651 lines
25 KiB
Kotlin
651 lines
25 KiB
Kotlin
package jp.juggler.subwaytooter.notification
|
|
|
|
import android.content.Context
|
|
import jp.juggler.subwaytooter.R
|
|
import jp.juggler.subwaytooter.api.TootApiClient
|
|
import jp.juggler.subwaytooter.api.TootApiResult
|
|
import jp.juggler.subwaytooter.api.entity.InstanceCapability
|
|
import jp.juggler.subwaytooter.api.entity.TootInstance
|
|
import jp.juggler.subwaytooter.api.entity.TootPushSubscription
|
|
import jp.juggler.subwaytooter.api.entity.parseItem
|
|
import jp.juggler.subwaytooter.table.SavedAccount
|
|
import jp.juggler.subwaytooter.table.SubscriptionServerKey
|
|
import jp.juggler.util.*
|
|
import okhttp3.Request
|
|
import okhttp3.Response
|
|
|
|
class PushSubscriptionHelper(
|
|
val context: Context,
|
|
val account: SavedAccount,
|
|
val verbose: Boolean = false,
|
|
) {
|
|
companion object {
|
|
|
|
private val log = LogCategory("PushSubscriptionHelper")
|
|
|
|
private const val ERROR_PREVENT_FREQUENTLY_CHECK =
|
|
"prevent frequently subscription check."
|
|
|
|
private val lastCheckedMap: HashMap<String, Long> = HashMap()
|
|
|
|
fun clearLastCheck(account: SavedAccount) {
|
|
synchronized(lastCheckedMap) {
|
|
lastCheckedMap.remove(account.acct.ascii)
|
|
}
|
|
}
|
|
|
|
private fun Boolean.booleanToInt(trueValue: Int, falseValue: Int = 0) =
|
|
if (this) trueValue else falseValue
|
|
|
|
private fun Response.closeQuietly() =
|
|
try {
|
|
close()
|
|
} catch (_: Throwable) {
|
|
}
|
|
}
|
|
|
|
val flags = account.notification_boost.booleanToInt(1) +
|
|
account.notification_favourite.booleanToInt(2) +
|
|
account.notification_follow.booleanToInt(4) +
|
|
account.notification_mention.booleanToInt(8) +
|
|
account.notification_reaction.booleanToInt(16) +
|
|
account.notification_vote.booleanToInt(32) +
|
|
account.notification_follow_request.booleanToInt(64) +
|
|
account.notification_post.booleanToInt(128)
|
|
|
|
private val logBuffer = StringBuilder()
|
|
|
|
val logString: String
|
|
get() = logBuffer.toString()
|
|
|
|
private var subscribed: Boolean = false
|
|
|
|
private fun addLog(s: String?) {
|
|
if (s?.isNotEmpty() == true) {
|
|
if (logBuffer.isNotEmpty()) logBuffer.append('\n')
|
|
logBuffer.append(s)
|
|
}
|
|
}
|
|
|
|
private fun isRecentlyChecked(): Boolean {
|
|
if (verbose) return false
|
|
val now = System.currentTimeMillis()
|
|
val acctAscii = account.acct.ascii
|
|
synchronized(lastCheckedMap) {
|
|
val lastChecked = lastCheckedMap[acctAscii]
|
|
val rv = lastChecked != null && now - lastChecked < 3600000L
|
|
if (!rv) lastCheckedMap[acctAscii] = now
|
|
return rv
|
|
}
|
|
}
|
|
|
|
private suspend fun updateServerKey(
|
|
client: TootApiClient,
|
|
clientIdentifier: String,
|
|
serverKey: String?,
|
|
): TootApiResult {
|
|
|
|
if (serverKey == null) {
|
|
return TootApiResult(context.getString(R.string.push_notification_server_key_missing))
|
|
} else if (serverKey.isEmpty()) {
|
|
return TootApiResult(context.getString(R.string.push_notification_server_key_empty))
|
|
}
|
|
|
|
// 既に登録済みの値と同じなら何もしない
|
|
val oldKey = SubscriptionServerKey.find(clientIdentifier)
|
|
if (oldKey != serverKey) {
|
|
|
|
// サーバキーをアプリサーバに登録
|
|
client.http(
|
|
JsonObject().apply {
|
|
put("client_id", clientIdentifier)
|
|
put("server_key", serverKey)
|
|
}
|
|
.toPostRequestBuilder()
|
|
.url("${PollingWorker.APP_SERVER}/webpushserverkey")
|
|
.build()
|
|
|
|
).also { result ->
|
|
result.response?.let { res ->
|
|
when (res.code.also { res.close() }) {
|
|
|
|
200 -> {
|
|
// 登録できたサーバーキーをアプリ内DBに保存
|
|
SubscriptionServerKey.save(clientIdentifier, serverKey)
|
|
addLog("(server public key is registered.)")
|
|
}
|
|
|
|
else -> {
|
|
addLog("(server public key registration failed.)")
|
|
addLog("${res.code} ${res.message}")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return TootApiResult()
|
|
}
|
|
|
|
// アプリサーバにendpoint URLの変更を伝える
|
|
private suspend fun registerEndpoint(
|
|
client: TootApiClient,
|
|
deviceId: String,
|
|
endpoint: String,
|
|
): TootApiResult {
|
|
|
|
if (account.last_push_endpoint == endpoint) return TootApiResult()
|
|
|
|
return client.http(
|
|
jsonObject {
|
|
put("acct", account.acct.ascii)
|
|
put("deviceId", deviceId)
|
|
put("endpoint", endpoint)
|
|
}
|
|
.toPostRequestBuilder()
|
|
.url("${PollingWorker.APP_SERVER}/webpushendpoint")
|
|
.build()
|
|
).also { result ->
|
|
result.response?.let { res ->
|
|
when (res.code.also { res.close() }) {
|
|
in 200 until 300 -> {
|
|
account.updateLastPushEndpoint(endpoint)
|
|
}
|
|
else -> {
|
|
result.caption = "(SubwayTooter App server)"
|
|
client.readBodyString(result)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
suspend fun updateSubscription(client: TootApiClient, force: Boolean = false): TootApiResult? = try {
|
|
when {
|
|
isRecentlyChecked() ->
|
|
TootApiResult(ERROR_PREVENT_FREQUENTLY_CHECK)
|
|
|
|
account.isPseudo ->
|
|
TootApiResult(context.getString(R.string.pseudo_account_not_supported))
|
|
|
|
account.isMisskey ->
|
|
updateSubscriptionMisskey(client)
|
|
|
|
else ->
|
|
updateSubscriptionMastodon(client, force)
|
|
}
|
|
} catch (ex: Throwable) {
|
|
TootApiResult(ex.withCaption("error."))
|
|
}?.apply {
|
|
|
|
if (error != null) addLog("$error $requestInfo".trimEnd())
|
|
|
|
// update error text on account table
|
|
val log = logString
|
|
when {
|
|
|
|
log.contains(ERROR_PREVENT_FREQUENTLY_CHECK) -> {
|
|
// don't update if check was skipped.
|
|
}
|
|
|
|
subscribed || log.isEmpty() ->
|
|
// clear error text if succeeded or no error log
|
|
if (account.last_subscription_error != null) {
|
|
account.updateSubscriptionError(null)
|
|
}
|
|
|
|
else ->
|
|
// record error text
|
|
account.updateSubscriptionError(log)
|
|
}
|
|
}
|
|
|
|
private suspend fun updateSubscriptionMisskey(client: TootApiClient): TootApiResult? {
|
|
|
|
// 現在の購読状態を取得できないので、毎回購読の更新を行う
|
|
// FCMのデバイスIDを取得
|
|
val deviceId = PollingWorker.getFirebaseMessagingToken(context)
|
|
?: return TootApiResult(error = context.getString(R.string.missing_fcm_device_id))
|
|
|
|
// アクセストークン
|
|
val accessToken = account.misskeyApiToken
|
|
?: return TootApiResult(error = "missing misskeyApiToken.")
|
|
|
|
// インストールIDを取得
|
|
val installId = PollingWorker.prepareInstallId(context)
|
|
?: return TootApiResult(error = context.getString(R.string.missing_install_id))
|
|
|
|
// クライアント識別子
|
|
val clientIdentifier = "$accessToken$installId".digestSHA256Base64Url()
|
|
|
|
// 購読が不要な場合
|
|
// アプリサーバが410を返せるように状態を通知する
|
|
if (flags == 0) return registerEndpoint(client, deviceId, "none").also {
|
|
if (it.error == null && verbose) addLog(context.getString(R.string.push_subscription_updated))
|
|
}
|
|
|
|
/*
|
|
https://github.com/syuilo/misskey/blob/master/src/services/create-notification.ts#L46
|
|
Misskeyは通知に既読の概念があり、イベント発生後2秒たっても未読の時だけプッシュ通知が発生する。
|
|
STでプッシュ通知を試すにはSTの画面を非表示にする必要があるのでWebUIを使って投稿していたが、
|
|
WebUIを開いていると通知はすぐ既読になるのでプッシュ通知は発生しない。
|
|
プッシュ通知のテスト時はST2台を使い、片方をプッシュ通知の受信チェック、もう片方を投稿などの作業に使うことになる。
|
|
*/
|
|
|
|
// https://github.com/syuilo/misskey/issues/2541
|
|
// https://github.com/syuilo/misskey/commit/4c6fb60dd25d7e2865fc7c4d97728593ffc3c902
|
|
// 2018/9/1 の上記コミット以降、Misskeyでもサーバ公開鍵を得られるようになった
|
|
|
|
val endpoint =
|
|
"${PollingWorker.APP_SERVER}/webpushcallback/${deviceId.encodePercent()}/${account.acct.ascii.encodePercent()}/$flags/$clientIdentifier/misskey"
|
|
|
|
// アプリサーバが過去のendpoint urlに410を返せるよう、状態を通知する
|
|
val r = registerEndpoint(client, deviceId, endpoint.toUri().encodedPath!!)
|
|
if (r.error != null) return r
|
|
|
|
// 購読
|
|
@Suppress("SpellCheckingInspection")
|
|
return client.request(
|
|
"/api/sw/register",
|
|
account.putMisskeyApiToken().apply {
|
|
put("endpoint", endpoint)
|
|
put("auth", "iRdmDrOS6eK6xvG1H6KshQ")
|
|
put(
|
|
"publickey",
|
|
"BBEUVi7Ehdzzpe_ZvlzzkQnhujNJuBKH1R0xYg7XdAKNFKQG9Gpm0TSGRGSuaU7LUFKX-uz8YW0hAshifDCkPuE"
|
|
)
|
|
}
|
|
.toPostRequestBuilder()
|
|
)?.also { result ->
|
|
val jsonObject = result.jsonObject
|
|
if (jsonObject == null) {
|
|
addLog("API error.")
|
|
} else {
|
|
if (verbose) addLog(context.getString(R.string.push_subscription_updated))
|
|
subscribed = true
|
|
return updateServerKey(
|
|
client,
|
|
clientIdentifier,
|
|
jsonObject.string("key") ?: "3q2+rw"
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
private suspend fun updateSubscriptionMastodon(client: TootApiClient, force: Boolean): TootApiResult? {
|
|
|
|
// 現在の購読状態を取得
|
|
// https://github.com/tootsuite/mastodon/pull/7471
|
|
// https://github.com/tootsuite/mastodon/pull/7472
|
|
|
|
val subscription404: Boolean
|
|
val oldSubscription: TootPushSubscription?
|
|
checkCurrentSubscription(client).let {
|
|
if (it.failed) return it.result
|
|
subscription404 = it.is404
|
|
oldSubscription = parseItem(::TootPushSubscription, it.result?.jsonObject)
|
|
}
|
|
|
|
if (oldSubscription == null) {
|
|
log.i("${account.acct}: oldSubscription is null")
|
|
val (ti, result) = TootInstance.get(client)
|
|
ti ?: return result
|
|
checkInstanceVersionMastodon(ti, subscription404)?.let { return it }
|
|
}
|
|
|
|
// FCMのデバイスIDを取得
|
|
val deviceId = PollingWorker.getFirebaseMessagingToken(context)
|
|
?: return TootApiResult(error = context.getString(R.string.missing_fcm_device_id))
|
|
|
|
// インストールIDを取得
|
|
val installId = PollingWorker.prepareInstallId(context)
|
|
?: return TootApiResult(error = context.getString(R.string.missing_install_id))
|
|
|
|
// アクセストークン
|
|
val accessToken = account.getAccessToken()
|
|
?: return TootApiResult(error = "missing access token.")
|
|
|
|
// アクセストークンのダイジェスト
|
|
val tokenDigest = accessToken.digestSHA256Base64Url()
|
|
|
|
// クライアント識別子
|
|
val clientIdentifier = "$accessToken$installId".digestSHA256Base64Url()
|
|
|
|
val endpoint =
|
|
"${PollingWorker.APP_SERVER}/webpushcallback/${deviceId.encodePercent()}/${account.acct.ascii.encodePercent()}/$flags/$clientIdentifier"
|
|
|
|
val newAlerts = JsonObject().apply {
|
|
put("follow", account.notification_follow)
|
|
put("favourite", account.notification_favourite)
|
|
put("reblog", account.notification_boost)
|
|
put("mention", account.notification_mention)
|
|
put("poll", account.notification_vote)
|
|
put("follow_request", account.notification_follow_request)
|
|
put("status", account.notification_post)
|
|
put("emoji_reaction", account.notification_reaction) // fedibird拡張
|
|
}
|
|
|
|
if (!force) {
|
|
canSkipSubscriptionMastodon(
|
|
client = client,
|
|
clientIdentifier = clientIdentifier,
|
|
endpoint = endpoint,
|
|
oldSubscription = oldSubscription,
|
|
newAlerts = newAlerts,
|
|
)?.let { return it }
|
|
}
|
|
|
|
// アクセストークンの優先権を取得
|
|
checkDeviceHasPriority(
|
|
client,
|
|
tokenDigest = tokenDigest,
|
|
installId = installId,
|
|
).let {
|
|
if (it.failed) return it.result
|
|
}
|
|
|
|
return when (flags) {
|
|
// 通知設定が全てカラなので、購読を取り消したい
|
|
0 -> unsubscribeMastodon(client)
|
|
|
|
// 通知設定が空ではないので購読を行いたい
|
|
else -> subscribeMastodon(
|
|
client = client,
|
|
clientIdentifier = clientIdentifier,
|
|
endpoint = endpoint,
|
|
newAlerts = newAlerts
|
|
)
|
|
}
|
|
}
|
|
|
|
private class CheckDeviceHasPriorityResult(
|
|
val result: TootApiResult?,
|
|
val failed: Boolean,
|
|
)
|
|
|
|
private suspend fun checkDeviceHasPriority(
|
|
client: TootApiClient,
|
|
tokenDigest: String,
|
|
installId: String,
|
|
): CheckDeviceHasPriorityResult {
|
|
val r = client.http(
|
|
jsonObject {
|
|
put("token_digest", tokenDigest)
|
|
put("install_id", installId)
|
|
}
|
|
.toPostRequestBuilder()
|
|
.url("${PollingWorker.APP_SERVER}/webpushtokencheck")
|
|
.build()
|
|
)
|
|
|
|
fun rvError() = CheckDeviceHasPriorityResult(r, true)
|
|
fun rvOk() = CheckDeviceHasPriorityResult(r, false)
|
|
|
|
val res = r.response ?: return rvError()
|
|
return when {
|
|
res.code != 200 -> {
|
|
if (res.code == 403) addLog(context.getString(R.string.token_exported))
|
|
r.caption = "(SubwayTooter App server)"
|
|
client.readBodyString(r)
|
|
rvError()
|
|
}
|
|
else -> {
|
|
res.closeQuietly()
|
|
rvOk()
|
|
}
|
|
}
|
|
}
|
|
|
|
// returns null if no error
|
|
private fun checkInstanceVersionMastodon(ti: TootInstance, subscription404: Boolean): TootApiResult? {
|
|
|
|
// 2.4.0rc1 未満にはプッシュ購読APIはない
|
|
if (!ti.versionGE(TootInstance.VERSION_2_4_0_rc1)) {
|
|
return TootApiResult(
|
|
context.getString(R.string.instance_does_not_support_push_api, ti.version)
|
|
)
|
|
}
|
|
|
|
if (subscription404 && flags == 0) {
|
|
when {
|
|
ti.versionGE(TootInstance.VERSION_2_4_0_rc2) -> {
|
|
// 購読が不要で現在の状況が404だった場合
|
|
// 2.4.0rc2以降では「購読が存在しない」を示すので何もしなくてよい
|
|
if (verbose) addLog(context.getString(R.string.push_subscription_not_exists))
|
|
return TootApiResult()
|
|
}
|
|
|
|
else -> {
|
|
// 2.4.0rc1では「APIが存在しない」と「購読が存在しない」を判別できない
|
|
}
|
|
}
|
|
}
|
|
return null
|
|
}
|
|
|
|
private class CheckCurrentSubscriptionResult(
|
|
val result: TootApiResult?,
|
|
val failed: Boolean,
|
|
val is404: Boolean,
|
|
)
|
|
|
|
@Suppress("BooleanLiteralArgument")
|
|
private suspend fun checkCurrentSubscription(client: TootApiClient): CheckCurrentSubscriptionResult {
|
|
val r = client.request("/api/v1/push/subscription")
|
|
fun rvError() = CheckCurrentSubscriptionResult(r, true, false)
|
|
fun rvOk() = CheckCurrentSubscriptionResult(r, false, false)
|
|
fun rv404() = CheckCurrentSubscriptionResult(r, false, true)
|
|
val res = r?.response ?: return rvError() // cancelled or missing response
|
|
|
|
if (res.code != 200) log.i("${account.acct}: check existing subscription: code=${res.code}")
|
|
|
|
return when (res.code) {
|
|
200 -> {
|
|
if (r.error?.isNotEmpty() == true && r.jsonObject == null) {
|
|
// Pleromaが200応答でもエラーHTMLを返す場合がある
|
|
addLog(context.getString(R.string.instance_does_not_support_push_api_pleroma))
|
|
rvError()
|
|
} else {
|
|
// たぶん購読が存在する
|
|
rvOk()
|
|
}
|
|
}
|
|
|
|
// この時点では存在しないのが購読なのかAPIなのか分からない
|
|
404 -> rv404()
|
|
|
|
403 -> {
|
|
// アクセストークンにpushスコープがない
|
|
if (flags != 0 || verbose) addLog(context.getString(R.string.missing_push_scope))
|
|
rvError()
|
|
}
|
|
|
|
in 400 until 500 -> {
|
|
addLog(context.getString(R.string.instance_does_not_support_push_api_pleroma))
|
|
rvError()
|
|
}
|
|
|
|
else -> {
|
|
addLog("${res.request}")
|
|
addLog("${res.code} ${res.message}")
|
|
rvOk() // 後でリトライする
|
|
}
|
|
}
|
|
}
|
|
|
|
suspend fun canSkipSubscriptionMastodon(
|
|
client: TootApiClient,
|
|
clientIdentifier: String,
|
|
endpoint: String,
|
|
oldSubscription: TootPushSubscription?,
|
|
newAlerts: JsonObject,
|
|
): TootApiResult? {
|
|
|
|
// 購読を解除したいのに古い購読があるのなら、購読の更新が必要
|
|
if (flags == 0 && oldSubscription != null) return null
|
|
|
|
// endpoint URLが合わないなら購読の更新が必要
|
|
if (oldSubscription?.endpoint != endpoint) return null
|
|
|
|
suspend fun makeSkipResult(): TootApiResult {
|
|
// 既に登録済みで、endpointも一致している
|
|
subscribed = true
|
|
if (verbose) addLog(context.getString(R.string.push_subscription_already_exists))
|
|
return updateServerKey(client, clientIdentifier, oldSubscription.server_key)
|
|
}
|
|
|
|
// STがstatus通知に対応した時期に古いサーバでここを通ると
|
|
// flagsの値が変わりendpoint URLも変わった状態で購読を自動更新してしまう
|
|
// しかしそのタイミングではサーバは古いのでサーバ側の購読内容は変化しなかった。
|
|
|
|
// サーバ上の購読アラートのリスト
|
|
var alertsOld = oldSubscription.alerts.entries
|
|
.mapNotNull { if (it.value) it.key else null }
|
|
.sorted()
|
|
|
|
// 期待する購読アラートのリスト
|
|
var alertsNew = newAlerts.entries
|
|
.mapNotNull { pair -> pair.key.takeIf { pair.value == true } }
|
|
.sorted()
|
|
|
|
// 両方に共通するアラートは除去する
|
|
val bothHave = alertsOld.filter { alertsNew.contains(it) }
|
|
alertsOld = alertsOld.filter { !bothHave.contains(it) }
|
|
alertsNew = alertsNew.filter { !bothHave.contains(it) }
|
|
|
|
// サーバのバージョンを調べる前に、この時点でalertsが一致するか確認する
|
|
if (alertsOld.joinToString(",") == alertsNew.joinToString(",")) {
|
|
log.i("${account.acct}: same alerts(1)")
|
|
return makeSkipResult()
|
|
}
|
|
|
|
// ここでサーバのバージョンによって対応が変わる
|
|
val (ti, result) = TootInstance.get(client)
|
|
ti ?: return result
|
|
|
|
// サーバが知らないアラート種別は比較対象から除去する
|
|
fun Iterable<String>.knownOnly() = filter {
|
|
when (it) {
|
|
"follow", "mention", "favourite", "reblog" -> true
|
|
"poll" -> ti.versionGE(TootInstance.VERSION_2_8_0_rc1)
|
|
"follow_request" -> ti.versionGE(TootInstance.VERSION_3_1_0_rc1)
|
|
"status" -> ti.versionGE(TootInstance.VERSION_3_3_0_rc1)
|
|
"emoji_reaction" -> ti.versionGE(TootInstance.VERSION_3_4_0_rc1) &&
|
|
InstanceCapability.emojiReaction(account, ti)
|
|
|
|
else -> {
|
|
log.w("${account.acct}: unknown alert '$it'. server version='${ti.version}'")
|
|
false // 未知のアラートの差異は比較しない
|
|
}
|
|
}
|
|
}
|
|
alertsOld = alertsOld.knownOnly()
|
|
alertsNew = alertsNew.knownOnly()
|
|
|
|
return if (alertsOld.joinToString(",") == alertsNew.joinToString(",")) {
|
|
log.i("${account.acct}: same alerts(2)")
|
|
makeSkipResult()
|
|
} else {
|
|
addLog("${account.acct}: alerts not match. account=${account.acct.pretty} old=${alertsOld.sorted()}, new=${alertsNew.sorted()}")
|
|
null
|
|
}
|
|
}
|
|
|
|
private suspend fun unsubscribeMastodon(
|
|
client: TootApiClient,
|
|
): TootApiResult? {
|
|
|
|
val r = client.request("/api/v1/push/subscription", Request.Builder().delete())
|
|
val res = r?.response ?: return r
|
|
|
|
return when (res.code) {
|
|
200 -> {
|
|
if (verbose) addLog(context.getString(R.string.push_subscription_deleted))
|
|
TootApiResult()
|
|
}
|
|
|
|
404 -> {
|
|
if (verbose) {
|
|
addLog(context.getString(R.string.missing_push_api))
|
|
r
|
|
} else {
|
|
TootApiResult()
|
|
}
|
|
}
|
|
|
|
403 -> {
|
|
addLog(context.getString(R.string.missing_push_scope))
|
|
r
|
|
}
|
|
|
|
else -> {
|
|
addLog("${res.request}")
|
|
addLog("${res.code} ${res.message}")
|
|
r
|
|
}
|
|
}
|
|
}
|
|
|
|
private suspend fun subscribeMastodon(
|
|
client: TootApiClient,
|
|
clientIdentifier: String,
|
|
endpoint: String,
|
|
newAlerts: JsonObject,
|
|
): TootApiResult? {
|
|
@Suppress("SpellCheckingInspection")
|
|
val params = JsonObject().apply {
|
|
put("subscription", JsonObject().apply {
|
|
put("endpoint", endpoint)
|
|
put("keys", JsonObject().apply {
|
|
put(
|
|
"p256dh",
|
|
"BBEUVi7Ehdzzpe_ZvlzzkQnhujNJuBKH1R0xYg7XdAKNFKQG9Gpm0TSGRGSuaU7LUFKX-uz8YW0hAshifDCkPuE"
|
|
)
|
|
put("auth", "iRdmDrOS6eK6xvG1H6KshQ")
|
|
})
|
|
})
|
|
put("data", JsonObject().apply {
|
|
put("alerts", newAlerts)
|
|
account.push_policy?.let { put("policy", it) }
|
|
})
|
|
}
|
|
|
|
val r = client.request(
|
|
"/api/v1/push/subscription",
|
|
params.toPostRequestBuilder()
|
|
) ?: return null
|
|
|
|
val res = r.response ?: return r
|
|
|
|
return when (res.code) {
|
|
404 -> {
|
|
addLog(context.getString(R.string.missing_push_api))
|
|
r
|
|
}
|
|
|
|
403 -> {
|
|
addLog(context.getString(R.string.missing_push_scope))
|
|
r
|
|
}
|
|
|
|
200 -> {
|
|
val newSubscription = parseItem(::TootPushSubscription, r.jsonObject)
|
|
?: return r.setError("parse error.")
|
|
|
|
subscribed = true
|
|
if (verbose) addLog(context.getString(R.string.push_subscription_updated))
|
|
|
|
return updateServerKey(
|
|
client,
|
|
clientIdentifier,
|
|
newSubscription.server_key
|
|
)
|
|
}
|
|
|
|
else -> {
|
|
addLog(r.jsonObject?.toString())
|
|
r
|
|
}
|
|
}
|
|
}
|
|
}
|