wip permissions

androidApp/src/androidMain/kotlin/org/jetbrains/kotlinconf/android/MainActivity.kt

@@ -7,24 +7,24 @@ import androidx.activity.SystemBarStyle
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
 import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
-import com.jetbrains.kotlinconf.R
 import org.jetbrains.kotlinconf.App
-import org.jetbrains.kotlinconf.ApplicationContext
+import org.jetbrains.kotlinconf.platformModule
 
 class MainActivity : ComponentActivity() {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         installSplashScreen()
+        enableEdgeToEdge()
 
-        val context = ApplicationContext(
-            application,
-            R.mipmap.ic_launcher,
+        val platformModule = platformModule(
+            activity = this,
+            application = application,
+            notificationIconId = com.jetbrains.kotlinconf.R.mipmap.ic_launcher,
         )
-
         setContent {
             App(
-                context = context,
+                platformModule = platformModule,
                 onThemeChange = { isDarkMode ->
                     enableEdgeToEdge(
                         statusBarStyle = SystemBarStyle.auto(

gradle/libs.versions.toml

@@ -34,6 +34,8 @@ postgresql = "42.7.3"
 androidx-navigation = "2.8.0-alpha12"
 doistx-normalize = "1.0.5"
 multiplatform-settings = "1.3.0"
+moko-permissions = "0.19.0"
+alarmee = "1.6.1"
 
 [libraries]
 
@@ -96,6 +98,7 @@ kotlinx-coroutines-swing = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-
 kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datetime" }
 logback-classic = { module = "ch.qos.logback:logback-classic", version.ref = "logbackClassic" }
 doistx-normalize = { module = "com.doist.x:normalize", version.ref = "doistx-normalize" }
+alarmee = { module = "io.github.tweener:alarmee", version.ref = "alarmee" }
 
 # images
 android-svg = { module = "com.caverock:androidsvg-aar", version.ref = "android-svg" }
@@ -111,6 +114,10 @@ settings-coroutines = { module = "com.russhwolf:multiplatform-settings-coroutine
 settings-serialization = { module = "com.russhwolf:multiplatform-settings-serialization", version.ref = "multiplatform-settings" }
 settings-observable = { module = "com.russhwolf:multiplatform-settings-make-observable", version.ref = "multiplatform-settings" }
 
+# moko-permissions
+moko-permissions = { module = "dev.icerock.moko:permissions", version.ref = "moko-permissions" }
+moko-permissions-notifications = { module = "dev.icerock.moko:permissions-notifications", version.ref = "moko-permissions" }
+
 [plugins]
 aboutLibraries = { id= "com.mikepenz.aboutlibraries.plugin", version.ref="aboutlibraries"}
 androidApplication = { id = "com.android.application", version.ref = "agp" }

shared/build.gradle.kts

@@ -100,12 +100,22 @@ kotlin {
             }
         }
 
+        val mobileMain by creating {
+            dependsOn(commonMain.get())
+            dependencies {
+                implementation(libs.moko.permissions)
+                implementation(libs.moko.permissions.notifications)
+                implementation(libs.alarmee)
+            }
+        }
+
         val nonAndroidMain by creating {
             dependsOn(commonMain.get())
         }
 
         androidMain {
             dependsOn(nonWebMain)
+            dependsOn(mobileMain)
             dependencies {
                 implementation(libs.android.svg)
                 implementation(libs.androidx.core.ktx)
@@ -119,6 +129,7 @@ kotlin {
         iosMain {
             dependsOn(nonWebMain)
             dependsOn(nonAndroidMain)
+            dependsOn(mobileMain)
             dependencies {
                 implementation(libs.ktor.client.darwin)
             }

shared/src/androidMain/kotlin/org/jetbrains/kotlinconf/platformModule.android.kt

@@ -0,0 +1,63 @@
+package org.jetbrains.kotlinconf
+
+import android.app.Application
+import androidx.activity.ComponentActivity
+import androidx.compose.ui.graphics.Color
+import androidx.preference.PreferenceManager
+import com.russhwolf.settings.ObservableSettings
+import com.russhwolf.settings.SharedPreferencesSettings
+import com.tweener.alarmee.AlarmeeScheduler
+import com.tweener.alarmee.AlarmeeSchedulerAndroid
+import com.tweener.alarmee.AndroidNotificationConfiguration
+import com.tweener.alarmee.AndroidNotificationPriority
+import com.tweener.alarmee.channel.AlarmeeNotificationChannel
+import com.tweener.alarmee.configuration.AlarmeeAndroidPlatformConfiguration
+import dev.icerock.moko.permissions.PermissionsController
+import dev.icerock.moko.permissions.PermissionsControllerImpl
+import org.koin.core.module.Module
+import org.koin.dsl.module
+
+private const val ANDROID_NOTIFICATION_CHANNEL_ID = "channel_all_notifications"
+
+fun platformModule(
+    activity: ComponentActivity,
+    application: Application,
+    notificationIconId: Int,
+): Module = module {
+    single<ObservableSettings> {
+        SharedPreferencesSettings(PreferenceManager.getDefaultSharedPreferences(application))
+    }
+    single<NotificationManager> {
+        AlarmeeNotificationManager(
+            permissionsController = get(),
+            alarmeeScheduler = get(),
+            timeProvider = get(),
+            androidConfig = AndroidNotificationConfiguration(
+                AndroidNotificationPriority.HIGH,
+                ANDROID_NOTIFICATION_CHANNEL_ID,
+                notificationIconId,
+            ),
+        )
+    }
+    single<PermissionsController> {
+        PermissionsControllerImpl(application).apply {
+            bind(activity)
+        }
+    }
+    single<AlarmeeScheduler> {
+        AlarmeeSchedulerAndroid(
+            context = application,
+            configuration = AlarmeeAndroidPlatformConfiguration(
+                notificationIconResId = 0,
+                notificationIconColor = Color.White,
+                notificationChannels = listOf(
+                    AlarmeeNotificationChannel(
+                        id = ANDROID_NOTIFICATION_CHANNEL_ID,
+                        name = "All notifications",
+                        importance = android.app.NotificationManager.IMPORTANCE_HIGH,
+                    ),
+                ),
+            )
+        )
+    }
+}

shared/src/commonMain/kotlin/org/jetbrains/kotlinconf/App.kt

@@ -25,17 +25,18 @@ import org.jetbrains.kotlinconf.storage.MultiplatformSettingsStorage
 import org.jetbrains.kotlinconf.ui.theme.KotlinConfTheme
 import org.koin.compose.KoinMultiplatformApplication
 import org.koin.compose.koinInject
+import org.koin.core.module.Module
 import org.koin.core.module.dsl.singleOf
 import org.koin.core.module.dsl.viewModelOf
 import org.koin.dsl.koinConfiguration
 import org.koin.dsl.module
 
 @Composable
 fun App(
-    context: ApplicationContext,
+    platformModule: Module = module {},
     onThemeChange: ((isDarkTheme: Boolean) -> Unit)? = null,
 ) {
-    KoinMultiplatformApplication(koinConfiguration(context)) {
+    KoinMultiplatformApplication(koinConfiguration(platformModule)) {
         DevelopmentEntryPoint {
             val service = koinInject<ConferenceService>()
             val currentTheme by service.getTheme().collectAsStateWithLifecycle(initialValue = Theme.SYSTEM)
@@ -68,13 +69,12 @@ fun App(
     }
 }
 
-private fun koinConfiguration(context: ApplicationContext) = koinConfiguration {
+private fun koinConfiguration(platformModule: Module) = koinConfiguration {
     val appModule = module {
         single { APIClient(URLs.API_ENDPOINT) }
-        single<ApplicationStorage> { MultiplatformSettingsStorage(context) }
-        single { NotificationManager(context) }
-        single<TimeProvider> { ServerBasedTimeProvider(get()) }
-//        single<TimeProvider> { FakeTimeProvider() }
+        single<ApplicationStorage> { MultiplatformSettingsStorage(get()) }
+//        single<TimeProvider> { ServerBasedTimeProvider(get()) }
+        single<TimeProvider> { FakeTimeProvider() }
         singleOf(::ConferenceService)
     }
 
@@ -90,5 +90,5 @@ private fun koinConfiguration(context: ApplicationContext) = koinConfiguration {
         viewModelOf(::SpeakerDetailViewModel)
     }
 
-    modules(appModule, viewModelModule)
+    modules(platformModule, appModule, viewModelModule)
 }