From e24564d7d61c1f3e6f9726bd8baecb79a1ec69ec Mon Sep 17 00:00:00 2001 From: Stanislav Dmitrenko <7953703+avently@users.noreply.github.com> Date: Thu, 6 Jul 2023 16:19:35 +0300 Subject: [PATCH] multiplatform: service refactor (#2661) Co-authored-by: Evgeny Poberezkin <2769109+epoberezkin@users.noreply.github.com> --- .../main/java/chat/simplex/app/SimplexApp.kt | 12 +- .../java/chat/simplex/app/SimplexService.kt | 175 +++++++++++++++++- .../java/chat/simplex/app/model/SimpleXAPI.kt | 166 ----------------- .../chat/simplex/app/views/call/CallView.kt | 2 +- .../app/views/database/DatabaseErrorView.kt | 2 +- .../app/views/database/DatabaseView.kt | 2 +- .../usersettings/NotificationsSettingsView.kt | 8 +- 7 files changed, 182 insertions(+), 185 deletions(-) diff --git a/apps/multiplatform/android/src/main/java/chat/simplex/app/SimplexApp.kt b/apps/multiplatform/android/src/main/java/chat/simplex/app/SimplexApp.kt index 29a20ff76..64994115e 100644 --- a/apps/multiplatform/android/src/main/java/chat/simplex/app/SimplexApp.kt +++ b/apps/multiplatform/android/src/main/java/chat/simplex/app/SimplexApp.kt @@ -84,9 +84,9 @@ class SimplexApp: Application(), LifecycleEventObserver { chatController.startChat(user) // Prevents from showing "Enable notifications" alert when onboarding wasn't complete yet if (chatModel.onboardingStage.value == OnboardingStage.OnboardingComplete) { - chatController.showBackgroundServiceNoticeIfNeeded() + SimplexService.showBackgroundServiceNoticeIfNeeded() if (appPreferences.notificationsMode.get() == NotificationsMode.SERVICE.name) - SimplexService.start(applicationContext) + SimplexService.start() } } } @@ -134,7 +134,7 @@ class SimplexApp: Application(), LifecycleEventObserver { Lifecycle.Event.ON_RESUME -> { isAppOnForeground = true if (chatModel.onboardingStage.value == OnboardingStage.OnboardingComplete) { - chatController.showBackgroundServiceNoticeIfNeeded() + SimplexService.showBackgroundServiceNoticeIfNeeded() } /** * We're starting service here instead of in [Lifecycle.Event.ON_START] because @@ -145,7 +145,7 @@ class SimplexApp: Application(), LifecycleEventObserver { chatModel.onboardingStage.value == OnboardingStage.OnboardingComplete && appPreferences.notificationsMode.get() == NotificationsMode.SERVICE.name ) { - SimplexService.start(applicationContext) + SimplexService.start() } } else -> isAppOnForeground = false @@ -155,12 +155,12 @@ class SimplexApp: Application(), LifecycleEventObserver { fun allowToStartServiceAfterAppExit() = with(chatModel.controller) { appPrefs.notificationsMode.get() == NotificationsMode.SERVICE.name && - (!NotificationsMode.SERVICE.requiresIgnoringBattery || isIgnoringBatteryOptimizations()) + (!NotificationsMode.SERVICE.requiresIgnoringBattery || SimplexService.isIgnoringBatteryOptimizations()) } private fun allowToStartPeriodically() = with(chatModel.controller) { appPrefs.notificationsMode.get() == NotificationsMode.PERIODIC.name && - (!NotificationsMode.PERIODIC.requiresIgnoringBattery || isIgnoringBatteryOptimizations()) + (!NotificationsMode.PERIODIC.requiresIgnoringBattery || SimplexService.isIgnoringBatteryOptimizations()) } /* diff --git a/apps/multiplatform/android/src/main/java/chat/simplex/app/SimplexService.kt b/apps/multiplatform/android/src/main/java/chat/simplex/app/SimplexService.kt index b9df85c4f..202471919 100644 --- a/apps/multiplatform/android/src/main/java/chat/simplex/app/SimplexService.kt +++ b/apps/multiplatform/android/src/main/java/chat/simplex/app/SimplexService.kt @@ -1,17 +1,28 @@ package chat.simplex.app +import android.annotation.SuppressLint import android.app.* import android.content.* import android.content.pm.PackageManager +import android.net.Uri import android.os.* import android.provider.Settings import android.util.Log +import androidx.compose.foundation.layout.* +import androidx.compose.material.* +import androidx.compose.ui.Modifier +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp import androidx.core.app.NotificationCompat import androidx.core.content.ContextCompat import androidx.work.* import chat.simplex.app.model.ChatController +import chat.simplex.app.model.ChatModel import chat.simplex.app.views.helpers.* +import chat.simplex.app.views.usersettings.NotificationsMode import chat.simplex.res.MR +import dev.icerock.moko.resources.compose.painterResource +import dev.icerock.moko.resources.compose.stringResource import kotlinx.coroutines.* // based on: @@ -207,7 +218,7 @@ class SimplexService: Service() { } if (getServiceState(context) == ServiceState.STARTED) { Log.d(TAG, "ServiceStartWorker: Starting foreground service (work ID: $id)") - start(context) + start() } return Result.success() } @@ -248,7 +259,7 @@ class SimplexService: Service() { workManager.enqueueUniqueWork(WORK_NAME_ONCE, ExistingWorkPolicy.KEEP, startServiceRequest) // Unique avoids races! } - suspend fun start(context: Context) = serviceAction(context, Action.START) + suspend fun start() = serviceAction(Action.START) /** * If there is a need to stop the service, use this function only. It makes sure that the service will be stopped without an @@ -262,12 +273,12 @@ class SimplexService: Service() { } } - private suspend fun serviceAction(context: Context, action: Action) { + private suspend fun serviceAction(action: Action) { Log.d(TAG, "SimplexService serviceAction: ${action.name}") withContext(Dispatchers.IO) { - Intent(context, SimplexService::class.java).also { + Intent(SimplexApp.context, SimplexService::class.java).also { it.action = action.name - ContextCompat.startForegroundService(context, it) + ContextCompat.startForegroundService(SimplexApp.context, it) } } } @@ -338,5 +349,159 @@ class SimplexService: Service() { } private fun getPreferences(context: Context): SharedPreferences = context.getSharedPreferences(SHARED_PREFS_ID, Context.MODE_PRIVATE) + + fun showBackgroundServiceNoticeIfNeeded() { + val appPrefs = ChatController.appPrefs + val mode = NotificationsMode.valueOf(appPrefs.notificationsMode.get()!!) + Log.d(TAG, "showBackgroundServiceNoticeIfNeeded") + // Nothing to do if mode is OFF. Can be selected on on-boarding stage + if (mode == NotificationsMode.OFF) return + + if (!appPrefs.backgroundServiceNoticeShown.get()) { + // the branch for the new users who have never seen service notice + if (!mode.requiresIgnoringBattery || isIgnoringBatteryOptimizations()) { + showBGServiceNotice(mode) + } else { + showBGServiceNoticeIgnoreOptimization(mode) + } + // set both flags, so that if the user doesn't allow ignoring optimizations, the service will be disabled without additional notice + appPrefs.backgroundServiceNoticeShown.set(true) + appPrefs.backgroundServiceBatteryNoticeShown.set(true) + } else if (mode.requiresIgnoringBattery && !isIgnoringBatteryOptimizations()) { + // the branch for users who have app installed, and have seen the service notice, + // but the battery optimization for the app is on (Android 12) AND the service is running + if (appPrefs.backgroundServiceBatteryNoticeShown.get()) { + // users have been presented with battery notice before - they did not allow ignoring optimizations -> disable service + showDisablingServiceNotice(mode) + appPrefs.notificationsMode.set(NotificationsMode.OFF.name) + ChatModel.notificationsMode.value = NotificationsMode.OFF + SimplexService.StartReceiver.toggleReceiver(false) + MessagesFetcherWorker.cancelAll() + SimplexService.safeStopService(SimplexApp.context) + } else { + // show battery optimization notice + showBGServiceNoticeIgnoreOptimization(mode) + appPrefs.backgroundServiceBatteryNoticeShown.set(true) + } + } else { + // service or periodic mode was chosen and battery optimization is disabled + SimplexApp.context.schedulePeriodicServiceRestartWorker() + SimplexApp.context.schedulePeriodicWakeUp() + } + } + + private fun showBGServiceNotice(mode: NotificationsMode) = AlertManager.shared.showAlert { + AlertDialog( + onDismissRequest = AlertManager.shared::hideAlert, + title = { + Row { + Icon( + painterResource(MR.images.ic_bolt), + contentDescription = + if (mode == NotificationsMode.SERVICE) stringResource(MR.strings.icon_descr_instant_notifications) else stringResource(MR.strings.periodic_notifications), + ) + Text( + if (mode == NotificationsMode.SERVICE) stringResource(MR.strings.icon_descr_instant_notifications) else stringResource(MR.strings.periodic_notifications), + fontWeight = FontWeight.Bold + ) + } + }, + text = { + Column { + Text( + if (mode == NotificationsMode.SERVICE) annotatedStringResource(MR.strings.to_preserve_privacy_simplex_has_background_service_instead_of_push_notifications_it_uses_a_few_pc_battery) else annotatedStringResource(MR.strings.periodic_notifications_desc), + Modifier.padding(bottom = 8.dp) + ) + Text( + annotatedStringResource(MR.strings.it_can_disabled_via_settings_notifications_still_shown) + ) + } + }, + confirmButton = { + TextButton(onClick = AlertManager.shared::hideAlert) { Text(stringResource(MR.strings.ok)) } + } + ) + } + + private fun showBGServiceNoticeIgnoreOptimization(mode: NotificationsMode) = AlertManager.shared.showAlert { + val ignoreOptimization = { + AlertManager.shared.hideAlert() + askAboutIgnoringBatteryOptimization() + } + AlertDialog( + onDismissRequest = ignoreOptimization, + title = { + Row { + Icon( + painterResource(MR.images.ic_bolt), + contentDescription = + if (mode == NotificationsMode.SERVICE) stringResource(MR.strings.icon_descr_instant_notifications) else stringResource(MR.strings.periodic_notifications), + ) + Text( + if (mode == NotificationsMode.SERVICE) stringResource(MR.strings.service_notifications) else stringResource(MR.strings.periodic_notifications), + fontWeight = FontWeight.Bold + ) + } + }, + text = { + Column { + Text( + if (mode == NotificationsMode.SERVICE) annotatedStringResource(MR.strings.to_preserve_privacy_simplex_has_background_service_instead_of_push_notifications_it_uses_a_few_pc_battery) else annotatedStringResource(MR.strings.periodic_notifications_desc), + Modifier.padding(bottom = 8.dp) + ) + Text(annotatedStringResource(MR.strings.turn_off_battery_optimization)) + } + }, + confirmButton = { + TextButton(onClick = ignoreOptimization) { Text(stringResource(MR.strings.ok)) } + } + ) + } + + private fun showDisablingServiceNotice(mode: NotificationsMode) = AlertManager.shared.showAlert { + AlertDialog( + onDismissRequest = AlertManager.shared::hideAlert, + title = { + Row { + Icon( + painterResource(MR.images.ic_bolt), + contentDescription = + if (mode == NotificationsMode.SERVICE) stringResource(MR.strings.icon_descr_instant_notifications) else stringResource(MR.strings.periodic_notifications), + ) + Text( + if (mode == NotificationsMode.SERVICE) stringResource(MR.strings.service_notifications_disabled) else stringResource(MR.strings.periodic_notifications_disabled), + fontWeight = FontWeight.Bold + ) + } + }, + text = { + Column { + Text( + annotatedStringResource(MR.strings.turning_off_service_and_periodic), + Modifier.padding(bottom = 8.dp) + ) + } + }, + confirmButton = { + TextButton(onClick = AlertManager.shared::hideAlert) { Text(stringResource(MR.strings.ok)) } + } + ) + } + + fun isIgnoringBatteryOptimizations(): Boolean { + val powerManager = SimplexApp.context.getSystemService(Application.POWER_SERVICE) as PowerManager + return powerManager.isIgnoringBatteryOptimizations(SimplexApp.context.packageName) + } + + private fun askAboutIgnoringBatteryOptimization() { + Intent().apply { + @SuppressLint("BatteryLife") + action = Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS + data = Uri.parse("package:${SimplexApp.context.packageName}") + // This flag is needed when you start a new activity from non-Activity context + addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) + SimplexApp.context.startActivity(this) + } + } } } diff --git a/apps/multiplatform/android/src/main/java/chat/simplex/app/model/SimpleXAPI.kt b/apps/multiplatform/android/src/main/java/chat/simplex/app/model/SimpleXAPI.kt index ba9600054..f7d7de42b 100644 --- a/apps/multiplatform/android/src/main/java/chat/simplex/app/model/SimpleXAPI.kt +++ b/apps/multiplatform/android/src/main/java/chat/simplex/app/model/SimpleXAPI.kt @@ -1,25 +1,13 @@ package chat.simplex.app.model -import android.annotation.SuppressLint -import android.app.Application import android.content.* -import android.net.Uri -import android.os.PowerManager -import android.provider.Settings import android.util.Log -import androidx.compose.foundation.layout.* -import androidx.compose.material.* import chat.simplex.app.views.helpers.* import androidx.compose.runtime.* -import androidx.compose.ui.Modifier import androidx.compose.ui.graphics.Color import androidx.compose.ui.graphics.painter.Painter import dev.icerock.moko.resources.compose.painterResource -import dev.icerock.moko.resources.compose.stringResource -import androidx.compose.ui.text.font.FontWeight -import androidx.compose.ui.unit.dp import chat.simplex.app.* -import chat.simplex.app.R import chat.simplex.app.ui.theme.* import chat.simplex.app.views.call.* import chat.simplex.app.views.newchat.ConnectViaLinkTab @@ -28,7 +16,6 @@ import chat.simplex.app.views.usersettings.* import com.charleskorn.kaml.Yaml import com.charleskorn.kaml.YamlConfiguration import chat.simplex.res.MR -import dev.icerock.moko.resources.compose.stringResource import kotlinx.coroutines.* import kotlinx.datetime.Clock import kotlinx.datetime.Instant @@ -1662,159 +1649,6 @@ object ChatController { chatModel.setContactNetworkStatus(contact, NetworkStatus.Error(err)) } - fun showBackgroundServiceNoticeIfNeeded() { - val mode = NotificationsMode.valueOf(appPrefs.notificationsMode.get()!!) - Log.d(TAG, "showBackgroundServiceNoticeIfNeeded") - // Nothing to do if mode is OFF. Can be selected on on-boarding stage - if (mode == NotificationsMode.OFF) return - - if (!appPrefs.backgroundServiceNoticeShown.get()) { - // the branch for the new users who have never seen service notice - if (!mode.requiresIgnoringBattery || isIgnoringBatteryOptimizations()) { - showBGServiceNotice(mode) - } else { - showBGServiceNoticeIgnoreOptimization(mode) - } - // set both flags, so that if the user doesn't allow ignoring optimizations, the service will be disabled without additional notice - appPrefs.backgroundServiceNoticeShown.set(true) - appPrefs.backgroundServiceBatteryNoticeShown.set(true) - } else if (mode.requiresIgnoringBattery && !isIgnoringBatteryOptimizations()) { - // the branch for users who have app installed, and have seen the service notice, - // but the battery optimization for the app is on (Android 12) AND the service is running - if (appPrefs.backgroundServiceBatteryNoticeShown.get()) { - // users have been presented with battery notice before - they did not allow ignoring optimizations -> disable service - showDisablingServiceNotice(mode) - appPrefs.notificationsMode.set(NotificationsMode.OFF.name) - chatModel.notificationsMode.value = NotificationsMode.OFF - SimplexService.StartReceiver.toggleReceiver(false) - MessagesFetcherWorker.cancelAll() - SimplexService.safeStopService(SimplexApp.context) - } else { - // show battery optimization notice - showBGServiceNoticeIgnoreOptimization(mode) - appPrefs.backgroundServiceBatteryNoticeShown.set(true) - } - } else { - // service or periodic mode was chosen and battery optimization is disabled - SimplexApp.context.schedulePeriodicServiceRestartWorker() - SimplexApp.context.schedulePeriodicWakeUp() - } - } - - private fun showBGServiceNotice(mode: NotificationsMode) = AlertManager.shared.showAlert { - AlertDialog( - onDismissRequest = AlertManager.shared::hideAlert, - title = { - Row { - Icon( - painterResource(MR.images.ic_bolt), - contentDescription = - if (mode == NotificationsMode.SERVICE) stringResource(MR.strings.icon_descr_instant_notifications) else stringResource(MR.strings.periodic_notifications), - ) - Text( - if (mode == NotificationsMode.SERVICE) stringResource(MR.strings.icon_descr_instant_notifications) else stringResource(MR.strings.periodic_notifications), - fontWeight = FontWeight.Bold - ) - } - }, - text = { - Column { - Text( - if (mode == NotificationsMode.SERVICE) annotatedStringResource(MR.strings.to_preserve_privacy_simplex_has_background_service_instead_of_push_notifications_it_uses_a_few_pc_battery) else annotatedStringResource(MR.strings.periodic_notifications_desc), - Modifier.padding(bottom = 8.dp) - ) - Text( - annotatedStringResource(MR.strings.it_can_disabled_via_settings_notifications_still_shown) - ) - } - }, - confirmButton = { - TextButton(onClick = AlertManager.shared::hideAlert) { Text(stringResource(MR.strings.ok)) } - } - ) - } - - private fun showBGServiceNoticeIgnoreOptimization(mode: NotificationsMode) = AlertManager.shared.showAlert { - val ignoreOptimization = { - AlertManager.shared.hideAlert() - askAboutIgnoringBatteryOptimization() - } - AlertDialog( - onDismissRequest = ignoreOptimization, - title = { - Row { - Icon( - painterResource(MR.images.ic_bolt), - contentDescription = - if (mode == NotificationsMode.SERVICE) stringResource(MR.strings.icon_descr_instant_notifications) else stringResource(MR.strings.periodic_notifications), - ) - Text( - if (mode == NotificationsMode.SERVICE) stringResource(MR.strings.service_notifications) else stringResource(MR.strings.periodic_notifications), - fontWeight = FontWeight.Bold - ) - } - }, - text = { - Column { - Text( - if (mode == NotificationsMode.SERVICE) annotatedStringResource(MR.strings.to_preserve_privacy_simplex_has_background_service_instead_of_push_notifications_it_uses_a_few_pc_battery) else annotatedStringResource(MR.strings.periodic_notifications_desc), - Modifier.padding(bottom = 8.dp) - ) - Text(annotatedStringResource(MR.strings.turn_off_battery_optimization)) - } - }, - confirmButton = { - TextButton(onClick = ignoreOptimization) { Text(stringResource(MR.strings.ok)) } - } - ) - } - - private fun showDisablingServiceNotice(mode: NotificationsMode) = AlertManager.shared.showAlert { - AlertDialog( - onDismissRequest = AlertManager.shared::hideAlert, - title = { - Row { - Icon( - painterResource(MR.images.ic_bolt), - contentDescription = - if (mode == NotificationsMode.SERVICE) stringResource(MR.strings.icon_descr_instant_notifications) else stringResource(MR.strings.periodic_notifications), - ) - Text( - if (mode == NotificationsMode.SERVICE) stringResource(MR.strings.service_notifications_disabled) else stringResource(MR.strings.periodic_notifications_disabled), - fontWeight = FontWeight.Bold - ) - } - }, - text = { - Column { - Text( - annotatedStringResource(MR.strings.turning_off_service_and_periodic), - Modifier.padding(bottom = 8.dp) - ) - } - }, - confirmButton = { - TextButton(onClick = AlertManager.shared::hideAlert) { Text(stringResource(MR.strings.ok)) } - } - ) - } - - fun isIgnoringBatteryOptimizations(): Boolean { - val powerManager = SimplexApp.context.getSystemService(Application.POWER_SERVICE) as PowerManager - return powerManager.isIgnoringBatteryOptimizations(SimplexApp.context.packageName) - } - - private fun askAboutIgnoringBatteryOptimization() { - Intent().apply { - @SuppressLint("BatteryLife") - action = Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS - data = Uri.parse("package:${SimplexApp.context.packageName}") - // This flag is needed when you start a new activity from non-Activity context - addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) - SimplexApp.context.startActivity(this) - } - } - fun getXFTPCfg(): XFTPFileConfig { return XFTPFileConfig(minFileSize = 0) } diff --git a/apps/multiplatform/android/src/main/java/chat/simplex/app/views/call/CallView.kt b/apps/multiplatform/android/src/main/java/chat/simplex/app/views/call/CallView.kt index e69d4c54f..f937342f5 100644 --- a/apps/multiplatform/android/src/main/java/chat/simplex/app/views/call/CallView.kt +++ b/apps/multiplatform/android/src/main/java/chat/simplex/app/views/call/CallView.kt @@ -59,7 +59,7 @@ fun ActiveCallView(chatModel: ChatModel) { LaunchedEffect(Unit) { // Start service when call happening since it's not already started. // It's needed to prevent Android from shutting down a microphone after a minute or so when screen is off - if (!ntfModeService) SimplexService.start(SimplexApp.context) + if (!ntfModeService) SimplexService.start() } DisposableEffect(Unit) { val am = SimplexApp.context.getSystemService(Context.AUDIO_SERVICE) as AudioManager diff --git a/apps/multiplatform/android/src/main/java/chat/simplex/app/views/database/DatabaseErrorView.kt b/apps/multiplatform/android/src/main/java/chat/simplex/app/views/database/DatabaseErrorView.kt index 1dd06cbc7..cf97b3c8c 100644 --- a/apps/multiplatform/android/src/main/java/chat/simplex/app/views/database/DatabaseErrorView.kt +++ b/apps/multiplatform/android/src/main/java/chat/simplex/app/views/database/DatabaseErrorView.kt @@ -208,7 +208,7 @@ private fun runChat( is DBMigrationResult.OK -> { SimplexService.cancelPassphraseNotification() when (prefs.notificationsMode.get()) { - NotificationsMode.SERVICE.name -> CoroutineScope(Dispatchers.Default).launch { SimplexService.start(SimplexApp.context) } + NotificationsMode.SERVICE.name -> CoroutineScope(Dispatchers.Default).launch { SimplexService.start() } NotificationsMode.PERIODIC.name -> SimplexApp.context.schedulePeriodicWakeUp() } } diff --git a/apps/multiplatform/android/src/main/java/chat/simplex/app/views/database/DatabaseView.kt b/apps/multiplatform/android/src/main/java/chat/simplex/app/views/database/DatabaseView.kt index ebb88e3e0..f82caf7e7 100644 --- a/apps/multiplatform/android/src/main/java/chat/simplex/app/views/database/DatabaseView.kt +++ b/apps/multiplatform/android/src/main/java/chat/simplex/app/views/database/DatabaseView.kt @@ -377,7 +377,7 @@ private fun startChat(m: ChatModel, runChat: MutableState, chatLastSta m.controller.appPrefs.chatLastStart.set(ts) chatLastStart.value = ts when (m.controller.appPrefs.notificationsMode.get()) { - NotificationsMode.SERVICE.name -> CoroutineScope(Dispatchers.Default).launch { SimplexService.start(SimplexApp.context) } + NotificationsMode.SERVICE.name -> CoroutineScope(Dispatchers.Default).launch { SimplexService.start() } NotificationsMode.PERIODIC.name -> SimplexApp.context.schedulePeriodicWakeUp() } } catch (e: Error) { diff --git a/apps/multiplatform/android/src/main/java/chat/simplex/app/views/usersettings/NotificationsSettingsView.kt b/apps/multiplatform/android/src/main/java/chat/simplex/app/views/usersettings/NotificationsSettingsView.kt index a509032a0..054686b0d 100644 --- a/apps/multiplatform/android/src/main/java/chat/simplex/app/views/usersettings/NotificationsSettingsView.kt +++ b/apps/multiplatform/android/src/main/java/chat/simplex/app/views/usersettings/NotificationsSettingsView.kt @@ -9,14 +9,12 @@ import androidx.compose.foundation.rememberScrollState import androidx.compose.foundation.verticalScroll import androidx.compose.material.* import androidx.compose.runtime.* -import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import dev.icerock.moko.resources.compose.stringResource import androidx.compose.ui.text.capitalize import androidx.compose.ui.text.intl.Locale import androidx.compose.ui.text.style.TextOverflow import chat.simplex.app.* -import chat.simplex.app.R import chat.simplex.app.model.ChatModel import chat.simplex.app.ui.theme.* import chat.simplex.app.views.helpers.* @@ -189,14 +187,14 @@ fun notificationPreviewModes(): List> { fun changeNotificationsMode(mode: NotificationsMode, chatModel: ChatModel) { chatModel.controller.appPrefs.notificationsMode.set(mode.name) - if (mode.requiresIgnoringBattery && !chatModel.controller.isIgnoringBatteryOptimizations()) { + if (mode.requiresIgnoringBattery && !SimplexService.isIgnoringBatteryOptimizations()) { chatModel.controller.appPrefs.backgroundServiceNoticeShown.set(false) } chatModel.notificationsMode.value = mode SimplexService.StartReceiver.toggleReceiver(mode == NotificationsMode.SERVICE) CoroutineScope(Dispatchers.Default).launch { if (mode == NotificationsMode.SERVICE) - SimplexService.start(SimplexApp.context) + SimplexService.start() else SimplexService.safeStopService(SimplexApp.context) } @@ -204,5 +202,5 @@ fun changeNotificationsMode(mode: NotificationsMode, chatModel: ChatModel) { if (mode != NotificationsMode.PERIODIC) { MessagesFetcherWorker.cancelAll() } - chatModel.controller.showBackgroundServiceNoticeIfNeeded() + SimplexService.showBackgroundServiceNoticeIfNeeded() }