implemented Native Notifications

Rohit-554 · Rohit-554 · commit 649fd9f4d2b1 · 2025-12-26T22:35:42.000+05:30
diff --git a/composeApp/src/androidMain/AndroidManifest.xml b/composeApp/src/androidMain/AndroidManifest.xml
@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
     <application
         android:name=".MyTodoApp"
         android:allowBackup="true"
diff --git a/composeApp/src/androidMain/kotlin/io/jadu/MyTodoApp.kt b/composeApp/src/androidMain/kotlin/io/jadu/MyTodoApp.kt
@@ -1,10 +1,12 @@
 package io.jadu
 
 import android.app.Application
+import io.jadu.todoApp.ui.notification.PlatformActivityProvider
 
 class MyTodoApp : Application() {
     override fun onCreate() {
         super.onCreate()
+        registerActivityLifecycleCallbacks(PlatformActivityProvider)
         initKoin(this)
     }
 }
diff --git a/composeApp/src/androidMain/kotlin/io/jadu/di.android.kt b/composeApp/src/androidMain/kotlin/io/jadu/di.android.kt
@@ -3,13 +3,15 @@ package io.jadu
 import android.app.Application
 import createDataStore
 import getDatabaseBuilder
+import io.jadu.todoApp.ui.notification.LocalNotificationManager
 import org.koin.android.ext.koin.androidContext
 import org.koin.core.module.Module
 import org.koin.dsl.module
 
 val androidModule = module {
     single { getDatabaseBuilder(androidContext()) }
     single { createDataStore(androidContext()) }
+    single { LocalNotificationManager(androidContext()) }
 }
 
 actual fun platformModule(): Module = androidModule
diff --git a/composeApp/src/androidMain/kotlin/io/jadu/todoApp/ui/notification/LocalNotificationManager.android.kt b/composeApp/src/androidMain/kotlin/io/jadu/todoApp/ui/notification/LocalNotificationManager.android.kt
@@ -0,0 +1,87 @@
+package io.jadu.todoApp.ui.notification
+
+import android.Manifest
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.app.ActivityCompat
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.content.ContextCompat
+import kotlin.random.Random
+
+actual class LocalNotificationManager (
+    private val context: Context
+) {
+    actual fun showNotification(title: String, body: String) {
+        val channelId = "default_channel_id"
+        val notificationId = Random.nextInt()
+
+        // 1. Create the NotificationChannel (Required for API 26+)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val name = "General Notifications"
+            val descriptionText = "Default channel for app notifications"
+            val importance = NotificationManager.IMPORTANCE_DEFAULT
+            val channel = NotificationChannel(channelId, name, importance).apply {
+                description = descriptionText
+            }
+            // Register the channel with the system
+            val notificationManager: NotificationManager =
+                context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+            notificationManager.createNotificationChannel(channel)
+        }
+
+        // 2. Build the notification
+        val builder = NotificationCompat.Builder(context, channelId)
+            .setSmallIcon(android.R.drawable.ic_dialog_info) // Replace with your app's icon
+            .setContentTitle(title)
+            .setContentText(body)
+            .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+            .setAutoCancel(true)
+
+        // 3. Show the notification
+        with(NotificationManagerCompat.from(context)) {
+            // Check for permission strictly required on Android 13+
+            try {
+                notify(notificationId, builder.build())
+            } catch (e: SecurityException) {
+                // Handle missing permission
+                println("Notification permission missing")
+            }
+        }
+    }
+
+    actual fun hasPermission(): Boolean {
+        return if (Build.VERSION.SDK_INT >= 33) { // Android 13+
+            ContextCompat.checkSelfPermission(
+                context,
+                Manifest.permission.POST_NOTIFICATIONS
+            ) == PackageManager.PERMISSION_GRANTED
+        } else {
+            true // Android 12 and below have implicit permission
+        }
+    }
+
+    actual suspend fun requestPermission(): Boolean {
+        if (hasPermission()) return true
+
+        // for Android 13
+        if (Build.VERSION.SDK_INT >= 33) {
+            val activity = PlatformActivityProvider.currentActivity
+            if (activity!=null) {
+                ActivityCompat.requestPermissions(
+                    activity,
+                    arrayOf(Manifest.permission.POST_NOTIFICATIONS),
+                    123 // Request Code
+                )
+                return false
+            } else {
+                println("LocalNotificationService needs an Activity Context to request permissions")
+                return false
+            }
+        }
+        return true
+    }
+}
diff --git a/composeApp/src/androidMain/kotlin/io/jadu/todoApp/ui/notification/PlatformActivityProvider.kt b/composeApp/src/androidMain/kotlin/io/jadu/todoApp/ui/notification/PlatformActivityProvider.kt
@@ -0,0 +1,27 @@
+package io.jadu.todoApp.ui.notification
+
+import android.app.Activity
+import android.app.Application
+import android.os.Bundle
+import java.lang.ref.WeakReference
+
+object PlatformActivityProvider : Application.ActivityLifecycleCallbacks {
+    // WeakReference prevents memory leaks
+    private var currentActivityRef: WeakReference<Activity>? = null
+
+    val currentActivity: Activity?
+        get() = currentActivityRef?.get()
+
+
+    override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}
+    override fun onActivityStarted(activity: Activity) {
+        currentActivityRef = WeakReference(activity)
+    }
+    override fun onActivityResumed(activity: Activity) {
+        currentActivityRef = WeakReference(activity)
+    }
+    override fun onActivityPaused(activity: Activity) {}
+    override fun onActivityStopped(activity: Activity) {}
+    override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
+    override fun onActivityDestroyed(activity: Activity) {}
+}
diff --git a/composeApp/src/commonMain/kotlin/io/jadu/di.kt b/composeApp/src/commonMain/kotlin/io/jadu/di.kt
@@ -5,6 +5,7 @@ import androidx.room.RoomDatabase
 import io.jadu.todoApp.data.TodoRepositoryImpl
 import io.jadu.todoApp.data.local.AppDatabase
 import io.jadu.todoApp.domain.TodoRepository
+import io.jadu.todoApp.ui.notification.NotificationViewModel
 import io.jadu.todoApp.ui.viewModel.AddProjectViewModel
 import io.jadu.todoApp.ui.viewModel.EditTodoViewModel
 import io.jadu.todoApp.ui.viewModel.HomeScreenViewModel
@@ -43,6 +44,7 @@ val appModule = module {
     single { HomeScreenViewModel(get(), get()) }
     single { SettingsViewModel(get(), get()) }
     single { MostUsedCategoryViewModel(get()) }
+    single { NotificationViewModel(get()) }
 }
 
 
diff --git a/composeApp/src/commonMain/kotlin/io/jadu/todoApp/ui/notification/LocalNotificationManager.kt b/composeApp/src/commonMain/kotlin/io/jadu/todoApp/ui/notification/LocalNotificationManager.kt
@@ -0,0 +1,7 @@
+package io.jadu.todoApp.ui.notification
+
+expect class LocalNotificationManager {
+    fun hasPermission(): Boolean
+    suspend fun requestPermission(): Boolean
+    fun showNotification(title: String, body: String)
+}
diff --git a/composeApp/src/commonMain/kotlin/io/jadu/todoApp/ui/notification/NotificationViewModel.kt b/composeApp/src/commonMain/kotlin/io/jadu/todoApp/ui/notification/NotificationViewModel.kt
@@ -0,0 +1,22 @@
+package io.jadu.todoApp.ui.notification
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.launch
+
+class NotificationViewModel(private val manager: LocalNotificationManager): ViewModel() {
+
+    fun onEnableNotificationsClicked() {
+        viewModelScope.launch {
+            if (!manager.hasPermission()) {
+                val granted = manager.requestPermission()
+
+                if (granted) {
+                    manager.showNotification("Success", "Notifications enabled!")
+                }
+            } else {
+                manager.showNotification("Success", "Notifications enabled!")
+            }
+        }
+    }
+}
diff --git a/composeApp/src/commonMain/kotlin/io/jadu/todoApp/ui/screens/homescreen/components/HomePageContent.kt b/composeApp/src/commonMain/kotlin/io/jadu/todoApp/ui/screens/homescreen/components/HomePageContent.kt
@@ -21,6 +21,7 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import androidx.navigation.NavController
+import io.jadu.todoApp.ui.notification.NotificationViewModel
 import io.jadu.todoApp.ui.route.NavRoute
 import io.jadu.todoApp.ui.theme.BodyLarge
 import io.jadu.todoApp.ui.theme.Spacing
@@ -33,7 +34,8 @@ import org.koin.compose.koinInject
 @Composable
 fun HomePageContent(
     navController: NavController,
-    viewModel: HomeScreenViewModel = koinInject()
+    viewModel: HomeScreenViewModel = koinInject(),
+    notificationVM: NotificationViewModel = koinInject()
 ) {
     val uiState by viewModel.uiState.collectAsState()
 
@@ -46,7 +48,12 @@ fun HomePageContent(
         Column(
             modifier = Modifier.padding(Spacing.s4)
         ) {
-            UserHeader(userProfile = uiState.userProfile)
+            UserHeader(
+                userProfile = uiState.userProfile,
+                onNotificationClick = {
+                    notificationVM.onEnableNotificationsClicked()
+                }
+            )
             VSpacer(Spacing.s6)
             TaskProgressCard(
                 progress = uiState.todayProgress,
diff --git a/composeApp/src/commonMain/kotlin/io/jadu/todoApp/ui/screens/homescreen/components/UserHeader.kt b/composeApp/src/commonMain/kotlin/io/jadu/todoApp/ui/screens/homescreen/components/UserHeader.kt
@@ -21,6 +21,7 @@ import androidx.compose.ui.graphics.ColorFilter
 import androidx.compose.ui.layout.ContentScale
 import coil3.compose.AsyncImage
 import io.jadu.todoApp.data.model.UserProfile
+import io.jadu.todoApp.ui.components.bounceClickable
 import io.jadu.todoApp.ui.theme.BodyLarge
 import io.jadu.todoApp.ui.theme.BodySmall
 import io.jadu.todoApp.ui.theme.BodyXXLarge
@@ -36,7 +37,8 @@ import todo_list.composeapp.generated.resources.user_octagon
 @Composable
 @Preview(showBackground = true)
 fun UserHeader(
-    userProfile: UserProfile = UserProfile()
+    userProfile: UserProfile = UserProfile(),
+    onNotificationClick: () -> Unit
 ) {
 
     val shouldShowNotificationDot = remember { mutableStateOf(true) }
@@ -103,7 +105,9 @@ fun UserHeader(
         }
 
         Box(
-            modifier = Modifier.size(Spacing.s6)
+            modifier = Modifier
+                .size(Spacing.s6)
+                .bounceClickable(onClick = onNotificationClick)
         ) {
             Image(
                 painter = painterResource(Res.drawable.notification),
diff --git a/composeApp/src/iosMain/kotlin/io/jadu/di.ios.kt b/composeApp/src/iosMain/kotlin/io/jadu/di.ios.kt
@@ -2,12 +2,14 @@ package io.jadu
 
 import createDataStore
 import getDatabaseBuilder
+import io.jadu.todoApp.ui.notification.LocalNotificationManager
 import org.koin.core.module.Module
 import org.koin.dsl.module
 
 val iosModule = module {
     single { getDatabaseBuilder() }
     single { createDataStore() }
+    single { LocalNotificationManager() }
 }
 actual fun platformModule(): Module = iosModule
 
diff --git a/composeApp/src/iosMain/kotlin/io/jadu/todoApp/ui/notification/LocalNotificationManager.ios.kt b/composeApp/src/iosMain/kotlin/io/jadu/todoApp/ui/notification/LocalNotificationManager.ios.kt
@@ -0,0 +1,70 @@
+package io.jadu.todoApp.ui.notification
+
+import platform.Foundation.timeIntervalSince1970
+import platform.UserNotifications.UNAuthorizationOptionAlert
+import platform.UserNotifications.UNAuthorizationOptionBadge
+import platform.UserNotifications.UNAuthorizationOptionSound
+import platform.UserNotifications.UNMutableNotificationContent
+import platform.UserNotifications.UNNotificationRequest
+import platform.UserNotifications.UNTimeIntervalNotificationTrigger
+import platform.UserNotifications.UNUserNotificationCenter
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+
+actual class LocalNotificationManager {
+
+    init {
+        // Request permission on initialization (or call this from a separate method)
+        val center = UNUserNotificationCenter.currentNotificationCenter()
+        val options = UNAuthorizationOptionAlert or UNAuthorizationOptionSound or UNAuthorizationOptionBadge
+
+        center.requestAuthorizationWithOptions(options) { granted, error ->
+            if (granted) {
+                println("Notification permission granted")
+            } else {
+                println("Notification permission denied: $error")
+            }
+        }
+    }
+
+    actual fun showNotification(title: String, body: String) {
+        val content = UNMutableNotificationContent().apply {
+            setTitle(title)
+            setBody(body)
+            setSound(platform.UserNotifications.UNNotificationSound.defaultSound)
+        }
+
+        // Trigger the notification after 1 second
+        val trigger = UNTimeIntervalNotificationTrigger.triggerWithTimeInterval(1.0, repeats = false)
+
+        val request = UNNotificationRequest.requestWithIdentifier(
+            identifier = "notification_${platform.Foundation.NSDate().timeIntervalSince1970}",
+            content = content,
+            trigger = trigger
+        )
+
+        UNUserNotificationCenter.currentNotificationCenter().addNotificationRequest(request) { error ->
+            if (error != null) {
+                println("Error showing notification: $error")
+            }
+        }
+    }
+
+    actual fun hasPermission(): Boolean {
+       return true
+    }
+
+    actual suspend fun requestPermission(): Boolean = suspendCoroutine { continuation ->
+        val center = UNUserNotificationCenter.currentNotificationCenter()
+        val options = UNAuthorizationOptionAlert or UNAuthorizationOptionSound or UNAuthorizationOptionBadge
+
+        center.requestAuthorizationWithOptions(options) { granted, error ->
+            if (error != null) {
+                println("Notification permission error: $error")
+                continuation.resume(false)
+            } else {
+                continuation.resume(granted)
+            }
+        }
+    }
+}
diff --git a/iosApp/iosApp/iOSApp.swift b/iosApp/iosApp/iOSApp.swift
@@ -5,9 +5,21 @@ struct iOSApp: App {
     init() {
         Di_iosKt.doInitKoin()
     }
+    @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
     var body: some Scene {
         WindowGroup {
             ContentView()
         }
     }
+}
+
+class AppDelegate: NSObject, UIApplicationDelegate, UNUserNotificationCenterDelegate {
+    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
+        UNUserNotificationCenter.current().delegate = self
+        return true
+    }
+
+    func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
+        completionHandler([.banner, .sound])
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,12 @@`
`1`	`1`	`package io.jadu`
`2`	`2`
`3`	`3`	`import android.app.Application`
	`4`	`+import io.jadu.todoApp.ui.notification.PlatformActivityProvider`
`4`	`5`
`5`	`6`	`class MyTodoApp : Application() {`
`6`	`7`	`override fun onCreate() {`
`7`	`8`	`super.onCreate()`
	`9`	`+ registerActivityLifecycleCallbacks(PlatformActivityProvider)`
`8`	`10`	`initKoin(this)`
`9`	`11`	`}`
`10`	`12`	`}`