[PR] KNUTICE 1.5.0 RC 2

app/build.gradle.kts

@@ -34,7 +34,7 @@ android {
         applicationId = "com.doyoonkim.knutice"
         minSdk = 31
         targetSdk = 35
-        versionCode = 24
+        versionCode = 26
         versionName = "1.5.0"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"

app/src/main/java/com/doyoonkim/knutice/MainActivity.kt

@@ -1,6 +1,7 @@
 package com.doyoonkim.knutice
 
 import android.Manifest
+import android.app.AlarmManager
 import android.content.Intent
 import android.net.Uri
 import android.os.Bundle
@@ -42,6 +43,9 @@ import com.doyoonkim.common.R
 import com.doyoonkim.common.di.AppPreferences
 import com.doyoonkim.common.theme.onAnyBackground
 import com.doyoonkim.common.theme.variantPurple
+import com.doyoonkim.knutice.di.components.DaggerMainActivityComponent
+import com.doyoonkim.knutice.di.components.DaggerSplashSceneComponent
+import com.doyoonkim.knutice.di.util.DefaultSystemService
 import com.doyoonkim.main.splash.KnuticeSplashScreen
 import com.doyoonkim.main.viewmodel.SplashViewModel
 import com.doyoonkim.notification.local.NotificationAlarmScheduler
@@ -50,17 +54,18 @@ import javax.inject.Inject
 
 class MainActivity : ComponentActivity() {
 
-    @Inject lateinit var viewModelFactory: ViewModelProvider.Factory
-    @Inject lateinit var notificationAlarmScheduler: NotificationAlarmScheduler
-    @Inject lateinit var appPreferences: AppPreferences
+     @Inject lateinit var alarmManager: AlarmManager
 
     // NavController
     private lateinit var navController: NavHostController
     private val activity = this
     private val receivedIntent = mutableStateOf<Intent?>(null)
 
     override fun onCreate(savedInstanceState: Bundle?) {
-        (applicationContext as MainApplication).appComponent.inject(this)
+        val appComponent = (application as MainApplication).appComponent
+        DaggerMainActivityComponent.factory().create(DefaultSystemService(appComponent))
+            .inject(this)
+
         super.onCreate(savedInstanceState)
         receivedIntent.value = intent
 
@@ -76,9 +81,13 @@ class MainActivity : ComponentActivity() {
 
                 var isPreProcessCompleted by remember { mutableStateOf(false) }
                 if (!isPreProcessCompleted) {
+                    val sceneComponent = remember(appComponent) {
+                        DaggerSplashSceneComponent.factory().create(DefaultSystemService(appComponent))
+                    }
+
                     KnuticeSplashScreen(
                         modifier = Modifier.fillMaxSize(),
-                        viewModel = viewModel<SplashViewModel>(factory = viewModelFactory)
+                        viewModel = viewModel<SplashViewModel>(factory = sceneComponent.viewModelFactory())
                     ) { result ->
                         if (!result) this.finish()
                         isPreProcessCompleted = true
@@ -94,7 +103,7 @@ class MainActivity : ComponentActivity() {
                         permissions.entries.forEach {
                             Log.d("MainServiceScreen", "${it.key}, ${it.value}")
                             if (it.key == Manifest.permission.SCHEDULE_EXACT_ALARM
-                                && !notificationAlarmScheduler.canScheduleExactAlarms()) {
+                                && !alarmManager.canScheduleExactAlarms()) {
                                 showPermissionRationale = true
                             }
                         }
@@ -114,7 +123,6 @@ class MainActivity : ComponentActivity() {
                     MainServiceScreen(
                         modifier = Modifier,
                         navController = navController,
-                        viewModelFactory = viewModelFactory
                     ) { activity.finish() }
 
                     if (showPermissionRationale) {

app/src/main/java/com/doyoonkim/knutice/MainApplication.kt

@@ -4,11 +4,14 @@ import android.app.Application
 import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.os.Build
+import android.util.Log
 import com.doyoonkim.common.di.AppInjector
 import com.doyoonkim.common.di.AppInjectorProvider
 import com.doyoonkim.common.R
 import com.doyoonkim.knutice.di.components.AppComponent
 import com.doyoonkim.knutice.di.components.DaggerAppComponent
+import com.doyoonkim.knutice.di.components.DaggerNotificationServiceComponent
+import com.doyoonkim.knutice.di.util.DefaultSystemService
 import com.doyoonkim.notification.fcm.PushNotificationService
 import javax.inject.Inject
 
@@ -21,16 +24,21 @@ class MainApplication() : Application(), AppInjectorProvider {
     override val appInjector: AppInjector = object : AppInjector {
         override fun inject(target: Any) {
             when(target) {
-                is PushNotificationService -> appComponent.inject(target)
+                is PushNotificationService -> {
+                    DaggerNotificationServiceComponent.factory()
+                        .create(DefaultSystemService(appComponent)).inject(target)
+                }
                 else -> error("Unsupported Target $target")
             }
         }
+
     }
 
     @Inject lateinit var notificationManager: NotificationManager
 
     override fun onCreate() {
         super.onCreate()
+        // Application-Level injection
         appComponent.inject(this)
 
         // Create channel group

app/src/main/java/com/doyoonkim/knutice/MainServiceScreen.kt

@@ -13,15 +13,13 @@ import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Scaffold
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import androidx.lifecycle.ViewModelProvider
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.navigation.NavHostController
 import androidx.navigation.compose.currentBackStackEntryAsState
 import com.doyoonkim.common.R
@@ -30,15 +28,12 @@ import com.doyoonkim.common.theme.displayBackground
 import com.doyoonkim.common.theme.onAnyBackground
 import com.doyoonkim.common.theme.subTitle
 import com.doyoonkim.common.theme.title
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
+import com.doyoonkim.knutice.navigation.AppNavHost
 
 @Composable
 fun MainServiceScreen(
     modifier: Modifier = Modifier,
     navController: NavHostController,
-    viewModelFactory: ViewModelProvider.Factory,
     onExit: () -> Unit
 ) {
 
@@ -138,7 +133,6 @@ fun MainServiceScreen(
             modifier = Modifier,
             contentPadding = contentPadding,
             navController = navController,
-            viewModelFactory = viewModelFactory,
             onExit = onExit
         )
     }

app/src/main/java/com/doyoonkim/knutice/di/components/AppComponent.kt

@@ -1,49 +1,30 @@
 package com.doyoonkim.knutice.di.components
 
+import android.app.AlarmManager
 import android.app.Application
-import com.doyoonkim.bookmark.di.BookmarkModule
-import com.doyoonkim.common.di.CommonModule
-import com.doyoonkim.data.di.DataBindingModule
-import com.doyoonkim.data.di.DataModule
-import com.doyoonkim.domain.di.DomainModule
-import com.doyoonkim.knutice.MainActivity
+import android.app.NotificationManager
+import android.content.Context
+import android.content.SharedPreferences
+import com.doyoonkim.common.di.ApplicationContext
 import com.doyoonkim.knutice.MainApplication
-import com.doyoonkim.knutice.di.AppModule
-import com.doyoonkim.knutice.di.DispatcherModule
-import com.doyoonkim.knutice.di.ViewModelFactoryModule
-import com.doyoonkim.main.di.MainModule
-import com.doyoonkim.network.di.NetworkModule
-import com.doyoonkim.notification.di.NotificationBindingModule
-import com.doyoonkim.notification.di.NotificationModule
-import com.doyoonkim.notification.fcm.PushNotificationService
+import com.doyoonkim.knutice.di.modules.AppModule
 import dagger.BindsInstance
 import dagger.Component
-import javax.inject.Singleton
 
-@Singleton
 @Component(
     modules = [
-        AppModule::class,
-        DispatcherModule::class,
-        CommonModule::class,
-        DataModule::class,
-        DataBindingModule::class,
-        DomainModule::class,
-        NetworkModule::class,
-        NotificationModule::class,
-        NotificationBindingModule::class,
-        BookmarkModule::class,
-        MainModule::class,
-        ViewModelFactoryModule::class
+        AppModule::class
     ]
 )
 interface AppComponent {
 
     fun inject(app: MainApplication)
 
-    fun inject(activity: MainActivity)
-
-    fun inject(service: PushNotificationService)
+    // Provision Functions
+    @ApplicationContext fun applicationContext(): Context
+    fun sharedPreference(): SharedPreferences
+    fun alarmManager(): AlarmManager
+    fun notificationManager(): NotificationManager
 
     @Component.Factory
     interface Factory {

app/src/main/java/com/doyoonkim/knutice/di/components/MainActivityComponent.kt

@@ -0,0 +1,18 @@
+package com.doyoonkim.knutice.di.components
+
+
+import com.doyoonkim.knutice.MainActivity
+import com.doyoonkim.knutice.di.util.SystemServices
+import dagger.Component
+
+@Component(
+    dependencies = [SystemServices::class]
+)
+interface MainActivityComponent {
+    fun inject(activity: MainActivity)
+
+    @Component.Factory
+    interface Factory {
+        fun create(systemServices: SystemServices): MainActivityComponent
+    }
+}

app/src/main/java/com/doyoonkim/knutice/di/components/NotificationServiceComponent.kt

@@ -0,0 +1,31 @@
+package com.doyoonkim.knutice.di.components
+
+import com.doyoonkim.common.di.CommonModule
+import com.doyoonkim.data.di.ImageRemoteModule
+import com.doyoonkim.data.di.NoticeRemoteModule
+import com.doyoonkim.knutice.di.modules.DispatcherModule
+import com.doyoonkim.knutice.di.util.SystemServices
+import com.doyoonkim.network.di.NotificationNetworkModule
+import com.doyoonkim.notification.di.NotificationModule
+import com.doyoonkim.notification.fcm.PushNotificationService
+import dagger.Component
+
+@Component(
+    dependencies = [SystemServices::class],
+    modules = [
+        NotificationModule::class,
+        DispatcherModule::class,
+        NoticeRemoteModule::class,
+        ImageRemoteModule::class,
+        CommonModule::class,
+        NotificationNetworkModule::class
+    ]
+)
+interface NotificationServiceComponent {
+    fun inject(service: PushNotificationService)
+
+    @Component.Factory
+    interface Factory {
+        fun create(systemServices: SystemServices): NotificationServiceComponent
+    }
+}