478 lines
16 KiB
Kotlin
478 lines
16 KiB
Kotlin
package jp.juggler.subwaytooter.appsetting
|
|
|
|
import android.annotation.SuppressLint
|
|
import android.content.ContentValues
|
|
import android.content.Context
|
|
import android.content.SharedPreferences
|
|
import android.database.Cursor
|
|
import android.net.Uri
|
|
import android.provider.BaseColumns
|
|
import android.util.JsonReader
|
|
import android.util.JsonToken
|
|
import android.util.JsonWriter
|
|
import jp.juggler.subwaytooter.App1
|
|
import jp.juggler.subwaytooter.AppState
|
|
import jp.juggler.subwaytooter.api.entity.EntityId
|
|
import jp.juggler.subwaytooter.column.Column
|
|
import jp.juggler.subwaytooter.column.ColumnEncoder
|
|
import jp.juggler.subwaytooter.column.getBackgroundImageDir
|
|
import jp.juggler.subwaytooter.pref.PrefL
|
|
import jp.juggler.subwaytooter.pref.impl.*
|
|
import jp.juggler.subwaytooter.pref.lazyPref
|
|
import jp.juggler.subwaytooter.table.*
|
|
import jp.juggler.util.*
|
|
import jp.juggler.util.data.*
|
|
import jp.juggler.util.log.LogCategory
|
|
import java.io.File
|
|
import java.io.FileOutputStream
|
|
import java.io.IOException
|
|
import java.io.InputStream
|
|
import java.util.zip.ZipEntry
|
|
import java.util.zip.ZipOutputStream
|
|
|
|
object AppDataExporter {
|
|
|
|
internal val log = LogCategory("AppDataExporter")
|
|
|
|
@Suppress("FloatingPointLiteralPrecision")
|
|
private const val MAGIC_NAN = -76287755398823900.0
|
|
|
|
private const val KEY_PREF = "pref"
|
|
private const val KEY_ACCOUNT = "account"
|
|
private const val KEY_COLUMN = "column"
|
|
private const val KEY_ACCT_COLOR = "acct_color"
|
|
private const val KEY_MUTED_APP = "muted_app"
|
|
private const val KEY_MUTED_WORD = "muted_word"
|
|
private const val KEY_FAV_MUTE = "fav_mute"
|
|
|
|
// v3.4.5で廃止 private const val KEY_CLIENT_INFO = "client_info2"
|
|
private const val KEY_HIGHLIGHT_WORD = "highlight_word"
|
|
|
|
@Throws(IOException::class, JsonException::class)
|
|
private fun JsonWriter.writeJsonValue(v: Any?) {
|
|
when (v) {
|
|
null -> nullValue()
|
|
is String -> value(v)
|
|
is Boolean -> value(v)
|
|
is Number -> value(v)
|
|
is EntityId -> value(v.toString())
|
|
|
|
is JsonObject -> {
|
|
beginObject()
|
|
for (entry in v.entries) {
|
|
name(entry.key)
|
|
writeJsonValue(entry.value)
|
|
}
|
|
endObject()
|
|
}
|
|
|
|
is JsonArray -> {
|
|
beginArray()
|
|
for (value in v) {
|
|
writeJsonValue(v)
|
|
}
|
|
endArray()
|
|
}
|
|
|
|
else -> error("writeJsonValue: bad value type: $v")
|
|
}
|
|
}
|
|
|
|
@Throws(IOException::class, JsonException::class)
|
|
private fun JsonReader.readJsonValue(): Any? {
|
|
return when (peek()) {
|
|
JsonToken.NULL -> {
|
|
nextNull()
|
|
null
|
|
}
|
|
|
|
JsonToken.STRING -> nextString()
|
|
JsonToken.BOOLEAN -> nextBoolean()
|
|
JsonToken.NUMBER -> nextDouble()
|
|
JsonToken.BEGIN_OBJECT -> buildJsonObject {
|
|
beginObject()
|
|
while (hasNext()) {
|
|
val name = nextName()
|
|
val value = readJsonValue()
|
|
put(name, value)
|
|
}
|
|
endObject()
|
|
}
|
|
JsonToken.BEGIN_ARRAY -> buildJsonArray {
|
|
beginArray()
|
|
while (hasNext()) {
|
|
add(readJsonValue())
|
|
}
|
|
endArray()
|
|
}
|
|
else -> null
|
|
}
|
|
}
|
|
|
|
@Throws(IOException::class)
|
|
private fun writeFromTable(writer: JsonWriter, jsonKey: String, table: String) {
|
|
|
|
writer.name(jsonKey)
|
|
writer.beginArray()
|
|
|
|
appDatabase.rawQuery("select from $table", emptyArray()).use { cursor ->
|
|
val names = ArrayList<String>()
|
|
val column_count = cursor.columnCount
|
|
for (i in 0 until column_count) {
|
|
names.add(cursor.getColumnName(i))
|
|
}
|
|
while (cursor.moveToNext()) {
|
|
writer.beginObject()
|
|
|
|
for (i in 0 until column_count) {
|
|
when (cursor.getType(i)) {
|
|
Cursor.FIELD_TYPE_NULL -> {
|
|
writer.name(names[i])
|
|
writer.nullValue()
|
|
}
|
|
|
|
Cursor.FIELD_TYPE_INTEGER -> {
|
|
writer.name(names[i])
|
|
writer.value(cursor.getLong(i))
|
|
}
|
|
|
|
Cursor.FIELD_TYPE_STRING -> {
|
|
writer.name(names[i])
|
|
writer.value(cursor.getString(i))
|
|
}
|
|
|
|
Cursor.FIELD_TYPE_FLOAT -> {
|
|
val d = cursor.getDouble(i)
|
|
if (d.isNaN() || d.isInfinite()) {
|
|
log.w("column ${names[i]} is nan or infinite value.")
|
|
} else {
|
|
writer.name(names[i])
|
|
writer.value(d)
|
|
}
|
|
}
|
|
|
|
Cursor.FIELD_TYPE_BLOB -> log.w("column ${names[i]} is blob.")
|
|
}
|
|
}
|
|
|
|
writer.endObject()
|
|
}
|
|
}
|
|
writer.endArray()
|
|
}
|
|
|
|
@Throws(IOException::class)
|
|
private fun importTable(reader: JsonReader, table: String, idMap: HashMap<Long, Long>?) {
|
|
val db = appDatabase
|
|
if (table == SavedAccount.table) {
|
|
SavedAccount.onDBDelete(db)
|
|
SavedAccount.onDBCreate(db)
|
|
}
|
|
|
|
db.execSQL("BEGIN TRANSACTION")
|
|
try {
|
|
db.execSQL("delete from $table")
|
|
|
|
val cv = ContentValues()
|
|
|
|
reader.beginArray()
|
|
while (reader.hasNext()) {
|
|
|
|
var old_id = -1L
|
|
cv.clear()
|
|
|
|
reader.beginObject()
|
|
while (reader.hasNext()) {
|
|
val name = reader.nextName()
|
|
if (name == null) {
|
|
reader.skipValue()
|
|
continue
|
|
}
|
|
|
|
if (BaseColumns._ID == name) {
|
|
old_id = reader.nextLong()
|
|
continue
|
|
}
|
|
|
|
if (SavedAccount.table == table) {
|
|
when (name) {
|
|
// 一時的に存在したが現在のDBスキーマにはない項目は読み飛ばす
|
|
"nickname",
|
|
"color",
|
|
"notification_server",
|
|
"register_key",
|
|
"register_time",
|
|
"last_notification_error",
|
|
"last_subscription_error",
|
|
"last_push_endpoint",
|
|
-> {
|
|
reader.skipValue()
|
|
continue
|
|
}
|
|
else -> Unit
|
|
}
|
|
}
|
|
|
|
when (reader.peek()) {
|
|
JsonToken.NULL -> {
|
|
reader.skipValue()
|
|
cv.putNull(name)
|
|
}
|
|
|
|
JsonToken.BOOLEAN -> cv.put(name, if (reader.nextBoolean()) 1 else 0)
|
|
|
|
JsonToken.NUMBER -> cv.put(name, reader.nextLong())
|
|
|
|
JsonToken.STRING -> cv.put(name, reader.nextString())
|
|
|
|
else -> reader.skipValue()
|
|
}
|
|
}
|
|
reader.endObject()
|
|
val new_id = db.replace(table, null, cv)
|
|
if (new_id == -1L) error("importTable: invalid row_id")
|
|
idMap?.put(old_id, new_id)
|
|
}
|
|
reader.endArray()
|
|
db.execSQL("COMMIT TRANSACTION")
|
|
} catch (ex: Throwable) {
|
|
log.e(ex, "importTable failed.")
|
|
try {
|
|
db.execSQL("ROLLBACK TRANSACTION")
|
|
} catch (ignored: Throwable) {
|
|
}
|
|
|
|
throw ex
|
|
}
|
|
}
|
|
|
|
@Throws(IOException::class)
|
|
private fun writePref(writer: JsonWriter, pref: SharedPreferences) {
|
|
writer.name(KEY_PREF)
|
|
writer.beginObject()
|
|
for ((k, v) in pref.all) {
|
|
writer.name(k)
|
|
when (v) {
|
|
null -> writer.nullValue()
|
|
is String -> writer.value(v)
|
|
is Boolean -> writer.value(v)
|
|
is Number -> when {
|
|
(v is Double && v.isNaN()) -> writer.value(MAGIC_NAN)
|
|
(v is Float && v.isNaN()) -> writer.value(MAGIC_NAN)
|
|
else -> writer.value(v)
|
|
}
|
|
else -> error("writePref: bad data type. key=$k, type=${v.javaClass.simpleName}")
|
|
}
|
|
}
|
|
writer.endObject()
|
|
}
|
|
|
|
@Throws(IOException::class)
|
|
private fun importPref(reader: JsonReader, pref: SharedPreferences) {
|
|
val e = pref.edit()
|
|
reader.beginObject()
|
|
while (reader.hasNext()) {
|
|
val k = reader.nextName() ?: error("importPref: name is null")
|
|
|
|
val token = reader.peek()
|
|
if (token == JsonToken.NULL) {
|
|
reader.nextNull()
|
|
e.remove(k)
|
|
continue
|
|
}
|
|
|
|
when (val prefItem = BasePref.allPref[k]) {
|
|
is BooleanPref -> e.putBoolean(k, reader.nextBoolean())
|
|
is IntPref -> e.putInt(k, reader.nextInt())
|
|
is LongPref -> e.putLong(k, reader.nextLong())
|
|
|
|
is StringPref -> if (prefItem.skipImport) {
|
|
reader.skipValue()
|
|
e.remove(k)
|
|
} else {
|
|
e.putString(k, reader.nextString())
|
|
}
|
|
|
|
is FloatPref -> {
|
|
val dv = reader.nextDouble()
|
|
e.putFloat(k, if (dv <= MAGIC_NAN) Float.NaN else dv.toFloat())
|
|
}
|
|
|
|
else -> {
|
|
// ignore or force reset
|
|
reader.skipValue()
|
|
e.remove(k)
|
|
}
|
|
}
|
|
}
|
|
reader.endObject()
|
|
e.apply()
|
|
}
|
|
|
|
@Throws(IOException::class, JsonException::class)
|
|
private fun writeColumn(appState: AppState, writer: JsonWriter) {
|
|
writer.name(KEY_COLUMN)
|
|
writer.beginArray()
|
|
for (column in appState.columnList) {
|
|
writer.writeJsonValue(buildJsonObject { ColumnEncoder.encode(column, this, 0) })
|
|
}
|
|
writer.endArray()
|
|
}
|
|
|
|
@Throws(IOException::class, JsonException::class)
|
|
private fun readColumn(
|
|
appState: AppState,
|
|
reader: JsonReader,
|
|
idMap: HashMap<Long, Long>,
|
|
) = ArrayList<Column>().also { result ->
|
|
reader.beginArray()
|
|
while (reader.hasNext()) {
|
|
val item: JsonObject = reader.readJsonValue().cast()!!
|
|
|
|
// DB上のアカウントIDが変化したので置き換える
|
|
when (val old_id = item.long(ColumnEncoder.KEY_ACCOUNT_ROW_ID) ?: -1L) {
|
|
|
|
// 検索カラムのアカウントIDはNAアカウントと紐ついている。変換の必要はない
|
|
-1L -> {
|
|
}
|
|
|
|
else -> item[ColumnEncoder.KEY_ACCOUNT_ROW_ID] = idMap[old_id]
|
|
?: error("readColumn: can't convert account id")
|
|
}
|
|
|
|
try {
|
|
result.add(Column(appState, item))
|
|
} catch (ex: Throwable) {
|
|
log.e(ex, "column load failed.")
|
|
throw ex
|
|
}
|
|
}
|
|
reader.endArray()
|
|
}
|
|
|
|
@Throws(IOException::class, JsonException::class)
|
|
fun encodeAppData(context: Context, writer: JsonWriter) {
|
|
writer.setIndent(" ")
|
|
writer.beginObject()
|
|
|
|
val app_state = App1.getAppState(context)
|
|
|
|
writePref(writer, lazyPref)
|
|
|
|
writeFromTable(writer, KEY_ACCOUNT, SavedAccount.table)
|
|
writeFromTable(writer, KEY_ACCT_COLOR, AcctColor.table)
|
|
writeFromTable(writer, KEY_MUTED_APP, MutedApp.table)
|
|
writeFromTable(writer, KEY_MUTED_WORD, MutedWord.table)
|
|
writeFromTable(writer, KEY_FAV_MUTE, FavMute.table)
|
|
writeFromTable(writer, KEY_HIGHLIGHT_WORD, HighlightWord.table)
|
|
|
|
writeColumn(app_state, writer)
|
|
|
|
writer.endObject()
|
|
}
|
|
|
|
@SuppressLint("UseSparseArrays")
|
|
@Throws(IOException::class, JsonException::class)
|
|
internal fun decodeAppData(context: Context, reader: JsonReader): ArrayList<Column> {
|
|
|
|
var result: ArrayList<Column>? = null
|
|
|
|
val app_state = App1.getAppState(context)
|
|
reader.beginObject()
|
|
|
|
val account_id_map = HashMap<Long, Long>()
|
|
|
|
while (reader.hasNext()) {
|
|
when (reader.nextName()) {
|
|
KEY_PREF -> importPref(reader, lazyPref)
|
|
KEY_ACCOUNT -> importTable(reader, SavedAccount.table, account_id_map)
|
|
|
|
KEY_ACCT_COLOR -> {
|
|
importTable(reader, AcctColor.table, null)
|
|
daoAcctColor.clearMemoryCache()
|
|
}
|
|
|
|
KEY_MUTED_APP -> importTable(reader, MutedApp.table, null)
|
|
KEY_MUTED_WORD -> importTable(reader, MutedWord.table, null)
|
|
KEY_FAV_MUTE -> importTable(reader, FavMute.table, null)
|
|
KEY_HIGHLIGHT_WORD -> importTable(reader, HighlightWord.table, null)
|
|
KEY_COLUMN -> result = readColumn(app_state, reader, account_id_map)
|
|
|
|
// 端末間でクライアントIDを再利用することはできなくなった
|
|
// KEY_CLIENT_INFO -> importTable(reader, ClientInfo.table, null)
|
|
|
|
else -> reader.skipValue()
|
|
}
|
|
}
|
|
|
|
run {
|
|
val old_id = PrefL.lpTabletTootDefaultAccount.value
|
|
if (old_id != -1L) {
|
|
val new_id = account_id_map[old_id]
|
|
PrefL.lpTabletTootDefaultAccount.value = new_id ?: -1L
|
|
}
|
|
}
|
|
|
|
if (result == null) error("import data does not includes column list!")
|
|
|
|
return result
|
|
}
|
|
|
|
fun saveBackgroundImage(
|
|
context: Context,
|
|
zipStream: ZipOutputStream,
|
|
column: Column,
|
|
) {
|
|
try {
|
|
column.columnBgImage.mayUri()?.let { uri ->
|
|
context.contentResolver.openInputStream(uri)?.use { inStream ->
|
|
zipStream.putNextEntry(ZipEntry("background-image/${column.columnId}"))
|
|
try {
|
|
inStream.copyTo(zipStream)
|
|
} finally {
|
|
zipStream.closeEntry()
|
|
}
|
|
}
|
|
}
|
|
} catch (ex: Throwable) {
|
|
log.e(ex, "saveBackgroundImage failed.")
|
|
}
|
|
}
|
|
|
|
private val reBackgroundImage = "background-image/(.+)".asciiPattern()
|
|
|
|
// エントリが背景画像のソレなら真を返す
|
|
// column.column_bg_image を更新する場合がある
|
|
fun restoreBackgroundImage(
|
|
context: Context,
|
|
columnList: ArrayList<Column>?,
|
|
inStream: InputStream,
|
|
entryName: String,
|
|
): Boolean {
|
|
|
|
// entryName がバックグラウンド画像のそれと一致するか
|
|
val m = reBackgroundImage.matcher(entryName)
|
|
if (!m.find()) return false
|
|
|
|
try {
|
|
val id = m.groupEx(1)
|
|
val column = columnList?.find { it.columnId == id }
|
|
if (column == null) {
|
|
log.e("missing column for id $id")
|
|
} else {
|
|
val backgroundDir = getBackgroundImageDir(context)
|
|
val file =
|
|
File(backgroundDir, "${column.columnId}:${System.currentTimeMillis()}")
|
|
FileOutputStream(file).use { outStream ->
|
|
inStream.copyTo(outStream)
|
|
}
|
|
column.columnBgImage = Uri.fromFile(file).toString()
|
|
}
|
|
} catch (ex: Throwable) {
|
|
log.e(ex, "restoreBackgroundImage failed.")
|
|
}
|
|
|
|
return true
|
|
}
|
|
}
|