devlab/server-manager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: push notifications via WorkManager background polling

Browse Source 
- NotificationWorker checks for new notifications every 15 min (WorkManager)
- Shows Android system notifications with Mark Read action
- Notification channels for general + alerts
- Permission request on Android 13+
- Boot persistence via WorkManager
- On-app-open immediate notification check
This commit is contained in:
Agent
2026-06-09 17:22:01 -04:00
parent 086bbda6e8
commit 1f67fc1fcd
9 changed files with 305 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
android/app/build.gradle.kts
View File

@@ -63,6 +63,7 @@ dependencies {
implementation("androidx.datastore:datastore-preferences:1.1.3")
implementation("androidx.core:core-splashscreen:1.0.1")
implementation("androidx.work:work-runtime-ktx:2.10.0")
debugImplementation("androidx.compose.ui:ui-tooling")
debugImplementation("androidx.compose.ui:ui-test-manifest")

10
android/app/src/main/AndroidManifest.xml
View File

@@ -5,6 +5,8 @@
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
<uses-permission android:name="android.permission.DOWNLOAD_WITHOUT_NOTIFICATION" />
<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
<application
android:name=".ServerManagerApp"
@@ -25,6 +27,14 @@
</intent-filter>
</activity>
<receiver
android:name=".util.NotificationActionReceiver"
android:exported="false">
<intent-filter>
<action android:name="com.devlab.app.MARK_READ" />
</intent-filter>
</receiver>
<provider
android:name="androidx.core.content.FileProvider"
android:authorities="${applicationId}.fileprovider"

21
android/app/src/main/java/com/devlab/app/MainActivity.kt
View File

@@ -1,10 +1,15 @@
package com.devlab.app
import android.Manifest
import android.app.AlertDialog
import android.content.pm.PackageManager
import android.os.Build
import android.os.Bundle
import androidx.core.app.ActivityCompat
import androidx.lifecycle.lifecycleScope
import com.devlab.app.util.AppUpdater
import com.devlab.app.util.UpdateChecker
import com.devlab.app.worker.NotificationWorker
import kotlinx.coroutines.launch
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
@@ -45,7 +50,9 @@ class MainActivity : ComponentActivity() {
installSplashScreen()
super.onCreate(savedInstanceState)
enableEdgeToEdge()
requestNotificationPermission()
checkForUpdates()
NotificationWorker.checkNow(this)
setContent {
ServerManagerTheme {
AppRoot()
@@ -53,6 +60,20 @@ class MainActivity : ComponentActivity() {
}
}
private fun requestNotificationPermission() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
if (checkSelfPermission(Manifest.permission.POST_NOTIFICATIONS)
!= PackageManager.PERMISSION_GRANTED
) {
ActivityCompat.requestPermissions(
this,
arrayOf(Manifest.permission.POST_NOTIFICATIONS),
1001
)
}
}
}
private fun checkForUpdates() {
val versionName = try {
packageManager.getPackageInfo(packageName, 0).versionName ?: "1.0.0"

4
android/app/src/main/java/com/devlab/app/ServerManagerApp.kt
View File

@@ -1,11 +1,15 @@
package com.devlab.app
import android.app.Application
import com.devlab.app.util.NotificationHelper
import com.devlab.app.worker.NotificationWorker
class ServerManagerApp : Application() {
override fun onCreate() {
super.onCreate()
instance = this
NotificationHelper.createChannels(this)
NotificationWorker.schedule(this)
}
companion object {

29
android/app/src/main/java/com/devlab/app/util/NotificationActionReceiver.kt Normal file
View File

@@ -0,0 +1,29 @@
package com.devlab.app.util
import android.app.NotificationManager
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
class NotificationActionReceiver : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) {
if (intent.action == "com.devlab.app.MARK_READ") {
val notificationId = intent.getIntExtra("notification_id", 0)
if (notificationId > 0) {
val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
manager.cancel(notificationId)
CoroutineScope(Dispatchers.IO).launch {
try {
val service = com.devlab.app.data.api.RetrofitClient.getApiService()
service.markNotificationRead(notificationId)
} catch (_: Exception) { }
}
}
}
}
}

120
android/app/src/main/java/com/devlab/app/util/NotificationHelper.kt Normal file
View File

@@ -0,0 +1,120 @@
package com.devlab.app.util
import android.Manifest
import android.app.NotificationChannel
import android.app.NotificationManager
import android.app.PendingIntent
import android.content.Context
import android.content.Intent
import android.content.pm.PackageManager
import android.os.Build
import androidx.core.app.NotificationCompat
import androidx.core.app.NotificationManagerCompat
import androidx.core.content.ContextCompat
import com.devlab.app.MainActivity
import com.devlab.app.R
import com.devlab.app.data.model.AppNotification
object NotificationHelper {
private const val CHANNEL_GENERAL = "notifications_general"
private const val CHANNEL_ALERTS = "notifications_alerts"
fun createChannels(context: Context) {
val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
val general = NotificationChannel(
CHANNEL_GENERAL, "Notifications",
NotificationManager.IMPORTANCE_DEFAULT
).apply {
description = "Server notifications and alerts"
}
val alerts = NotificationChannel(
CHANNEL_ALERTS, "Alerts",
NotificationManager.IMPORTANCE_HIGH
).apply {
description = "Important alerts requiring attention"
}
manager.createNotificationChannel(general)
manager.createNotificationChannel(alerts)
}
fun showNotification(context: Context, notification: AppNotification) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
if (ContextCompat.checkSelfPermission(
context, Manifest.permission.POST_NOTIFICATIONS
) != PackageManager.PERMISSION_GRANTED
) {
return
}
}
val intent = Intent(context, MainActivity::class.java).apply {
flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
putExtra("open_notification", notification.id)
}
val pendingIntent = PendingIntent.getActivity(
context, notification.id, intent,
PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
)
val markReadIntent = Intent(context, NotificationActionReceiver::class.java).apply {
action = "com.devlab.app.MARK_READ"
putExtra("notification_id", notification.id)
}
val markReadPendingIntent = PendingIntent.getBroadcast(
context, notification.id + 1000, markReadIntent,
PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
)
val channel = when (notification.type) {
"error" -> CHANNEL_ALERTS
"warning" -> CHANNEL_ALERTS
else -> CHANNEL_GENERAL
}
val icon = when (notification.type) {
"success" -> android.R.drawable.ic_dialog_info
"error" -> android.R.drawable.ic_dialog_alert
"warning" -> android.R.drawable.ic_dialog_alert
else -> android.R.drawable.ic_dialog_info
}
val built = NotificationCompat.Builder(context, channel)
.setSmallIcon(icon)
.setContentTitle(notification.title)
.setContentText(notification.message)
.setStyle(NotificationCompat.BigTextStyle().bigText(notification.message))
.setPriority(
when (notification.type) {
"error" -> NotificationCompat.PRIORITY_HIGH
"warning" -> NotificationCompat.PRIORITY_DEFAULT
else -> NotificationCompat.PRIORITY_DEFAULT
}
)
.setContentIntent(pendingIntent)
.addAction(
android.R.drawable.ic_input_add,
"Mark Read",
markReadPendingIntent
)
.setAutoCancel(true)
.setWhen(parseTime(notification.created_at))
NotificationManagerCompat.from(context).notify(notification.id, built.build())
}
private fun parseTime(time: String?): Long {
if (time == null) return System.currentTimeMillis()
return try {
java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss", java.util.Locale.US).apply {
timeZone = java.util.TimeZone.getTimeZone("UTC")
}.parse(time)?.time ?: System.currentTimeMillis()
} catch (_: Exception) {
System.currentTimeMillis()
}
}
}

12
android/app/src/main/java/com/devlab/app/util/PreferencesManager.kt
View File

@@ -3,6 +3,7 @@ package com.devlab.app.util
import android.content.Context
import androidx.datastore.preferences.core.edit
import androidx.datastore.preferences.core.intPreferencesKey
import androidx.datastore.preferences.core.longPreferencesKey
import androidx.datastore.preferences.core.stringPreferencesKey
import androidx.datastore.preferences.preferencesDataStore
import kotlinx.coroutines.flow.Flow
@@ -19,6 +20,7 @@ class PreferencesManager(private val context: Context) {
private val KEY_EMAIL = stringPreferencesKey("email")
private val KEY_ROLE = stringPreferencesKey("role")
private val KEY_USER_ID = intPreferencesKey("user_id")
private val KEY_LAST_NOTIFICATION_CHECK = longPreferencesKey("last_notification_check")
}
val token: Flow<String> = context.dataStore.data.map { prefs ->
@@ -68,6 +70,16 @@ class PreferencesManager(private val context: Context) {
suspend fun getUsername(): String = context.dataStore.data.first()[KEY_USERNAME] ?: ""
suspend fun getEmail(): String = context.dataStore.data.first()[KEY_EMAIL] ?: ""
suspend fun getLastNotificationCheck(): Long {
return context.dataStore.data.first()[KEY_LAST_NOTIFICATION_CHECK] ?: 0L
}
suspend fun setLastNotificationCheck(time: Long) {
context.dataStore.edit { prefs ->
prefs[KEY_LAST_NOTIFICATION_CHECK] = time
}
}
suspend fun clear() {
context.dataStore.edit { it.clear() }
}

108
android/app/src/main/java/com/devlab/app/worker/NotificationWorker.kt Normal file
View File

@@ -0,0 +1,108 @@
package com.devlab.app.worker
import android.content.Context
import androidx.work.*
import com.devlab.app.data.api.RetrofitClient
import com.devlab.app.data.model.AppNotification
import com.devlab.app.util.NotificationHelper
import com.devlab.app.util.PreferencesManager
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import java.util.concurrent.TimeUnit
class NotificationWorker(
context: Context,
workerParams: WorkerParameters
) : CoroutineWorker(context, workerParams) {
override suspend fun doWork(): Result = withContext(Dispatchers.IO) {
try {
val prefs = PreferencesManager(applicationContext)
val token = prefs.getToken()
if (token.isBlank()) {
return@withContext Result.success()
}
val lastCheck = prefs.getLastNotificationCheck()
RetrofitClient.setToken(token)
val service = RetrofitClient.getApiService()
try {
val response = service.getNotifications(page = 1, perPage = 50)
if (response.success) {
val newNotifications = response.data.filter { note ->
val noteTime = parseTime(note.created_at)
noteTime > lastCheck && note.is_read == 0
}
for (notification in newNotifications) {
NotificationHelper.showNotification(applicationContext, notification)
}
val lastTime = newNotifications.maxOfOrNull {
parseTime(it.created_at)
} ?: System.currentTimeMillis()
prefs.setLastNotificationCheck(
if (newNotifications.isNotEmpty()) lastTime else System.currentTimeMillis()
)
}
} catch (_: Exception) { }
Result.success()
} catch (_: Exception) {
Result.retry()
}
}
private fun parseTime(time: String?): Long {
if (time == null) return 0L
return try {
val sdf = java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss", java.util.Locale.US).apply {
timeZone = java.util.TimeZone.getTimeZone("UTC")
}
sdf.parse(time)?.time ?: 0L
} catch (_: Exception) {
0L
}
}
companion object {
private const val WORK_NAME = "notification_check"
fun schedule(context: Context) {
val constraints = Constraints.Builder()
.setRequiredNetworkType(NetworkType.CONNECTED)
.build()
val request = PeriodicWorkRequestBuilder<NotificationWorker>(
15, TimeUnit.MINUTES
)
.setConstraints(constraints)
.setBackoffCriteria(
BackoffPolicy.EXPONENTIAL,
1, TimeUnit.MINUTES
)
.build()
WorkManager.getInstance(context).enqueueUniquePeriodicWork(
WORK_NAME,
ExistingPeriodicWorkPolicy.KEEP,
request
)
}
fun checkNow(context: Context) {
val constraints = Constraints.Builder()
.setRequiredNetworkType(NetworkType.CONNECTED)
.build()
val request = OneTimeWorkRequestBuilder<NotificationWorker>()
.setConstraints(constraints)
.build()
WorkManager.getInstance(context).enqueue(request)
}
}
}

BIN
public/sysadmin.apk
View File

Binary file not shown.