336 lines
13 KiB
Kotlin
336 lines
13 KiB
Kotlin
package jp.juggler.subwaytooter.table
|
|
|
|
import android.content.ContentValues
|
|
import android.database.sqlite.SQLiteDatabase
|
|
import android.provider.BaseColumns
|
|
import jp.juggler.subwaytooter.api.entity.Acct
|
|
import jp.juggler.subwaytooter.api.entity.EntityId
|
|
import jp.juggler.subwaytooter.api.entity.putMayNull
|
|
import jp.juggler.util.data.*
|
|
import jp.juggler.util.log.LogCategory
|
|
import java.util.concurrent.ConcurrentHashMap
|
|
|
|
class NotificationTracking {
|
|
|
|
private var dirty = false
|
|
|
|
private var id = -1L
|
|
set(value) {
|
|
dirty = true; field = value
|
|
}
|
|
|
|
// アカウントDBの行ID。 サーバ側のIDではない
|
|
private var accountDbId: Long = 0
|
|
set(value) {
|
|
dirty = true; field = value
|
|
}
|
|
|
|
// 返信だけ通知グループを分ける
|
|
private var notificationType: String = ""
|
|
set(value) {
|
|
dirty = true; field = value
|
|
}
|
|
|
|
// 通知ID。ここまで既読
|
|
var nid_read: EntityId? = null
|
|
set(value) {
|
|
dirty = true; field = value
|
|
}
|
|
|
|
// 通知ID。もっとも最近取得したもの
|
|
var nid_show: EntityId? = null
|
|
set(value) {
|
|
dirty = true; field = value
|
|
}
|
|
|
|
// 最後に表示した通知のID
|
|
var post_id: EntityId? = null
|
|
set(value) {
|
|
dirty = true; field = value
|
|
}
|
|
|
|
// 最後に表示した通知の作成時刻
|
|
var post_time: Long = 0
|
|
set(value) {
|
|
dirty = true; field = value
|
|
}
|
|
|
|
companion object : TableCompanion {
|
|
private val log = LogCategory("NotificationTracking")
|
|
override val table = "noti_trac"
|
|
private const val COL_ID = BaseColumns._ID
|
|
private const val COL_ACCOUNT_DB_ID = "a"
|
|
private const val COL_NID_READ = "nr"
|
|
private const val COL_NID_SHOW = "ns"
|
|
private const val COL_POST_ID = "pi"
|
|
private const val COL_POST_TIME = "pt"
|
|
private const val COL_NOTIFICATION_TYPE = "nt"
|
|
|
|
private val metaColumns = MetaColumns(table, initialVersion = 0).apply {
|
|
column(0, COL_ID, "INTEGER PRIMARY KEY")
|
|
column(0, COL_ACCOUNT_DB_ID, "integer not null")
|
|
column(0, COL_NID_READ, "text")
|
|
column(0, COL_NID_SHOW, "text")
|
|
column(0, COL_POST_ID, "text")
|
|
column(0, COL_POST_TIME, "integer default 0")
|
|
column(40, COL_NOTIFICATION_TYPE, "text default ''")
|
|
deleteBeforeCreate = true
|
|
createExtra = {
|
|
arrayOf(
|
|
"create unique index if not exists ${table}_b on $table($COL_ACCOUNT_DB_ID,$COL_NOTIFICATION_TYPE)"
|
|
)
|
|
}
|
|
}
|
|
|
|
override fun onDBCreate(db: SQLiteDatabase) {
|
|
metaColumns.onDBCreate(db)
|
|
}
|
|
|
|
override fun onDBUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
|
|
|
|
if (newVersion < oldVersion) {
|
|
try {
|
|
db.execSQL("drop table if exists $table")
|
|
} catch (ex: Throwable) {
|
|
log.e(ex, "delete DB failed.")
|
|
}
|
|
metaColumns.onDBCreate(db)
|
|
return
|
|
}
|
|
|
|
if (oldVersion < 2 && newVersion >= 2) {
|
|
metaColumns.onDBCreate(db)
|
|
return
|
|
}
|
|
|
|
if (oldVersion < 40 && newVersion >= 40) {
|
|
try {
|
|
db.execSQL("drop index if exists ${table}_a")
|
|
} catch (ex: Throwable) {
|
|
log.e(ex, "drop index failed.")
|
|
}
|
|
}
|
|
metaColumns.onDBUpgrade(db, oldVersion, newVersion)
|
|
if (oldVersion < 40 && newVersion >= 40) {
|
|
try {
|
|
db.execSQL(
|
|
"create unique index if not exists ${table}_b on $table ($COL_ACCOUNT_DB_ID,$COL_NOTIFICATION_TYPE)"
|
|
)
|
|
} catch (ex: Throwable) {
|
|
log.e(ex, "can't add index.")
|
|
}
|
|
}
|
|
}
|
|
|
|
private val cache =
|
|
ConcurrentHashMap<Long, ConcurrentHashMap<String, NotificationTracking>>()
|
|
|
|
private fun <K : Any, V : Any> ConcurrentHashMap<K, V>.getOrCreate(
|
|
key: K,
|
|
creator: () -> V,
|
|
): V {
|
|
var v = this[key]
|
|
if (v == null) v = creator().also { this[key] = it }
|
|
return v
|
|
}
|
|
|
|
private fun loadCache(accountDbId: Long, notificationType: String): NotificationTracking? =
|
|
cache[accountDbId]?.get(notificationType)
|
|
|
|
private fun clearCache(accountDbId: Long, notificationType: String): NotificationTracking? =
|
|
cache[accountDbId]?.remove(notificationType)
|
|
|
|
private fun saveCache(
|
|
accountDbId: Long,
|
|
notificationType: String,
|
|
nt: NotificationTracking,
|
|
) {
|
|
cache.getOrCreate(accountDbId) {
|
|
ConcurrentHashMap<String, NotificationTracking>()
|
|
}[notificationType] = nt
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
|
|
private const val WHERE_AID = "$COL_ACCOUNT_DB_ID=? and $COL_NOTIFICATION_TYPE=?"
|
|
}
|
|
|
|
fun toContentValues() = ContentValues().apply {
|
|
put(COL_ACCOUNT_DB_ID, accountDbId)
|
|
put(COL_NOTIFICATION_TYPE, notificationType)
|
|
nid_read.putMayNull(this, COL_NID_READ)
|
|
nid_show.putMayNull(this, COL_NID_SHOW)
|
|
post_id.putMayNull(this, COL_POST_ID)
|
|
put(COL_POST_TIME, post_time)
|
|
}
|
|
|
|
class Access(val db: SQLiteDatabase) {
|
|
|
|
fun load(
|
|
// ログ出力だけに使う
|
|
acct: Acct,
|
|
accountDbId: Long,
|
|
notificationType: String,
|
|
): NotificationTracking {
|
|
loadCache(accountDbId, notificationType)
|
|
?.takeIf { !it.dirty }
|
|
?.let {
|
|
log.d(
|
|
"${acct.pretty}/$notificationType load-cached. post=(${it.post_id},${it.post_time}), read=${it.nid_read}, show=${it.nid_show}"
|
|
)
|
|
return it
|
|
}
|
|
|
|
val whereArgs = arrayOf(accountDbId.toString(), notificationType)
|
|
val dst = NotificationTracking()
|
|
dst.accountDbId = accountDbId
|
|
dst.notificationType = notificationType
|
|
try {
|
|
db.rawQuery(
|
|
"select * from $table where $COL_ACCOUNT_DB_ID=? and $COL_NOTIFICATION_TYPE=?",
|
|
whereArgs,
|
|
)?.use { cursor ->
|
|
if (cursor.moveToFirst()) {
|
|
dst.id = cursor.getLong(COL_ID)
|
|
|
|
dst.post_id = EntityId.entityId(cursor, COL_POST_ID)
|
|
dst.post_time = cursor.getLong(COL_POST_TIME)
|
|
|
|
val show = EntityId.entityId(cursor, COL_NID_SHOW)
|
|
if (show == null) {
|
|
dst.nid_show = null
|
|
dst.nid_read = null
|
|
} else {
|
|
dst.nid_show = show
|
|
val read = EntityId.entityId(cursor, COL_NID_READ)
|
|
if (read == null) {
|
|
dst.nid_read = null
|
|
} else {
|
|
val r2 = minComparable(show, read)
|
|
dst.nid_read = r2
|
|
if (r2 != read) {
|
|
log.i("$acct/$notificationType read>show! clip to $show")
|
|
val cv = ContentValues()
|
|
show.putTo(cv, COL_NID_READ) //変数名とキー名が異なるのに注意
|
|
db.update(table, cv, WHERE_AID, whereArgs)
|
|
}
|
|
}
|
|
}
|
|
|
|
log.d(
|
|
"${acct.pretty}/$notificationType load. post=(${dst.post_id},${dst.post_time}), read=${dst.nid_read}, show=${dst.nid_show}"
|
|
)
|
|
saveCache(accountDbId, notificationType, dst)
|
|
}
|
|
}
|
|
} catch (ex: Throwable) {
|
|
log.e(ex, "${acct.pretty} load failed.")
|
|
} finally {
|
|
dst.dirty = false
|
|
}
|
|
return dst
|
|
}
|
|
|
|
fun updateRead(accountDbId: Long, notificationType: String) {
|
|
try {
|
|
val whereArgs = arrayOf(accountDbId.toString(), notificationType)
|
|
db.rawQuery(
|
|
"select $COL_NID_SHOW, $COL_NID_READ from $table where $COL_ACCOUNT_DB_ID=? and $COL_NOTIFICATION_TYPE=?",
|
|
whereArgs,
|
|
)?.use { cursor ->
|
|
when {
|
|
!cursor.moveToFirst() -> log.e("updateRead[$accountDbId,$notificationType]: can't find the data row.")
|
|
|
|
else -> {
|
|
val nid_show = EntityId.entityId(cursor, COL_NID_SHOW)
|
|
val nid_read = EntityId.entityId(cursor, COL_NID_READ)
|
|
when {
|
|
nid_show == null ->
|
|
log.e("updateRead[$accountDbId,$notificationType]: nid_show is null.")
|
|
|
|
nid_read != null && nid_read >= nid_show ->
|
|
log.e("updateRead[$accountDbId,$notificationType]: nid_read already updated.")
|
|
|
|
else -> {
|
|
log.i("updateRead[$accountDbId,$notificationType]: update nid_read as $nid_show...")
|
|
val cv = ContentValues()
|
|
nid_show.putTo(cv, COL_NID_READ) //変数名とキー名が異なるのに注意
|
|
db.update(table, cv, WHERE_AID, whereArgs)
|
|
clearCache(accountDbId, notificationType)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch (ex: Throwable) {
|
|
log.e(ex, "updateRead[$accountDbId] failed.")
|
|
}
|
|
}
|
|
|
|
fun resetPostAll() {
|
|
try {
|
|
val cv = ContentValues()
|
|
cv.putNull(COL_POST_ID)
|
|
cv.put(COL_POST_TIME, 0)
|
|
db.update(table, cv, null, null)
|
|
cache.clear()
|
|
} catch (ex: Throwable) {
|
|
log.e(ex, "resetPostAll failed.")
|
|
}
|
|
}
|
|
|
|
// アカウント設定から手動で呼ばれる
|
|
fun resetTrackingState(accountDbId: Long?) {
|
|
accountDbId ?: return
|
|
try {
|
|
db.delete(table, "$COL_ACCOUNT_DB_ID=?", arrayOf(accountDbId.toString()))
|
|
cache.remove(accountDbId)
|
|
} catch (ex: Throwable) {
|
|
log.e(ex, "resetTrackingState failed.")
|
|
}
|
|
}
|
|
|
|
fun save(
|
|
// ログ出力だけに使う
|
|
acct: Acct,
|
|
item: NotificationTracking,
|
|
) {
|
|
try {
|
|
if (!item.dirty) return
|
|
val rowId = item.toContentValues()
|
|
.replaceTo(db, table)
|
|
if (item.id == -1L) item.id = rowId
|
|
|
|
log.d("${acct.pretty}/${item.notificationType} save. post=(${item.post_id},${item.post_time})")
|
|
item.dirty = false
|
|
clearCache(item.accountDbId, item.notificationType)
|
|
} catch (ex: Throwable) {
|
|
log.e(ex, "save failed.")
|
|
}
|
|
}
|
|
|
|
fun updatePost(postId: EntityId, postTime: Long, item: NotificationTracking) {
|
|
try {
|
|
item.post_id = postId
|
|
item.post_time = postTime
|
|
if (!item.dirty) return
|
|
val cv = item.toContentValues().apply {
|
|
postId.putTo(this, COL_POST_ID)
|
|
put(COL_POST_TIME, postTime)
|
|
}
|
|
val rows = db.update(
|
|
table,
|
|
cv,
|
|
WHERE_AID,
|
|
arrayOf(item.accountDbId.toString(), item.notificationType)
|
|
)
|
|
log.d("updatePost account_db_id=${item.accountDbId}, nt=${item.notificationType}, post=${postId},${postTime} update_rows=${rows}")
|
|
item.dirty = false
|
|
clearCache(item.accountDbId, item.notificationType)
|
|
} catch (ex: Throwable) {
|
|
log.e(ex, "updatePost failed.")
|
|
}
|
|
}
|
|
}
|
|
}
|