1211 lines
36 KiB
Kotlin
1211 lines
36 KiB
Kotlin
package jp.juggler.subwaytooter.table
|
|
|
|
import android.content.ContentValues
|
|
import android.content.Context
|
|
import android.database.Cursor
|
|
import android.database.sqlite.SQLiteDatabase
|
|
import android.provider.BaseColumns
|
|
import jp.juggler.subwaytooter.App1
|
|
import jp.juggler.subwaytooter.R
|
|
import jp.juggler.subwaytooter.api.TootApiClient
|
|
import jp.juggler.subwaytooter.api.TootApiResult
|
|
import jp.juggler.subwaytooter.api.TootParser
|
|
import jp.juggler.subwaytooter.api.entity.*
|
|
import jp.juggler.subwaytooter.notification.PollingWorker
|
|
import jp.juggler.subwaytooter.util.LinkHelper
|
|
import jp.juggler.util.*
|
|
import java.util.*
|
|
import kotlin.math.max
|
|
|
|
class SavedAccount(
|
|
val db_id : Long,
|
|
acctArg : String,
|
|
apiHostArg : String? = null,
|
|
apDomainArg : String? = null,
|
|
var token_info : JsonObject? = null,
|
|
var loginAccount : TootAccount? = null, // 疑似アカウントではnull
|
|
override val misskeyVersion : Int = 0
|
|
) : LinkHelper {
|
|
|
|
// SavedAccountのロード時にhostを供給する必要があった
|
|
override val apiHost : Host
|
|
// fun findAcct(url : String?) : String? = null
|
|
// fun colorFromAcct(acct : String?) : AcctColor? = null
|
|
|
|
override val apDomain : Host
|
|
|
|
val username : String
|
|
|
|
val acct : Acct
|
|
|
|
var visibility : TootVisibility = TootVisibility.Public
|
|
var confirm_boost : Boolean = false
|
|
var confirm_favourite : Boolean = false
|
|
var confirm_unboost : Boolean = false
|
|
var confirm_unfavourite : Boolean = false
|
|
|
|
var dont_hide_nsfw : Boolean = false
|
|
var dont_show_timeout : Boolean = false
|
|
|
|
var notification_mention : Boolean = false
|
|
var notification_boost : Boolean = false
|
|
var notification_favourite : Boolean = false
|
|
var notification_follow : Boolean = false
|
|
var notification_follow_request : Boolean = false
|
|
var notification_reaction : Boolean = false
|
|
var notification_vote : Boolean = false
|
|
var notification_post : Boolean = false
|
|
var sound_uri = ""
|
|
|
|
var confirm_follow : Boolean = false
|
|
var confirm_follow_locked : Boolean = false
|
|
var confirm_unfollow : Boolean = false
|
|
var confirm_post : Boolean = false
|
|
|
|
var notification_tag : String? = null
|
|
private var register_key : String? = null
|
|
private var register_time : Long = 0
|
|
var default_text : String = ""
|
|
|
|
var default_sensitive = false
|
|
var expand_cw = false
|
|
|
|
var max_toot_chars = 0
|
|
|
|
var last_notification_error : String? = null
|
|
var last_subscription_error : String? = null
|
|
var last_push_endpoint : String? = null
|
|
|
|
var image_resize: String? = null
|
|
var image_max_megabytes : String? = null
|
|
var movie_max_megabytes : String? = null
|
|
|
|
var push_policy : String? = null
|
|
|
|
init {
|
|
val tmpAcct = Acct.parse(acctArg)
|
|
this.username = tmpAcct.username
|
|
if(username.isEmpty()) throw RuntimeException("missing username in acct")
|
|
|
|
val tmpApiHost = apiHostArg?.notEmpty()?.let { Host.parse(it) }
|
|
val tmpApDomain = apDomainArg?.notEmpty()?.let { Host.parse(it) }
|
|
|
|
this.apiHost = tmpApiHost ?: tmpApDomain ?: tmpAcct.host ?: error("missing apiHost")
|
|
this.apDomain = tmpApDomain ?: tmpApiHost ?: tmpAcct.host ?: error("missing apDomain")
|
|
|
|
this.acct = tmpAcct.followHost(apDomain)
|
|
}
|
|
|
|
constructor(context : Context, cursor : Cursor) : this(
|
|
db_id = cursor.getLong(COL_ID), // db_id
|
|
acctArg = cursor.getString(COL_USER), // acct
|
|
apiHostArg = cursor.getStringOrNull(COL_HOST), // host
|
|
apDomainArg = cursor.getStringOrNull(COL_DOMAIN), // host
|
|
misskeyVersion = cursor.getInt(COL_MISSKEY_VERSION)
|
|
) {
|
|
val strAccount = cursor.getString(COL_ACCOUNT)
|
|
val jsonAccount = strAccount.decodeJsonObject()
|
|
|
|
loginAccount = if(jsonAccount["id"] == null) {
|
|
null // 疑似アカウント
|
|
} else {
|
|
TootParser(
|
|
context,
|
|
LinkHelper.create(
|
|
apiHostArg = this@SavedAccount.apiHost,
|
|
apDomainArg = this@SavedAccount.apDomain,
|
|
misskeyVersion = misskeyVersion
|
|
)
|
|
).account(jsonAccount)
|
|
?: error("missing loginAccount for $strAccount")
|
|
}
|
|
|
|
val sv = cursor.getStringOrNull(COL_VISIBILITY)
|
|
visibility = TootVisibility.parseSavedVisibility(sv) ?: TootVisibility.Public
|
|
|
|
confirm_boost = cursor.getBoolean(COL_CONFIRM_BOOST)
|
|
confirm_favourite = cursor.getBoolean(COL_CONFIRM_FAVOURITE)
|
|
confirm_unboost = cursor.getBoolean(COL_CONFIRM_UNBOOST)
|
|
confirm_unfavourite = cursor.getBoolean(COL_CONFIRM_UNFAVOURITE)
|
|
confirm_follow = cursor.getBoolean(COL_CONFIRM_FOLLOW)
|
|
confirm_follow_locked = cursor.getBoolean(COL_CONFIRM_FOLLOW_LOCKED)
|
|
confirm_unfollow = cursor.getBoolean(COL_CONFIRM_UNFOLLOW)
|
|
confirm_post = cursor.getBoolean(COL_CONFIRM_POST)
|
|
|
|
notification_mention = cursor.getBoolean(COL_NOTIFICATION_MENTION)
|
|
notification_boost = cursor.getBoolean(COL_NOTIFICATION_BOOST)
|
|
notification_favourite = cursor.getBoolean(COL_NOTIFICATION_FAVOURITE)
|
|
notification_follow = cursor.getBoolean(COL_NOTIFICATION_FOLLOW)
|
|
notification_follow_request = cursor.getBoolean(COL_NOTIFICATION_FOLLOW_REQUEST)
|
|
notification_reaction = cursor.getBoolean(COL_NOTIFICATION_REACTION)
|
|
notification_vote = cursor.getBoolean(COL_NOTIFICATION_VOTE)
|
|
notification_post = cursor.getBoolean(COL_NOTIFICATION_POST)
|
|
|
|
dont_hide_nsfw = cursor.getBoolean(COL_DONT_HIDE_NSFW)
|
|
dont_show_timeout = cursor.getBoolean(COL_DONT_SHOW_TIMEOUT)
|
|
|
|
notification_tag = cursor.getStringOrNull(COL_NOTIFICATION_TAG)
|
|
|
|
register_key = cursor.getStringOrNull(COL_REGISTER_KEY)
|
|
|
|
register_time = cursor.getLong(COL_REGISTER_TIME)
|
|
|
|
token_info = cursor.getString(COL_TOKEN).decodeJsonObject()
|
|
|
|
sound_uri = cursor.getString(COL_SOUND_URI)
|
|
|
|
default_text = cursor.getStringOrNull(COL_DEFAULT_TEXT) ?: ""
|
|
|
|
default_sensitive = cursor.getBoolean(COL_DEFAULT_SENSITIVE)
|
|
expand_cw = cursor.getBoolean(COL_EXPAND_CW)
|
|
max_toot_chars = cursor.getInt(COL_MAX_TOOT_CHARS)
|
|
|
|
last_notification_error = cursor.getStringOrNull(COL_LAST_NOTIFICATION_ERROR)
|
|
last_subscription_error = cursor.getStringOrNull(COL_LAST_SUBSCRIPTION_ERROR)
|
|
last_push_endpoint = cursor.getStringOrNull(COL_LAST_PUSH_ENDPOINT)
|
|
|
|
image_resize = cursor.getStringOrNull(COL_IMAGE_RESIZE)
|
|
image_max_megabytes = cursor.getStringOrNull(COL_IMAGE_MAX_MEGABYTES)
|
|
movie_max_megabytes = cursor.getStringOrNull(COL_MOVIE_MAX_MEGABYTES)
|
|
push_policy = cursor.getStringOrNull(COL_PUSH_POLICY)
|
|
}
|
|
|
|
val isNA : Boolean
|
|
get() = acct == Acct.UNKNOWN
|
|
|
|
val isPseudo : Boolean
|
|
get() = username == "?"
|
|
|
|
fun delete() {
|
|
try {
|
|
App1.database.delete(table, "$COL_ID=?", arrayOf(db_id.toString()))
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
throw RuntimeException("SavedAccount.delete failed.", ex)
|
|
}
|
|
|
|
}
|
|
|
|
fun updateTokenInfo(tokenInfoArg : JsonObject?) {
|
|
|
|
if(db_id == INVALID_DB_ID) throw RuntimeException("updateTokenInfo: missing db_id")
|
|
|
|
val token_info = tokenInfoArg ?: JsonObject()
|
|
this.token_info = token_info
|
|
|
|
val cv = ContentValues()
|
|
cv.put(COL_TOKEN, token_info.toString())
|
|
App1.database.update(table, cv, "$COL_ID=?", arrayOf(db_id.toString()))
|
|
}
|
|
|
|
fun saveSetting() {
|
|
|
|
if(db_id == INVALID_DB_ID) throw RuntimeException("saveSetting: missing db_id")
|
|
|
|
val cv = ContentValues()
|
|
cv.put(COL_VISIBILITY, visibility.id.toString())
|
|
cv.put(COL_CONFIRM_BOOST, confirm_boost.b2i())
|
|
cv.put(COL_CONFIRM_FAVOURITE, confirm_favourite.b2i())
|
|
cv.put(COL_CONFIRM_UNBOOST, confirm_unboost.b2i())
|
|
cv.put(COL_CONFIRM_UNFAVOURITE, confirm_unfavourite.b2i())
|
|
|
|
cv.put(COL_DONT_HIDE_NSFW, dont_hide_nsfw.b2i())
|
|
cv.put(COL_DONT_SHOW_TIMEOUT, dont_show_timeout.b2i())
|
|
cv.put(COL_NOTIFICATION_MENTION, notification_mention.b2i())
|
|
cv.put(COL_NOTIFICATION_BOOST, notification_boost.b2i())
|
|
cv.put(COL_NOTIFICATION_FAVOURITE, notification_favourite.b2i())
|
|
cv.put(COL_NOTIFICATION_FOLLOW, notification_follow.b2i())
|
|
cv.put(COL_NOTIFICATION_FOLLOW_REQUEST, notification_follow_request.b2i())
|
|
cv.put(COL_NOTIFICATION_REACTION, notification_reaction.b2i())
|
|
cv.put(COL_NOTIFICATION_VOTE, notification_vote.b2i())
|
|
cv.put(COL_NOTIFICATION_POST, notification_post.b2i())
|
|
|
|
cv.put(COL_CONFIRM_FOLLOW, confirm_follow.b2i())
|
|
cv.put(COL_CONFIRM_FOLLOW_LOCKED, confirm_follow_locked.b2i())
|
|
cv.put(COL_CONFIRM_UNFOLLOW, confirm_unfollow.b2i())
|
|
cv.put(COL_CONFIRM_POST, confirm_post.b2i())
|
|
|
|
cv.put(COL_SOUND_URI, sound_uri)
|
|
cv.put(COL_DEFAULT_TEXT, default_text)
|
|
|
|
cv.put(COL_DEFAULT_SENSITIVE, default_sensitive.b2i())
|
|
cv.put(COL_EXPAND_CW, expand_cw.b2i())
|
|
cv.put(COL_MAX_TOOT_CHARS, max_toot_chars)
|
|
|
|
cv.putOrNull(COL_IMAGE_RESIZE,image_resize)
|
|
cv.putOrNull(COL_IMAGE_MAX_MEGABYTES, image_max_megabytes)
|
|
cv.putOrNull(COL_MOVIE_MAX_MEGABYTES, movie_max_megabytes)
|
|
cv.putOrNull(COL_PUSH_POLICY,push_policy)
|
|
|
|
// UIからは更新しない
|
|
// notification_tag
|
|
// register_key
|
|
|
|
App1.database.update(table, cv, "$COL_ID=?", arrayOf(db_id.toString()))
|
|
}
|
|
|
|
// fun saveNotificationTag() {
|
|
// if(db_id == INVALID_DB_ID)
|
|
// throw RuntimeException("SavedAccount.saveNotificationTag missing db_id")
|
|
//
|
|
// val cv = ContentValues()
|
|
// cv.put(COL_NOTIFICATION_TAG, notification_tag)
|
|
//
|
|
// App1.database.update(table, cv, "$COL_ID=?", arrayOf(db_id.toString()))
|
|
// }
|
|
//
|
|
// fun saveRegisterKey() {
|
|
// if(db_id == INVALID_DB_ID)
|
|
// throw RuntimeException("SavedAccount.saveRegisterKey missing db_id")
|
|
//
|
|
// val cv = ContentValues()
|
|
// cv.put(COL_REGISTER_KEY, register_key)
|
|
// cv.put(COL_REGISTER_TIME, register_time)
|
|
//
|
|
// App1.database.update(table, cv, "$COL_ID=?", arrayOf(db_id.toString()))
|
|
// }
|
|
|
|
// onResumeの時に設定を読み直す
|
|
fun reloadSetting(context : Context) {
|
|
|
|
if(db_id == INVALID_DB_ID)
|
|
throw RuntimeException("SavedAccount.reloadSetting missing db_id")
|
|
|
|
// DBから削除されてるかもしれない
|
|
val b = loadAccount(context, db_id) ?: return
|
|
|
|
this.visibility = b.visibility
|
|
this.confirm_boost = b.confirm_boost
|
|
this.confirm_favourite = b.confirm_favourite
|
|
this.confirm_unboost = b.confirm_unboost
|
|
this.confirm_unfavourite = b.confirm_unfavourite
|
|
|
|
this.dont_hide_nsfw = b.dont_hide_nsfw
|
|
this.dont_show_timeout = b.dont_show_timeout
|
|
this.token_info = b.token_info
|
|
this.notification_mention = b.notification_mention
|
|
this.notification_boost = b.notification_boost
|
|
this.notification_favourite = b.notification_favourite
|
|
this.notification_follow = b.notification_follow
|
|
this.notification_follow_request = b.notification_follow_request
|
|
this.notification_reaction = b.notification_reaction
|
|
this.notification_vote = b.notification_vote
|
|
this.notification_post = b.notification_post
|
|
|
|
this.notification_tag = b.notification_tag
|
|
this.default_text = b.default_text
|
|
this.default_sensitive = b.default_sensitive
|
|
this.expand_cw = b.expand_cw
|
|
|
|
this.sound_uri = b.sound_uri
|
|
|
|
this.image_resize = b.image_resize
|
|
this.image_max_megabytes = b.image_max_megabytes
|
|
this.movie_max_megabytes = b.movie_max_megabytes
|
|
this.push_policy = b.push_policy
|
|
}
|
|
|
|
fun getFullAcct(who : TootAccount?) = getFullAcct(who?.acct)
|
|
|
|
fun isRemoteUser(who : TootAccount) : Boolean = ! isLocalUser(who.acct)
|
|
fun isLocalUser(who : TootAccount?) : Boolean = isLocalUser(who?.acct)
|
|
private fun isLocalUser(acct : Acct?) : Boolean {
|
|
acct ?: return false
|
|
return acct.host == null || acct.host == this.apDomain
|
|
}
|
|
|
|
// fun isRemoteUser(acct : String) : Boolean {
|
|
// return ! isLocalUser(acct)
|
|
// }
|
|
|
|
fun isMe(who : TootAccount?) : Boolean = isMe(who?.acct)
|
|
// fun isMe(who_acct : String) : Boolean = isMe(Acct.parse(who_acct))
|
|
|
|
fun isMe(who_acct : Acct?) : Boolean {
|
|
who_acct ?: return false
|
|
if(who_acct.username != this.acct.username) return false
|
|
return who_acct.host == null || who_acct.host == this.acct.host
|
|
}
|
|
|
|
fun supplyBaseUrl(url : String?) : String? {
|
|
return when {
|
|
url == null || url.isEmpty() -> return null
|
|
url[0] == '/' -> "https://${apiHost.ascii}$url"
|
|
else -> url
|
|
}
|
|
}
|
|
|
|
fun isNicoru(account : TootAccount?) : Boolean = account?.apiHost == Host.FRIENDS_NICO
|
|
|
|
companion object : TableCompanion {
|
|
|
|
private val log = LogCategory("SavedAccount")
|
|
|
|
const val table = "access_info"
|
|
|
|
private const val COL_ID = BaseColumns._ID
|
|
private const val COL_HOST = "h"
|
|
private const val COL_DOMAIN = "d"
|
|
private const val COL_USER = "u"
|
|
private const val COL_ACCOUNT = "a"
|
|
private const val COL_TOKEN = "t"
|
|
|
|
private const val COL_VISIBILITY = "visibility"
|
|
private const val COL_CONFIRM_BOOST = "confirm_boost"
|
|
private const val COL_DONT_HIDE_NSFW = "dont_hide_nsfw"
|
|
|
|
private const val COL_NOTIFICATION_MENTION = "notification_mention" // スキーマ2
|
|
private const val COL_NOTIFICATION_BOOST = "notification_boost" // スキーマ2
|
|
private const val COL_NOTIFICATION_FAVOURITE = "notification_favourite" // スキーマ2
|
|
private const val COL_NOTIFICATION_FOLLOW = "notification_follow" // スキーマ2
|
|
private const val COL_NOTIFICATION_FOLLOW_REQUEST = "notification_follow_request" // スキーマ44
|
|
private const val COL_NOTIFICATION_REACTION = "notification_reaction" // スキーマ33
|
|
private const val COL_NOTIFICATION_VOTE = "notification_vote" // スキーマ33
|
|
private const val COL_NOTIFICATION_POST = "notification_post" // スキーマ57
|
|
|
|
private const val COL_CONFIRM_FOLLOW = "confirm_follow" // スキーマ10
|
|
private const val COL_CONFIRM_FOLLOW_LOCKED = "confirm_follow_locked" // スキーマ10
|
|
private const val COL_CONFIRM_UNFOLLOW = "confirm_unfollow" // スキーマ10
|
|
private const val COL_CONFIRM_POST = "confirm_post" // スキーマ10
|
|
private const val COL_CONFIRM_FAVOURITE = "confirm_favourite" // スキーマ23
|
|
private const val COL_CONFIRM_UNBOOST = "confirm_unboost" // スキーマ24
|
|
private const val COL_CONFIRM_UNFAVOURITE = "confirm_unfavourite" // スキーマ24
|
|
|
|
// スキーマ13から
|
|
const val COL_NOTIFICATION_TAG = "notification_server"
|
|
|
|
// スキーマ14から
|
|
const val COL_REGISTER_KEY = "register_key"
|
|
const val COL_REGISTER_TIME = "register_time"
|
|
|
|
// スキーマ16から
|
|
private const val COL_SOUND_URI = "sound_uri"
|
|
|
|
// スキーマ18から
|
|
private const val COL_DONT_SHOW_TIMEOUT = "dont_show_timeout"
|
|
|
|
// スキーマ27から
|
|
private const val COL_DEFAULT_TEXT = "default_text"
|
|
|
|
// スキーマ28から
|
|
private const val COL_MISSKEY_VERSION = "is_misskey" // カラム名がおかしいのは、昔はboolean扱いだったから
|
|
// 0: not misskey
|
|
// 1: old(v10) misskey
|
|
// 11: misskey v11
|
|
|
|
private const val COL_DEFAULT_SENSITIVE = "default_sensitive"
|
|
private const val COL_EXPAND_CW = "expand_cw"
|
|
private const val COL_MAX_TOOT_CHARS = "max_toot_chars"
|
|
|
|
private const val COL_LAST_NOTIFICATION_ERROR = "last_notification_error" // スキーマ42
|
|
private const val COL_LAST_SUBSCRIPTION_ERROR = "last_subscription_error" // スキーマ45
|
|
private const val COL_LAST_PUSH_ENDPOINT = "last_push_endpoint" // スキーマ46
|
|
|
|
private const val COL_IMAGE_RESIZE = "image_resize" // スキーマ59
|
|
private const val COL_IMAGE_MAX_MEGABYTES = "image_max_megabytes" // スキーマ59
|
|
private const val COL_MOVIE_MAX_MEGABYTES = "movie_max_megabytes" // スキーマ59
|
|
|
|
private const val COL_PUSH_POLICY = "push_policy" // スキーマ60
|
|
|
|
/////////////////////////////////
|
|
// login information
|
|
const val INVALID_DB_ID = - 1L
|
|
|
|
// アプリデータのインポート時に呼ばれる
|
|
fun onDBDelete(db : SQLiteDatabase) {
|
|
try {
|
|
db.execSQL("drop table if exists $table")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
}
|
|
|
|
override fun onDBCreate(db : SQLiteDatabase) {
|
|
db.execSQL(
|
|
"create table if not exists $table"
|
|
+ "($COL_ID INTEGER PRIMARY KEY"
|
|
+ ",$COL_USER text not null"
|
|
+ ",$COL_HOST text not null"
|
|
+ ",$COL_ACCOUNT text not null"
|
|
+ ",$COL_TOKEN text not null"
|
|
+ ",$COL_VISIBILITY text"
|
|
+ ",$COL_CONFIRM_BOOST integer default 1"
|
|
+ ",$COL_DONT_HIDE_NSFW integer default 0"
|
|
|
|
// 以下はDBスキーマ2で追加
|
|
+ ",$COL_NOTIFICATION_MENTION integer default 1"
|
|
+ ",$COL_NOTIFICATION_BOOST integer default 1"
|
|
+ ",$COL_NOTIFICATION_FAVOURITE integer default 1"
|
|
+ ",$COL_NOTIFICATION_FOLLOW integer default 1"
|
|
|
|
// 以下はDBスキーマ10で更新
|
|
+ ",$COL_CONFIRM_FOLLOW integer default 1"
|
|
+ ",$COL_CONFIRM_FOLLOW_LOCKED integer default 1"
|
|
+ ",$COL_CONFIRM_UNFOLLOW integer default 1"
|
|
+ ",$COL_CONFIRM_POST integer default 1"
|
|
|
|
// 以下はDBスキーマ13で更新
|
|
+ ",$COL_NOTIFICATION_TAG text default ''"
|
|
|
|
// 以下はDBスキーマ14で更新
|
|
+ ",$COL_REGISTER_KEY text default ''"
|
|
+ ",$COL_REGISTER_TIME integer default 0"
|
|
|
|
// 以下はDBスキーマ16で更新
|
|
+ ",$COL_SOUND_URI text default ''"
|
|
|
|
// 以下はDBスキーマ18で更新
|
|
+ ",$COL_DONT_SHOW_TIMEOUT integer default 0"
|
|
|
|
// 以下はDBスキーマ23で更新
|
|
+ ",$COL_CONFIRM_FAVOURITE integer default 1"
|
|
|
|
// 以下はDBスキーマ24で更新
|
|
+ ",$COL_CONFIRM_UNBOOST integer default 1"
|
|
+ ",$COL_CONFIRM_UNFAVOURITE integer default 1"
|
|
|
|
// 以下はDBスキーマ27で更新
|
|
+ ",$COL_DEFAULT_TEXT text default ''"
|
|
|
|
// 以下はDBスキーマ28で更新
|
|
+ ",$COL_MISSKEY_VERSION integer default 0"
|
|
|
|
// スキーマ33から
|
|
+ ",$COL_NOTIFICATION_REACTION integer default 1"
|
|
+ ",$COL_NOTIFICATION_VOTE integer default 1"
|
|
|
|
// スキーマ37から
|
|
+ ",$COL_DEFAULT_SENSITIVE integer default 0"
|
|
+ ",$COL_EXPAND_CW integer default 0"
|
|
|
|
// スキーマ39から
|
|
+ ",$COL_MAX_TOOT_CHARS integer default 0"
|
|
|
|
// スキーマ42から
|
|
+ ",$COL_LAST_NOTIFICATION_ERROR text"
|
|
|
|
// スキーマ44から
|
|
+ ",$COL_NOTIFICATION_FOLLOW_REQUEST integer default 1"
|
|
|
|
// スキーマ45から
|
|
+ ",$COL_LAST_SUBSCRIPTION_ERROR text"
|
|
|
|
// スキーマ46から
|
|
+ ",$COL_LAST_PUSH_ENDPOINT text"
|
|
|
|
// スキーマ56から
|
|
+ ",$COL_DOMAIN text"
|
|
|
|
// スキーマ57から
|
|
+ ",$COL_NOTIFICATION_POST integer default 1"
|
|
|
|
// スキーマ59から
|
|
+ ",$COL_IMAGE_RESIZE text default null"
|
|
+ ",$COL_IMAGE_MAX_MEGABYTES text default null"
|
|
+ ",$COL_MOVIE_MAX_MEGABYTES text default null"
|
|
|
|
// スキーマ60から
|
|
+ ",$COL_PUSH_POLICY text default null"
|
|
|
|
+ ")"
|
|
)
|
|
db.execSQL("create index if not exists ${table}_user on ${table}(u)")
|
|
db.execSQL("create index if not exists ${table}_host on ${table}(h,u)")
|
|
}
|
|
|
|
override fun onDBUpgrade(db : SQLiteDatabase, oldVersion : Int, newVersion : Int) {
|
|
fun isUpgraded(n:Int,block:()->Unit){
|
|
if( oldVersion < n && newVersion >= n ) block()
|
|
}
|
|
|
|
isUpgraded(2){
|
|
try {
|
|
db.execSQL("alter table $table add column notification_mention integer default 1")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
|
|
try {
|
|
db.execSQL("alter table $table add column notification_boost integer default 1")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
|
|
try {
|
|
db.execSQL("alter table $table add column notification_favourite integer default 1")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
|
|
try {
|
|
db.execSQL("alter table $table add column notification_follow integer default 1")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
|
|
}
|
|
isUpgraded( 10) {
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_CONFIRM_FOLLOW integer default 1")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_CONFIRM_FOLLOW_LOCKED integer default 1")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_CONFIRM_UNFOLLOW integer default 1")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_CONFIRM_POST integer default 1")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
|
|
}
|
|
isUpgraded( 13) {
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_NOTIFICATION_TAG text default ''")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
|
|
}
|
|
isUpgraded( 14) {
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_REGISTER_KEY text default ''")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_REGISTER_TIME integer default 0")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
|
|
}
|
|
isUpgraded( 16) {
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_SOUND_URI text default ''")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
|
|
}
|
|
isUpgraded( 18) {
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_DONT_SHOW_TIMEOUT integer default 0")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
|
|
}
|
|
isUpgraded( 23) {
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_CONFIRM_FAVOURITE integer default 1")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
|
|
}
|
|
isUpgraded( 24) {
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_CONFIRM_UNFAVOURITE integer default 1")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_CONFIRM_UNBOOST integer default 1")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
|
|
}
|
|
isUpgraded( 27) {
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_DEFAULT_TEXT text default ''")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
|
|
}
|
|
isUpgraded( 28) {
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_MISSKEY_VERSION integer default 0")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
}
|
|
|
|
isUpgraded( 33) {
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_NOTIFICATION_REACTION integer default 1")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_NOTIFICATION_VOTE integer default 1")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
}
|
|
|
|
isUpgraded( 38) {
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_DEFAULT_SENSITIVE integer default 0")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_EXPAND_CW integer default 0")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
|
|
}
|
|
|
|
isUpgraded( 39) {
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_MAX_TOOT_CHARS integer default 0")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
}
|
|
|
|
isUpgraded( 42) {
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_LAST_NOTIFICATION_ERROR text")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
}
|
|
|
|
isUpgraded( 44) {
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_NOTIFICATION_FOLLOW_REQUEST integer default 1")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
}
|
|
|
|
isUpgraded( 45) {
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_LAST_SUBSCRIPTION_ERROR text")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
}
|
|
isUpgraded(46) {
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_LAST_PUSH_ENDPOINT text")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
}
|
|
isUpgraded( 56) {
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_DOMAIN text")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
}
|
|
isUpgraded( 57) {
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_NOTIFICATION_POST integer default 1")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
|
|
}
|
|
isUpgraded( 59) {
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_IMAGE_RESIZE text default null")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_IMAGE_MAX_MEGABYTES text default null")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_MOVIE_MAX_MEGABYTES text default null")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
}
|
|
isUpgraded( 60) {
|
|
try {
|
|
db.execSQL("alter table $table add column $COL_PUSH_POLICY text default null")
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
}
|
|
}
|
|
|
|
val defaultResizeConfig = ResizeConfig(ResizeType.LongSide, 1280)
|
|
|
|
internal val resizeConfigList = arrayOf(
|
|
ResizeConfig(ResizeType.None, 0),
|
|
|
|
ResizeConfig(ResizeType.LongSide, 640),
|
|
ResizeConfig(ResizeType.LongSide, 800),
|
|
ResizeConfig(ResizeType.LongSide, 1024),
|
|
ResizeConfig(ResizeType.LongSide, 1280),
|
|
ResizeConfig(ResizeType.LongSide, 1600),
|
|
ResizeConfig(ResizeType.LongSide, 2048),
|
|
|
|
ResizeConfig(ResizeType.SquarePixel, 640),
|
|
ResizeConfig(ResizeType.SquarePixel, 800),
|
|
ResizeConfig(ResizeType.SquarePixel, 1024),
|
|
ResizeConfig(ResizeType.SquarePixel, 1280),
|
|
ResizeConfig(ResizeType.SquarePixel, 1440, R.string.size_1920_1080),
|
|
ResizeConfig(ResizeType.SquarePixel, 1600),
|
|
ResizeConfig(ResizeType.SquarePixel, 2048)
|
|
)
|
|
|
|
// 横断検索用の、何とも紐ついていないアカウント
|
|
// 保存しない。
|
|
val na : SavedAccount by lazy {
|
|
val dst = SavedAccount(- 1L, "?@?")
|
|
dst.notification_follow = false
|
|
dst.notification_follow_request = false
|
|
dst.notification_favourite = false
|
|
dst.notification_boost = false
|
|
dst.notification_mention = false
|
|
dst.notification_reaction = false
|
|
dst.notification_vote = false
|
|
dst.notification_post = false
|
|
|
|
dst
|
|
}
|
|
|
|
private fun parse(context : Context, cursor : Cursor) : SavedAccount? {
|
|
return try {
|
|
SavedAccount(context, cursor)
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
log.e(ex, "parse failed.")
|
|
null
|
|
}
|
|
}
|
|
|
|
fun insert(
|
|
acct : String,
|
|
host : String,
|
|
domain : String?,
|
|
account : JsonObject,
|
|
token : JsonObject,
|
|
misskeyVersion : Int = 0
|
|
) : Long {
|
|
try {
|
|
val cv = ContentValues()
|
|
cv.put(COL_USER, acct)
|
|
cv.put(COL_HOST, host)
|
|
cv.putOrNull(COL_DOMAIN, domain)
|
|
cv.put(COL_ACCOUNT, account.toString())
|
|
cv.put(COL_TOKEN, token.toString())
|
|
cv.put(COL_MISSKEY_VERSION, misskeyVersion)
|
|
return App1.database.insert(table, null, cv)
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
throw RuntimeException("SavedAccount.insert failed.", ex)
|
|
}
|
|
|
|
}
|
|
|
|
private const val REGISTER_KEY_UNREGISTERED = "unregistered"
|
|
|
|
fun clearRegistrationCache() {
|
|
val cv = ContentValues()
|
|
cv.put(COL_REGISTER_KEY, REGISTER_KEY_UNREGISTERED)
|
|
cv.put(COL_REGISTER_TIME, 0L)
|
|
App1.database.update(table, cv, null, null)
|
|
}
|
|
|
|
fun loadAccount(context : Context, db_id : Long) : SavedAccount? {
|
|
try {
|
|
App1.database.query(
|
|
table,
|
|
null,
|
|
"$COL_ID=?",
|
|
arrayOf(db_id.toString()),
|
|
null,
|
|
null,
|
|
null
|
|
)
|
|
.use { cursor ->
|
|
if(cursor.moveToFirst()) {
|
|
return parse(context, cursor)
|
|
}
|
|
log.e("moveToFirst failed. db_id=$db_id")
|
|
}
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
log.e(ex, "loadAccount failed.")
|
|
}
|
|
|
|
return null
|
|
}
|
|
|
|
fun loadAccountList(context : Context) : ArrayList<SavedAccount> {
|
|
val result = ArrayList<SavedAccount>()
|
|
try {
|
|
App1.database.query(
|
|
table,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null
|
|
)
|
|
.use { cursor ->
|
|
while(cursor.moveToNext()) {
|
|
val a = parse(context, cursor)
|
|
if(a != null) result.add(a)
|
|
}
|
|
}
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
log.e(ex, "loadAccountList failed.")
|
|
context.showToast(true, ex.withCaption("(SubwayTooter) broken in-app database?"))
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
fun loadByTag(context : Context, tag : String) : ArrayList<SavedAccount> {
|
|
val result = ArrayList<SavedAccount>()
|
|
try {
|
|
App1.database.query(
|
|
table,
|
|
null,
|
|
"$COL_NOTIFICATION_TAG=?",
|
|
arrayOf(tag),
|
|
null,
|
|
null,
|
|
null
|
|
)
|
|
.use { cursor ->
|
|
while(cursor.moveToNext()) {
|
|
val a = parse(context, cursor)
|
|
if(a != null) result.add(a)
|
|
}
|
|
|
|
}
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
log.e(ex, "loadByTag failed.")
|
|
throw RuntimeException("SavedAccount.loadByTag failed.", ex)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
fun loadAccountByAcct(context : Context, full_acct : String) : SavedAccount? {
|
|
try {
|
|
App1.database.query(
|
|
table,
|
|
null,
|
|
"$COL_USER=?",
|
|
arrayOf(full_acct),
|
|
null,
|
|
null,
|
|
null
|
|
)
|
|
.use { cursor ->
|
|
if(cursor.moveToNext()) {
|
|
return parse(context, cursor)
|
|
}
|
|
}
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
log.e(ex, "loadAccountByAcct failed.")
|
|
}
|
|
|
|
return null
|
|
}
|
|
|
|
fun hasRealAccount() : Boolean {
|
|
try {
|
|
App1.database.query(
|
|
table,
|
|
null,
|
|
"$COL_USER NOT LIKE '?@%'",
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
"1"
|
|
)
|
|
.use { cursor ->
|
|
if(cursor.moveToNext()) {
|
|
return true
|
|
}
|
|
}
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
log.e(ex, "hasNonPseudoAccount failed.")
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
val count : Long
|
|
get() {
|
|
try {
|
|
App1.database.query(table, arrayOf("count(*)"), null, null, null, null, null)
|
|
.use { cursor ->
|
|
if(cursor.moveToNext()) {
|
|
return cursor.getLong(0)
|
|
}
|
|
}
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
log.e(ex, "getCount failed.")
|
|
throw RuntimeException("SavedAccount.getCount failed.", ex)
|
|
}
|
|
|
|
return 0L
|
|
}
|
|
|
|
fun isNicoru(acct : Acct) : Boolean {
|
|
return acct.host == Host.FRIENDS_NICO
|
|
}
|
|
|
|
// private fun charAtLower(src : CharSequence, pos : Int) : Char {
|
|
// val c = src[pos]
|
|
// return if(c >= 'a' && c <= 'z') c - ('a' - 'A') else c
|
|
// }
|
|
//
|
|
// @Suppress("SameParameterValue")
|
|
// private fun host_match(
|
|
// a : CharSequence,
|
|
// a_startArg : Int,
|
|
// b : CharSequence,
|
|
// b_startArg : Int
|
|
// ) : Boolean {
|
|
// var a_start = a_startArg
|
|
// var b_start = b_startArg
|
|
//
|
|
// val a_end = a.length
|
|
// val b_end = b.length
|
|
//
|
|
// var a_remain = a_end - a_start
|
|
// val b_remain = b_end - b_start
|
|
//
|
|
// // 文字数が違う
|
|
// if(a_remain != b_remain) return false
|
|
//
|
|
// // 文字数がゼロ
|
|
// if(a_remain <= 0) return true
|
|
//
|
|
// // 末尾の文字が違う
|
|
// if(charAtLower(a, a_end - 1) != charAtLower(b, b_end - 1)) return false
|
|
//
|
|
// // 先頭からチェック
|
|
// while(a_remain -- > 0) {
|
|
// if(charAtLower(a, a_start ++) != charAtLower(b, b_start ++)) return false
|
|
// }
|
|
//
|
|
// return true
|
|
// }
|
|
|
|
private val account_comparator = Comparator<SavedAccount> { a, b ->
|
|
var i : Int
|
|
|
|
// NA > !NA
|
|
i = a.isNA.b2i() - b.isNA.b2i()
|
|
if(i != 0) return@Comparator i
|
|
|
|
// pseudo > real
|
|
i = a.isPseudo.b2i() - b.isPseudo.b2i()
|
|
if(i != 0) return@Comparator i
|
|
|
|
val sa = AcctColor.getNickname(a)
|
|
val sb = AcctColor.getNickname(b)
|
|
sa.compareTo(sb, ignoreCase = true)
|
|
}
|
|
|
|
fun sort(account_list : MutableList<SavedAccount>) {
|
|
Collections.sort(account_list, account_comparator)
|
|
}
|
|
|
|
fun sweepBuggieData() {
|
|
// https://github.com/tateisu/SubwayTooter/issues/107
|
|
// COL_ACCOUNTの内容がおかしければ削除する
|
|
|
|
val list = ArrayList<Long>()
|
|
try {
|
|
App1.database.query(
|
|
table,
|
|
null,
|
|
"$COL_ACCOUNT like ?",
|
|
arrayOf("jp.juggler.subwaytooter.api.entity.TootAccount@%"),
|
|
null,
|
|
null,
|
|
null
|
|
).use { cursor ->
|
|
while(cursor.moveToNext()) {
|
|
list.add(cursor.getLong(COL_ID))
|
|
}
|
|
}
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
log.e(ex, "sweepBuggieData failed.")
|
|
}
|
|
|
|
list.forEach {
|
|
try {
|
|
App1.database.delete(table, "$COL_ID=?", arrayOf(it.toString()))
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
log.e(ex, "sweepBuggieData failed.")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fun getAccessToken() : String? {
|
|
return token_info?.string("access_token")
|
|
}
|
|
|
|
val misskeyApiToken : String?
|
|
get() = token_info?.string(TootApiClient.KEY_API_KEY_MISSKEY)
|
|
|
|
fun putMisskeyApiToken(params : JsonObject = JsonObject()) : JsonObject {
|
|
val apiKey = misskeyApiToken
|
|
if(apiKey?.isNotEmpty() == true) params["i"] = apiKey
|
|
return params
|
|
}
|
|
|
|
fun canNotificationShowing(type : String?) = when(type) {
|
|
|
|
TootNotification.TYPE_MENTION,
|
|
TootNotification.TYPE_REPLY -> notification_mention
|
|
|
|
TootNotification.TYPE_REBLOG,
|
|
TootNotification.TYPE_RENOTE,
|
|
TootNotification.TYPE_QUOTE -> notification_boost
|
|
|
|
TootNotification.TYPE_FAVOURITE -> notification_favourite
|
|
|
|
TootNotification.TYPE_FOLLOW,
|
|
TootNotification.TYPE_UNFOLLOW -> notification_follow
|
|
|
|
TootNotification.TYPE_FOLLOW_REQUEST,
|
|
TootNotification.TYPE_FOLLOW_REQUEST_MISSKEY,
|
|
TootNotification.TYPE_FOLLOW_REQUEST_ACCEPTED_MISSKEY -> notification_follow_request
|
|
|
|
TootNotification.TYPE_REACTION -> notification_reaction
|
|
|
|
TootNotification.TYPE_VOTE,
|
|
TootNotification.TYPE_POLL,
|
|
TootNotification.TYPE_POLL_VOTE_MISSKEY -> notification_vote
|
|
|
|
TootNotification.TYPE_STATUS -> notification_post
|
|
|
|
else -> false
|
|
}
|
|
|
|
val isConfirmed : Boolean
|
|
get() {
|
|
val myId = this.loginAccount?.id
|
|
return myId != EntityId.CONFIRMING
|
|
}
|
|
|
|
suspend fun checkConfirmed(context : Context, client : TootApiClient) : TootApiResult? {
|
|
try {
|
|
val myId = this.loginAccount?.id
|
|
if(db_id != INVALID_DB_ID && myId == EntityId.CONFIRMING) {
|
|
val accessToken = getAccessToken()
|
|
if(accessToken != null) {
|
|
val result = client.getUserCredential(accessToken)
|
|
if(result == null || result.error != null) return result
|
|
val ta = TootParser(context, this).account(result.jsonObject)
|
|
if(ta != null) {
|
|
this.loginAccount = ta
|
|
val cv = ContentValues()
|
|
cv.put(COL_ACCOUNT, result.jsonObject.toString())
|
|
App1.database.update(table, cv, "$COL_ID=?", arrayOf(db_id.toString()))
|
|
PollingWorker.queueUpdateNotification(context)
|
|
}
|
|
}
|
|
}
|
|
return TootApiResult()
|
|
} catch(ex : Throwable) {
|
|
log.trace(ex)
|
|
return TootApiResult(ex.withCaption("account confirmation failed."))
|
|
}
|
|
}
|
|
|
|
fun updateNotificationError(text : String?) {
|
|
this.last_notification_error = text
|
|
if(db_id != INVALID_DB_ID) {
|
|
val cv = ContentValues()
|
|
when(text) {
|
|
null -> cv.putNull(COL_LAST_NOTIFICATION_ERROR)
|
|
else -> cv.put(COL_LAST_NOTIFICATION_ERROR, text)
|
|
}
|
|
App1.database.update(table, cv, "$COL_ID=?", arrayOf(db_id.toString()))
|
|
}
|
|
}
|
|
|
|
fun updateSubscriptionError(text : String?) {
|
|
this.last_subscription_error = text
|
|
if(db_id != INVALID_DB_ID) {
|
|
val cv = ContentValues()
|
|
when(text) {
|
|
null -> cv.putNull(COL_LAST_SUBSCRIPTION_ERROR)
|
|
else -> cv.put(COL_LAST_SUBSCRIPTION_ERROR, text)
|
|
}
|
|
App1.database.update(table, cv, "$COL_ID=?", arrayOf(db_id.toString()))
|
|
}
|
|
}
|
|
|
|
fun updateLastPushEndpoint(text : String?) {
|
|
this.last_push_endpoint = text
|
|
if(db_id != INVALID_DB_ID) {
|
|
val cv = ContentValues()
|
|
when(text) {
|
|
null -> cv.putNull(COL_LAST_PUSH_ENDPOINT)
|
|
else -> cv.put(COL_LAST_PUSH_ENDPOINT, text)
|
|
}
|
|
App1.database.update(table, cv, "$COL_ID=?", arrayOf(db_id.toString()))
|
|
}
|
|
}
|
|
|
|
override fun equals(other : Any?) : Boolean =
|
|
when(other) {
|
|
is SavedAccount -> acct == other.acct
|
|
else -> false
|
|
}
|
|
|
|
override fun hashCode() : Int = acct.hashCode()
|
|
|
|
|
|
fun getResizeConfig() =
|
|
resizeConfigList.find { it.spec == this.image_resize } ?: defaultResizeConfig
|
|
|
|
fun getMovieMaxBytes(ti:TootInstance) = 1000000 * max(
|
|
1,
|
|
this.movie_max_megabytes?.toIntOrNull()
|
|
?: if( ti.instanceType == InstanceType.Pixelfed) 15 else 40
|
|
)
|
|
|
|
fun getImageMaxBytes(ti:TootInstance) = 1000000 * max(
|
|
1,
|
|
this.image_max_megabytes?.toIntOrNull()
|
|
?: if( ti.instanceType == InstanceType.Pixelfed) 15 else 8
|
|
)
|
|
}
|