713 lines
24 KiB
Kotlin
713 lines
24 KiB
Kotlin
package jp.juggler.subwaytooter.notification
|
|
|
|
import android.annotation.SuppressLint
|
|
import android.app.NotificationManager
|
|
import android.app.job.JobInfo
|
|
import android.app.job.JobParameters
|
|
import android.app.job.JobScheduler
|
|
import android.app.job.JobService
|
|
import android.content.ComponentName
|
|
import android.content.Context
|
|
import android.content.SharedPreferences
|
|
import android.net.ConnectivityManager
|
|
import android.net.Uri
|
|
import android.net.wifi.WifiManager
|
|
import android.os.Build
|
|
import android.os.PowerManager
|
|
import android.os.SystemClock
|
|
import com.google.firebase.messaging.FirebaseMessaging
|
|
import jp.juggler.subwaytooter.*
|
|
import jp.juggler.subwaytooter.api.TootApiClient
|
|
import jp.juggler.subwaytooter.api.entity.*
|
|
import jp.juggler.subwaytooter.table.*
|
|
import jp.juggler.subwaytooter.util.*
|
|
import jp.juggler.util.*
|
|
import kotlinx.coroutines.*
|
|
import kotlinx.coroutines.channels.Channel
|
|
import kotlinx.coroutines.channels.ClosedReceiveChannelException
|
|
import kotlinx.coroutines.tasks.await
|
|
import okhttp3.Request
|
|
import ru.gildor.coroutines.okhttp.await
|
|
import java.lang.ref.WeakReference
|
|
import java.util.*
|
|
import java.util.concurrent.ConcurrentLinkedQueue
|
|
import java.util.concurrent.atomic.AtomicBoolean
|
|
import java.util.concurrent.atomic.AtomicReference
|
|
import kotlin.coroutines.coroutineContext
|
|
import kotlin.math.max
|
|
|
|
|
|
class PollingWorker private constructor(contextArg: Context) {
|
|
|
|
companion object {
|
|
|
|
val log = LogCategory("PollingWorker")
|
|
|
|
// private const val FCM_SENDER_ID = "433682361381"
|
|
// private const val FCM_SCOPE = "FCM"
|
|
|
|
const val NOTIFICATION_ID = 1
|
|
const val NOTIFICATION_ID_ERROR = 3
|
|
|
|
val mBusyAppDataImportBefore = AtomicBoolean(false)
|
|
val mBusyAppDataImportAfter = AtomicBoolean(false)
|
|
|
|
const val EXTRA_DB_ID = "db_id"
|
|
const val EXTRA_TAG = "tag"
|
|
const val EXTRA_TASK_ID = "task_id"
|
|
const val EXTRA_NOTIFICATION_TYPE = "notification_type"
|
|
const val EXTRA_NOTIFICATION_ID = "notificationId"
|
|
|
|
const val APP_SERVER = "https://mastodon-msg.juggler.jp"
|
|
|
|
val inject_queue = ConcurrentLinkedQueue<InjectData>()
|
|
|
|
|
|
@SuppressLint("StaticFieldLeak")
|
|
private var sInstance: PollingWorker? = null
|
|
|
|
fun getInstance(applicationContext: Context): PollingWorker {
|
|
synchronized(this) {
|
|
return sInstance ?: PollingWorker(applicationContext).also { sInstance = it }
|
|
}
|
|
}
|
|
|
|
suspend fun getFirebaseMessagingToken(context: Context): String? {
|
|
val prefDevice = PrefDevice.prefDevice(context)
|
|
// 設定ファイルに保持されていたらそれを使う
|
|
prefDevice
|
|
.getString(PrefDevice.KEY_DEVICE_TOKEN, null)
|
|
?.notEmpty()?.let { return it }
|
|
|
|
// 古い形式
|
|
// return FirebaseInstanceId.getInstance().getToken(FCM_SENDER_ID, FCM_SCOPE)
|
|
|
|
// com.google.firebase:firebase-messaging.20.3.0 以降
|
|
// implementation "org.jetbrains.kotlinx:kotlinx-coroutines-play-services:$kotlinx_coroutines_version"
|
|
try {
|
|
val sv = FirebaseMessaging.getInstance().token.await()
|
|
return if (sv.isNullOrBlank()) {
|
|
log.e("getFirebaseMessagingToken: missing device token.")
|
|
null
|
|
} else {
|
|
prefDevice
|
|
.edit()
|
|
.putString(PrefDevice.KEY_DEVICE_TOKEN, sv)
|
|
.apply()
|
|
sv
|
|
}
|
|
} catch (ex: Throwable) {
|
|
log.trace(ex, "getFirebaseMessagingToken: could not get device token.")
|
|
return null
|
|
}
|
|
}
|
|
|
|
|
|
// インストールIDを生成する前に、各データの通知登録キャッシュをクリアする
|
|
// トークンがまだ生成されていない場合、このメソッドは null を返します。
|
|
@Suppress("BlockingMethodInNonBlockingContext")
|
|
suspend fun prepareInstallId(
|
|
context: Context,
|
|
job: JobItem? = null
|
|
): String? {
|
|
val prefDevice = PrefDevice.prefDevice(context)
|
|
|
|
var sv = prefDevice.getString(PrefDevice.KEY_INSTALL_ID, null)
|
|
if (sv?.isNotEmpty() == true) return sv
|
|
|
|
SavedAccount.clearRegistrationCache()
|
|
|
|
try {
|
|
val device_token = getFirebaseMessagingToken(context)
|
|
?: return null
|
|
|
|
val request = Request.Builder()
|
|
.url("$APP_SERVER/counter")
|
|
.build()
|
|
|
|
val call = App1.ok_http_client.newCall(request)
|
|
job?.currentCall = WeakReference(call)
|
|
val response = call.await()
|
|
|
|
val body = response.body?.string()
|
|
|
|
if (!response.isSuccessful || body?.isEmpty() != false) {
|
|
log.e(
|
|
TootApiClient.formatResponse(
|
|
response,
|
|
"getInstallId: get/counter failed."
|
|
)
|
|
)
|
|
return null
|
|
}
|
|
|
|
sv = (device_token + UUID.randomUUID() + body).digestSHA256Base64Url()
|
|
prefDevice.edit().putString(PrefDevice.KEY_INSTALL_ID, sv).apply()
|
|
|
|
return sv
|
|
|
|
} catch (ex: Throwable) {
|
|
log.trace(ex, "prepareInstallId failed.")
|
|
}
|
|
return null
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// タスクの管理
|
|
|
|
val task_list = TaskList()
|
|
|
|
private fun scheduleJob(context: Context, jobId: JobId) {
|
|
|
|
val scheduler = context.getSystemService(Context.JOB_SCHEDULER_SERVICE)
|
|
as? JobScheduler
|
|
?: throw NotImplementedError("missing JobScheduler system service")
|
|
|
|
val component = ComponentName(context, PollingService::class.java)
|
|
|
|
val builder = JobInfo.Builder(jobId.int, component)
|
|
.setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY)
|
|
|
|
if (jobId == JobId.Polling) {
|
|
|
|
val minute = 60000L
|
|
|
|
val intervalMillis = max(
|
|
minute * 5L,
|
|
minute * Pref.spPullNotificationCheckInterval.toInt(context.pref())
|
|
)
|
|
|
|
val flexMillis = max(
|
|
minute,
|
|
intervalMillis shr 1
|
|
)
|
|
|
|
fun JobInfo.Builder.setPeriodicCompat(intervalMillis: Long, flexMillis: Long) =
|
|
this.apply {
|
|
if (Build.VERSION.SDK_INT >= 24) {
|
|
builder.setPeriodic(intervalMillis, flexMillis)
|
|
} else {
|
|
builder.setPeriodic(intervalMillis)
|
|
}
|
|
}
|
|
|
|
builder
|
|
.setPeriodicCompat(intervalMillis, flexMillis)
|
|
.setPersisted(true)
|
|
|
|
} else {
|
|
builder
|
|
.setMinimumLatency(0)
|
|
.setOverrideDeadline(60000L)
|
|
}
|
|
val jobInfo = builder.build()
|
|
|
|
val rv = scheduler.schedule(jobInfo)
|
|
if (rv != JobScheduler.RESULT_SUCCESS) {
|
|
log.w("scheduler.schedule failed. rv=$rv")
|
|
}
|
|
}
|
|
|
|
// タスクの追加
|
|
private fun addTask(
|
|
context: Context,
|
|
removeOld: Boolean,
|
|
taskId: TaskId,
|
|
taskDataInitializer: JsonObject.() -> Unit = {}
|
|
) {
|
|
try {
|
|
task_list.addLast(
|
|
context,
|
|
removeOld,
|
|
jsonObject {
|
|
taskDataInitializer()
|
|
put(EXTRA_TASK_ID, taskId.int)
|
|
}
|
|
)
|
|
scheduleJob(context, JobId.Task)
|
|
} catch (ex: Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
|
|
}
|
|
|
|
fun queueUpdateNotification(context: Context) {
|
|
addTask(context, true, TaskId.AccountUpdated)
|
|
}
|
|
|
|
fun resetNotificationTracking(context: Context, account: SavedAccount) {
|
|
addTask(context, false, TaskId.ResetTrackingState) {
|
|
put(EXTRA_DB_ID, account.db_id)
|
|
}
|
|
}
|
|
|
|
|
|
fun injectData(
|
|
context: Context,
|
|
account: SavedAccount,
|
|
src: List<TootNotification>
|
|
) {
|
|
|
|
if (src.isEmpty()) return
|
|
|
|
inject_queue.add(InjectData(account.db_id, src))
|
|
addTask(context, true, TaskId.DataInjected)
|
|
}
|
|
|
|
fun queueNotificationCleared(context: Context, db_id: Long) {
|
|
addTask(context, true, TaskId.Clear) {
|
|
put(EXTRA_DB_ID, db_id)
|
|
}
|
|
}
|
|
|
|
private fun JsonObject.decodeNotificationUri(uri: Uri) {
|
|
putNotNull(
|
|
EXTRA_DB_ID,
|
|
uri.getQueryParameter("db_id")?.toLongOrNull()
|
|
)
|
|
putNotNull(
|
|
EXTRA_NOTIFICATION_TYPE,
|
|
uri.getQueryParameter("type")?.notEmpty()
|
|
)
|
|
putNotNull(
|
|
EXTRA_NOTIFICATION_ID,
|
|
uri.getQueryParameter("notificationId")?.notEmpty()
|
|
)
|
|
}
|
|
|
|
fun queueNotificationDeleted(context: Context, uri: Uri?) {
|
|
if (uri != null) {
|
|
addTask(context, false, TaskId.NotificationDelete) {
|
|
decodeNotificationUri(uri)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun queueNotificationClicked(context: Context, uri: Uri?) {
|
|
if (uri != null) {
|
|
addTask(context, true, TaskId.NotificationClick) {
|
|
decodeNotificationUri(uri)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun queueAppDataImportBefore(context: Context) {
|
|
mBusyAppDataImportBefore.set(true)
|
|
mBusyAppDataImportAfter.set(true)
|
|
addTask(context, false, TaskId.AppDataImportBefore)
|
|
}
|
|
|
|
fun queueAppDataImportAfter(context: Context) {
|
|
addTask(context, false, TaskId.AppDataImportAfter)
|
|
}
|
|
|
|
fun queueFCMTokenUpdated(context: Context) {
|
|
addTask(context, true, TaskId.FcmDeviceToken)
|
|
}
|
|
|
|
fun queueBootCompleted(context: Context) {
|
|
addTask(context, true, TaskId.BootCompleted)
|
|
}
|
|
|
|
fun queuePackageReplaced(context: Context) {
|
|
addTask(context, true, TaskId.PackageReplaced)
|
|
}
|
|
|
|
private val job_status = AtomicReference<String>(null)
|
|
|
|
var workerStatus: String
|
|
get() = job_status.get()
|
|
set(x) {
|
|
log.d("workerStatus:$x")
|
|
job_status.set(x)
|
|
}
|
|
|
|
// IntentServiceが作ったスレッドから呼ばれる
|
|
suspend fun handleFCMMessage(
|
|
context: Context,
|
|
tag: String?,
|
|
progress: (String) -> Unit
|
|
) {
|
|
log.d("handleFCMMessage: start. tag=$tag")
|
|
|
|
val time_start = SystemClock.elapsedRealtime()
|
|
|
|
// この呼出でIntentServiceがstartForegroundする
|
|
progress("=>")
|
|
|
|
// タスクを追加
|
|
task_list.addLast(
|
|
context,
|
|
true,
|
|
JsonObject().apply {
|
|
put(EXTRA_TASK_ID, TaskId.FcmMessage.int)
|
|
if (tag != null) put(EXTRA_TAG, tag)
|
|
}
|
|
)
|
|
|
|
progress("==>")
|
|
|
|
// 疑似ジョブを開始
|
|
val pw = getInstance(context)
|
|
|
|
pw.addJobFCM()
|
|
|
|
// 疑似ジョブが終了するまで待機する
|
|
while (true) {
|
|
// ジョブが完了した？
|
|
val now = SystemClock.elapsedRealtime()
|
|
if (!pw.hasJob(JobId.Push)) {
|
|
log.d(
|
|
"handleFCMMessage: JOB_FCM completed. time=%.2f",
|
|
(now - time_start) / 1000f
|
|
)
|
|
break
|
|
}
|
|
|
|
// ジョブの状況を通知する
|
|
progress(job_status.get() ?: "(null)")
|
|
|
|
// 少し待機
|
|
delay(50L)
|
|
}
|
|
}
|
|
|
|
fun onAppSettingStop(context: Context) {
|
|
try {
|
|
scheduleJob(context, JobId.Polling)
|
|
} catch (ex: Throwable) {
|
|
ActAppSetting.log.trace(ex, "PollingWorker.scheduleJob failed.")
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
val context: Context
|
|
val appState: AppState
|
|
val pref: SharedPreferences
|
|
private val connectivityManager: ConnectivityManager
|
|
val notification_manager: NotificationManager
|
|
private val scheduler: JobScheduler
|
|
private val power_manager: PowerManager?
|
|
private val power_lock: PowerManager.WakeLock
|
|
private val wifi_manager: WifiManager?
|
|
private val wifi_lock: WifiManager.WifiLock
|
|
|
|
private val startedJobList = LinkedList<JobItem>()
|
|
|
|
private val workerNotifier = Channel<Unit>(capacity = Channel.CONFLATED)
|
|
|
|
fun notifyWorker() {
|
|
GlobalScope.launch { workerNotifier.send(Unit) }
|
|
}
|
|
|
|
init {
|
|
log.d("init")
|
|
|
|
val context = contextArg.applicationContext
|
|
|
|
this.context = context
|
|
|
|
// クラッシュレポートによると App1.onCreate より前にここを通る場合がある
|
|
// データベースへアクセスできるようにする
|
|
this.appState = App1.prepare(context, "PollingWorker.init")
|
|
this.pref = App1.pref
|
|
|
|
this.connectivityManager = systemService(context)
|
|
?: error("missing ConnectivityManager system service")
|
|
|
|
|
|
this.notification_manager = systemService(context)
|
|
?: error("missing NotificationManager system service")
|
|
|
|
this.scheduler = systemService(context)
|
|
?: error("missing JobScheduler system service")
|
|
|
|
this.power_manager = systemService(context)
|
|
?: error("missing PowerManager system service")
|
|
|
|
// WifiManagerの取得時はgetApplicationContext を使わないとlintに怒られる
|
|
this.wifi_manager = systemService(context.applicationContext)
|
|
?: error("missing WifiManager system service")
|
|
|
|
power_lock = power_manager.newWakeLock(
|
|
PowerManager.PARTIAL_WAKE_LOCK,
|
|
PollingWorker::class.java.name
|
|
)
|
|
power_lock.setReferenceCounted(false)
|
|
|
|
wifi_lock = if (Build.VERSION.SDK_INT >= 29) {
|
|
wifi_manager.createWifiLock(
|
|
WifiManager.WIFI_MODE_FULL_HIGH_PERF,
|
|
PollingWorker::class.java.name
|
|
)
|
|
} else {
|
|
@Suppress("DEPRECATION")
|
|
wifi_manager.createWifiLock(PollingWorker::class.java.name)
|
|
}
|
|
|
|
wifi_lock.setReferenceCounted(false)
|
|
|
|
GlobalScope.launch(Dispatchers.Default) { worker() }
|
|
}
|
|
|
|
@SuppressLint("WakelockTimeout")
|
|
private fun acquirePowerLock() {
|
|
log.d("acquire power lock...")
|
|
try {
|
|
if (!power_lock.isHeld) {
|
|
power_lock.acquire()
|
|
}
|
|
} catch (ex: Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
|
|
try {
|
|
if (!wifi_lock.isHeld) {
|
|
wifi_lock.acquire()
|
|
}
|
|
} catch (ex: Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
}
|
|
|
|
private fun releasePowerLock() {
|
|
log.d("release power lock...")
|
|
try {
|
|
if (power_lock.isHeld) {
|
|
power_lock.release()
|
|
}
|
|
} catch (ex: Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
|
|
try {
|
|
if (wifi_lock.isHeld) {
|
|
wifi_lock.release()
|
|
}
|
|
} catch (ex: Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
}
|
|
|
|
private suspend fun worker() {
|
|
workerStatus = "worker start."
|
|
try {
|
|
suspend fun isActive() = coroutineContext[Job]?.isActive == true
|
|
while (isActive()) {
|
|
while (true) {
|
|
handleJobItem(synchronized(startedJobList) {
|
|
for (ji in startedJobList) {
|
|
if (ji.mJobCancelled_.get()) continue
|
|
if (ji.mWorkerAttached.compareAndSet(false, true)) {
|
|
return@synchronized ji
|
|
}
|
|
}
|
|
null
|
|
} ?: break)
|
|
}
|
|
try {
|
|
workerNotifier.receive()
|
|
} catch (ex: ClosedReceiveChannelException) {
|
|
}
|
|
}
|
|
} finally {
|
|
workerStatus = "worker end."
|
|
}
|
|
}
|
|
|
|
private suspend fun handleJobItem(item: JobItem) {
|
|
try {
|
|
workerStatus = "start job ${item.jobId}"
|
|
acquirePowerLock()
|
|
try {
|
|
item.run(this@PollingWorker)
|
|
} finally {
|
|
releasePowerLock()
|
|
}
|
|
} catch (ex: Throwable) {
|
|
log.trace(ex)
|
|
} finally {
|
|
workerStatus = "end job ${item.jobId}"
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// ジョブの管理
|
|
|
|
// JobService#onDestroy から呼ばれる
|
|
fun onJobServiceDestroy() {
|
|
log.d("onJobServiceDestroy")
|
|
|
|
synchronized(startedJobList) {
|
|
val it = startedJobList.iterator()
|
|
while (it.hasNext()) {
|
|
val item = it.next()
|
|
if (item.jobId == JobId.Push) continue
|
|
it.remove()
|
|
item.cancel(false)
|
|
}
|
|
}
|
|
}
|
|
|
|
// JobService#onStartJob から呼ばれる
|
|
fun onStartJob(jobService: JobService, params: JobParameters): Boolean {
|
|
return when (val jobId = JobId.from(params.jobId)) {
|
|
null -> {
|
|
log.e("onStartJob: unknown jobId $params.jobId")
|
|
false
|
|
}
|
|
else -> {
|
|
val item = JobItem(jobId, params, WeakReference(jobService))
|
|
addStartedJob(item, true)
|
|
// return True if your context needs to process the work (on a separate thread).
|
|
// return False if there's no more work to be done for this job.
|
|
true
|
|
}
|
|
}
|
|
}
|
|
|
|
// FCMメッセージイベントから呼ばれる
|
|
private fun hasJob(@Suppress("SameParameterValue") jobId: JobId): Boolean {
|
|
synchronized(startedJobList) {
|
|
return startedJobList.any { it.jobId == jobId }
|
|
}
|
|
}
|
|
|
|
// FCMメッセージイベントから呼ばれる
|
|
private fun addJobFCM() {
|
|
addStartedJob(JobItem(JobId.Push), false)
|
|
}
|
|
|
|
// onStartJobから呼ばれる
|
|
private fun addStartedJob(item: JobItem, bRemoveOld: Boolean) {
|
|
val jobId = item.jobId
|
|
|
|
// 同じジョブ番号がジョブリストにあるか？
|
|
synchronized(startedJobList) {
|
|
if (bRemoveOld) {
|
|
val it = startedJobList.iterator()
|
|
while (it.hasNext()) {
|
|
val itemOld = it.next()
|
|
if (itemOld.jobId == jobId) {
|
|
log.w("addJob: jobId=$jobId, old job cancelled.")
|
|
// 同じジョブをすぐに始めるのだからrescheduleはfalse
|
|
itemOld.cancel(false)
|
|
it.remove()
|
|
}
|
|
}
|
|
}
|
|
log.d("addJob: jobId=$jobId, add to list.")
|
|
startedJobList.add(item)
|
|
}
|
|
|
|
GlobalScope.launch(Dispatchers.Default) {
|
|
workerNotifier.send(Unit)
|
|
}
|
|
}
|
|
|
|
|
|
// JobService#onStopJob から呼ばれる
|
|
// return True to indicate to the JobManager whether you'd like to reschedule this job based on the retry criteria provided at job creation-time.
|
|
// return False to drop the job. Regardless of the value returned, your job must stop executing.
|
|
fun onStopJob(params: JobParameters): Boolean {
|
|
val jobId = JobId.from(params.jobId)
|
|
|
|
// 同じジョブ番号がジョブリストにあるか？
|
|
synchronized(startedJobList) {
|
|
startedJobList.removeFirst { it.jobId == jobId }?.let { item ->
|
|
log.w("onStopJob: jobId=${jobId}, set cancel flag.")
|
|
// リソースがなくてStopされるのだからrescheduleはtrue
|
|
item.cancel(true)
|
|
return true // reschedule
|
|
}
|
|
}
|
|
|
|
// 該当するジョブを依頼されていない
|
|
log.w("onStopJob: jobId=${jobId}, not started..")
|
|
return false
|
|
}
|
|
|
|
fun processInjectedData(injectedAccounts: HashSet<Long>) {
|
|
while (true) {
|
|
val data = inject_queue.poll() ?: break
|
|
val account = SavedAccount.loadAccount(context, data.account_db_id) ?: continue
|
|
val list = data.list
|
|
log.d("${account.acct} processInjectedData +${list.size}")
|
|
if (list.isNotEmpty()) injectedAccounts.add(account.db_id)
|
|
NotificationCache(data.account_db_id).apply {
|
|
load()
|
|
inject(account, list)
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// ポーリングが完了した
|
|
fun onPollingComplete(requiredNextPolling: Boolean) {
|
|
when (requiredNextPolling) {
|
|
// まだスケジュールされてないなら登録する
|
|
true -> if (!scheduler.allPendingJobs.any { it.id == JobId.Polling.int }) {
|
|
log.d("registering next polling…")
|
|
scheduleJob(context, JobId.Polling)
|
|
}
|
|
// Pull通知を必要とするアカウントが存在しないなら、スケジュール登録を解除する
|
|
else -> try {
|
|
log.d("polling job is no longer required.")
|
|
scheduler.cancel(JobId.Polling.int)
|
|
} catch (ex: Throwable) {
|
|
log.trace(ex)
|
|
}
|
|
}
|
|
}
|
|
|
|
// ジョブ完了後にメインスレッドで呼ばれる
|
|
fun onJobComplete(item: JobItem) {
|
|
|
|
synchronized(startedJobList) {
|
|
startedJobList.remove(item)
|
|
}
|
|
|
|
// ジョブ終了報告
|
|
item.refJobService?.get()?.let { jobService ->
|
|
try {
|
|
val willReschedule = item.mReschedule.get()
|
|
log.d("sending jobFinished. willReschedule=$willReschedule")
|
|
jobService.jobFinished(item.jobParams, willReschedule)
|
|
} catch (ex: Throwable) {
|
|
log.trace(ex, "jobFinished failed.")
|
|
}
|
|
}
|
|
}
|
|
|
|
// return false if app data import started.
|
|
fun onStartTask(taskId: TaskId): Boolean {
|
|
@Suppress("NON_EXHAUSTIVE_WHEN")
|
|
when (taskId) {
|
|
TaskId.AppDataImportBefore -> {
|
|
|
|
// フォアグラウンドサービスの通知は消されないらしい
|
|
notification_manager.cancelAll()
|
|
|
|
scheduler.cancelAll()
|
|
|
|
mBusyAppDataImportBefore.set(false)
|
|
return false
|
|
}
|
|
|
|
TaskId.AppDataImportAfter -> {
|
|
mBusyAppDataImportAfter.set(false)
|
|
mBusyAppDataImportBefore.set(false)
|
|
NotificationTracking.resetPostAll()
|
|
// fall
|
|
}
|
|
}
|
|
|
|
|
|
// アプリデータのインポート処理がビジーな間、他のジョブは実行されない
|
|
return when {
|
|
mBusyAppDataImportBefore.get() || mBusyAppDataImportAfter.get() -> false
|
|
else -> true
|
|
}
|
|
}
|
|
} |