From 79393bf8a666e81e10984d88635b6ab12d639059 Mon Sep 17 00:00:00 2001 From: Vaishno Singh Date: Thu, 19 Nov 2026 00:27:15 +0530 Subject: [PATCH] feat: release v1.1.0 with Widgets, Background Monitor, Biometrics, History & NFC --- app/build.gradle.kts | 14 +- app/src/main/AndroidManifest.xml | 39 ++ .../java/com/expapp/trigger/MainActivity.kt | 237 +++++++- .../expapp/trigger/data/model/TriggerLog.kt | 17 + .../trigger/data/repository/AppSettings.kt | 32 ++ .../data/repository/DeviceRepository.kt | 25 +- .../repository/TriggerHistoryRepository.kt | 54 ++ .../expapp/trigger/network/TriggerClient.kt | 147 +++-- .../java/com/expapp/trigger/nfc/NfcHelper.kt | 121 +++++ .../trigger/security/BiometricHelper.kt | 60 +++ .../trigger/ui/components/HistoryDialog.kt | 510 ++++++++++++++++++ .../trigger/ui/components/NfcWriteDialog.kt | 312 +++++++++++ .../trigger/ui/components/SettingsDialog.kt | 261 +++++++++ .../expapp/trigger/ui/screens/MainScreen.kt | 288 +++++++--- .../java/com/expapp/trigger/ui/theme/Color.kt | 1 + .../trigger/widget/ServerWidgetProvider.kt | 271 ++++++++++ .../trigger/worker/ServerMonitorWorker.kt | 143 +++++ app/src/main/res/drawable/ic_refresh.xml | 9 + app/src/main/res/drawable/ic_terminal.xml | 9 + app/src/main/res/drawable/widget_bg.xml | 9 + .../main/res/drawable/widget_btn_amber.xml | 9 + .../main/res/drawable/widget_btn_green.xml | 9 + app/src/main/res/drawable/widget_btn_red.xml | 9 + app/src/main/res/drawable/widget_dot_gray.xml | 6 + .../main/res/drawable/widget_dot_green.xml | 6 + app/src/main/res/drawable/widget_dot_red.xml | 6 + .../main/res/layout/widget_server_control.xml | 156 ++++++ app/src/main/res/xml/server_widget_info.xml | 8 + .../data/repository/AppSettingsTest.kt | 61 +++ .../TriggerHistoryRepositoryTest.kt | 128 +++++ 30 files changed, 2827 insertions(+), 130 deletions(-) create mode 100644 app/src/main/java/com/expapp/trigger/data/model/TriggerLog.kt create mode 100644 app/src/main/java/com/expapp/trigger/data/repository/AppSettings.kt create mode 100644 app/src/main/java/com/expapp/trigger/data/repository/TriggerHistoryRepository.kt create mode 100644 app/src/main/java/com/expapp/trigger/nfc/NfcHelper.kt create mode 100644 app/src/main/java/com/expapp/trigger/security/BiometricHelper.kt create mode 100644 app/src/main/java/com/expapp/trigger/ui/components/HistoryDialog.kt create mode 100644 app/src/main/java/com/expapp/trigger/ui/components/NfcWriteDialog.kt create mode 100644 app/src/main/java/com/expapp/trigger/ui/components/SettingsDialog.kt create mode 100644 app/src/main/java/com/expapp/trigger/widget/ServerWidgetProvider.kt create mode 100644 app/src/main/java/com/expapp/trigger/worker/ServerMonitorWorker.kt create mode 100644 app/src/main/res/drawable/ic_refresh.xml create mode 100644 app/src/main/res/drawable/ic_terminal.xml create mode 100644 app/src/main/res/drawable/widget_bg.xml create mode 100644 app/src/main/res/drawable/widget_btn_amber.xml create mode 100644 app/src/main/res/drawable/widget_btn_green.xml create mode 100644 app/src/main/res/drawable/widget_btn_red.xml create mode 100644 app/src/main/res/drawable/widget_dot_gray.xml create mode 100644 app/src/main/res/drawable/widget_dot_green.xml create mode 100644 app/src/main/res/drawable/widget_dot_red.xml create mode 100644 app/src/main/res/layout/widget_server_control.xml create mode 100644 app/src/main/res/xml/server_widget_info.xml create mode 100644 app/src/test/java/com/expapp/trigger/data/repository/AppSettingsTest.kt create mode 100644 app/src/test/java/com/expapp/trigger/data/repository/TriggerHistoryRepositoryTest.kt diff --git a/app/build.gradle.kts b/app/build.gradle.kts index 5fc1c23..8e0469f 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -11,8 +11,8 @@ android { applicationId = "com.expapp.trigger" minSdk = 24 targetSdk = 34 - versionCode = 3 - versionName = "1.0.3" + versionCode = 4 + versionName = "1.1.0" testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" vectorDrawables { @@ -48,6 +48,11 @@ android { } } } + + lint { + checkReleaseBuilds = false + abortOnError = false + } compileOptions { sourceCompatibility = JavaVersion.VERSION_17 targetCompatibility = JavaVersion.VERSION_17 @@ -91,6 +96,11 @@ dependencies { implementation("com.squareup.okhttp3:okhttp:4.12.0") implementation("com.google.code.gson:gson:2.10.1") + // Biometrics & Background Work + implementation("androidx.fragment:fragment-ktx:1.6.2") + implementation("androidx.biometric:biometric:1.1.0") + implementation("androidx.work:work-runtime-ktx:2.9.0") + // Testing testImplementation("junit:junit:4.13.2") testImplementation("com.squareup.okhttp3:mockwebserver:4.12.0") diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index 27eace2..0ae1a68 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -4,6 +4,15 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/src/main/java/com/expapp/trigger/MainActivity.kt b/app/src/main/java/com/expapp/trigger/MainActivity.kt index f05610b..2afcaf9 100644 --- a/app/src/main/java/com/expapp/trigger/MainActivity.kt +++ b/app/src/main/java/com/expapp/trigger/MainActivity.kt @@ -1,26 +1,88 @@ package com.expapp.trigger +import android.Manifest +import android.content.Context +import android.content.Intent +import android.content.pm.PackageManager +import android.nfc.NfcAdapter +import android.nfc.Tag +import android.os.Build import android.os.Bundle -import androidx.activity.ComponentActivity +import android.os.VibrationEffect +import android.os.Vibrator +import android.os.VibratorManager +import android.widget.Toast import androidx.activity.compose.setContent import androidx.activity.enableEdgeToEdge +import androidx.activity.result.contract.ActivityResultContracts import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.material3.Surface +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue import androidx.compose.ui.Modifier +import androidx.core.content.ContextCompat +import androidx.fragment.app.FragmentActivity +import com.expapp.trigger.data.model.DeviceConfig +import com.expapp.trigger.data.model.TriggerLog +import com.expapp.trigger.data.repository.AppSettings import com.expapp.trigger.data.repository.DeviceRepository import com.expapp.trigger.data.repository.SharedPrefsStorage +import com.expapp.trigger.data.repository.TriggerHistoryRepository +import com.expapp.trigger.network.TriggerAction import com.expapp.trigger.network.TriggerClient +import com.expapp.trigger.nfc.NfcHelper +import com.expapp.trigger.nfc.NfcTriggerPayload +import com.expapp.trigger.security.BiometricHelper import com.expapp.trigger.ui.screens.MainScreen import com.expapp.trigger.ui.theme.DarkBackground import com.expapp.trigger.ui.theme.ExpAppTheme +import com.expapp.trigger.widget.ServerWidgetProvider +import com.expapp.trigger.worker.ServerMonitorWorker + +class MainActivity : FragmentActivity() { + + private lateinit var repository: DeviceRepository + private lateinit var triggerClient: TriggerClient + private lateinit var appSettings: AppSettings + private lateinit var historyRepository: TriggerHistoryRepository + + private var activeNfcWritePayload by mutableStateOf(null) + private var nfcWriteResult by mutableStateOf?>(null) + + private val notificationPermissionLauncher = + registerForActivityResult(ActivityResultContracts.RequestPermission()) { isGranted -> + if (isGranted && appSettings.isBackgroundMonitoringEnabled) { + ServerMonitorWorker.schedule(this) + } + } -class MainActivity : ComponentActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) enableEdgeToEdge() - val repository = DeviceRepository(SharedPrefsStorage(applicationContext)) - val triggerClient = TriggerClient() + repository = DeviceRepository(SharedPrefsStorage(applicationContext)) + triggerClient = TriggerClient() + appSettings = AppSettings(applicationContext) + historyRepository = TriggerHistoryRepository(applicationContext) + + // Request notification permission on Android 13+ + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) { + if (ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) + != PackageManager.PERMISSION_GRANTED + ) { + notificationPermissionLauncher.launch(Manifest.permission.POST_NOTIFICATIONS) + } + } + + // Initialize background server monitoring + if (appSettings.isBackgroundMonitoringEnabled) { + ServerMonitorWorker.createNotificationChannel(this) + ServerMonitorWorker.schedule(this) + } + + // Handle initial launch intent (from NFC or Widget) + handleIntent(intent) setContent { ExpAppTheme { @@ -30,10 +92,175 @@ class MainActivity : ComponentActivity() { ) { MainScreen( repository = repository, - triggerClient = triggerClient + triggerClient = triggerClient, + appSettings = appSettings, + historyRepository = historyRepository, + requestBiometricAuth = { title, subtitle, onResult -> + BiometricHelper.authenticate(this, title, subtitle) { success, _ -> + onResult(success) + } + }, + nfcWriteResult = nfcWriteResult, + onStartNfcWriting = { payload -> + nfcWriteResult = null + activeNfcWritePayload = payload + }, + onStopNfcWriting = { + activeNfcWritePayload = null + nfcWriteResult = null + } ) } } } } + + override fun onResume() { + super.onResume() + if (NfcHelper.isNfcSupported(this)) { + NfcHelper.enableForegroundDispatch(this) + } + } + + override fun onPause() { + super.onPause() + if (NfcHelper.isNfcSupported(this)) { + NfcHelper.disableForegroundDispatch(this) + } + } + + override fun onNewIntent(intent: Intent) { + super.onNewIntent(intent) + setIntent(intent) + handleIntent(intent) + } + + private fun handleIntent(intent: Intent?) { + if (intent == null) return + + // 1. NFC Tag write handling + val writePayload = activeNfcWritePayload + if (writePayload != null) { + @Suppress("DEPRECATION") + val tag = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) { + intent.getParcelableExtra(NfcAdapter.EXTRA_TAG, Tag::class.java) + } else { + intent.getParcelableExtra(NfcAdapter.EXTRA_TAG) + } + if (tag != null) { + val message = NfcHelper.createNdefMessage(writePayload.nodeOrDeviceId, writePayload.action) + val result = NfcHelper.writeTag(tag, message) + nfcWriteResult = result + vibrateFeedback(result.isSuccess) + return + } + } + + // 2. NFC Tag trigger execution + val nfcPayload = NfcHelper.parseTriggerPayload(intent) + if (nfcPayload != null) { + val devices = repository.getDevices() + val device = devices.find { it.node.equals(nfcPayload.nodeOrDeviceId, ignoreCase = true) || it.id == nfcPayload.nodeOrDeviceId } + if (device != null) { + executeExternalTrigger(device, nfcPayload.action, "NFC") + } else { + Toast.makeText(this, "NFC Tag: Unknown server (${nfcPayload.nodeOrDeviceId})", Toast.LENGTH_LONG).show() + } + return + } + + // 3. Widget biometric trigger launch + if (intent.action == ServerWidgetProvider.ACTION_TRIGGER) { + val deviceId = intent.getStringExtra(ServerWidgetProvider.EXTRA_DEVICE_ID) + val actionName = intent.getStringExtra(ServerWidgetProvider.EXTRA_ACTION) + if (deviceId != null && actionName != null) { + val action = try { TriggerAction.valueOf(actionName) } catch (e: Exception) { null } + val device = repository.getDevices().find { it.id == deviceId } + if (device != null && action != null) { + executeExternalTrigger(device, action, "Widget") + } + } + } + } + + private fun executeExternalTrigger(device: DeviceConfig, action: TriggerAction, source: String) { + val actionName = when (action) { + TriggerAction.POWER_ON -> "Power On" + TriggerAction.REBOOT -> "Reboot" + TriggerAction.POWER_OFF -> "Shutdown" + } + + val onAuthorized = { + vibrateFeedback(true) + Toast.makeText(this, "Sending $actionName signal to ${device.name}...", Toast.LENGTH_SHORT).show() + triggerClient.sendTrigger(device, action) { response -> + val msg = if (response.isSuccess) { + "$actionName signal sent successfully" + } else { + "Failed: ${response.message.take(50)}" + } + Toast.makeText(this, msg, Toast.LENGTH_SHORT).show() + historyRepository.addLog( + TriggerLog( + deviceId = device.id, + deviceName = device.name, + node = device.node, + action = action, + isSuccess = response.isSuccess, + statusCode = response.statusCode, + message = response.message, + source = source + ) + ) + ServerWidgetProvider.updateAllWidgets(this) + } + } + + if (appSettings.isBiometricEnabled && BiometricHelper.isBiometricAvailable(this)) { + BiometricHelper.authenticate( + this, + title = "Confirm $actionName", + subtitle = "Authenticate with fingerprint to trigger ${device.name}" + ) { success, errorMsg -> + if (success) { + onAuthorized() + } else if (errorMsg != null) { + Toast.makeText(this, "Authentication cancelled", Toast.LENGTH_SHORT).show() + } + } + } else { + onAuthorized() + } + } + + private fun vibrateFeedback(success: Boolean) { + try { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) { + val vibratorManager = getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as? VibratorManager + val vibrator = vibratorManager?.defaultVibrator + vibrator?.vibrate( + VibrationEffect.createOneShot( + if (success) 80 else 200, + VibrationEffect.DEFAULT_AMPLITUDE + ) + ) + } else { + @Suppress("DEPRECATION") + val vibrator = getSystemService(Context.VIBRATOR_SERVICE) as? Vibrator + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { + vibrator?.vibrate( + VibrationEffect.createOneShot( + if (success) 80 else 200, + VibrationEffect.DEFAULT_AMPLITUDE + ) + ) + } else { + @Suppress("DEPRECATION") + vibrator?.vibrate(if (success) 80 else 200) + } + } + } catch (e: Exception) { + // Ignore if vibration is not supported + } + } } diff --git a/app/src/main/java/com/expapp/trigger/data/model/TriggerLog.kt b/app/src/main/java/com/expapp/trigger/data/model/TriggerLog.kt new file mode 100644 index 0000000..756a380 --- /dev/null +++ b/app/src/main/java/com/expapp/trigger/data/model/TriggerLog.kt @@ -0,0 +1,17 @@ +package com.expapp.trigger.data.model + +import com.expapp.trigger.network.TriggerAction +import java.util.UUID + +data class TriggerLog( + val id: String = UUID.randomUUID().toString(), + val timestamp: Long = System.currentTimeMillis(), + val deviceId: String, + val deviceName: String, + val node: String, + val action: TriggerAction, + val isSuccess: Boolean, + val statusCode: Int, + val message: String, + val source: String = "App" // "App", "Widget", "NFC" +) diff --git a/app/src/main/java/com/expapp/trigger/data/repository/AppSettings.kt b/app/src/main/java/com/expapp/trigger/data/repository/AppSettings.kt new file mode 100644 index 0000000..b57716d --- /dev/null +++ b/app/src/main/java/com/expapp/trigger/data/repository/AppSettings.kt @@ -0,0 +1,32 @@ +package com.expapp.trigger.data.repository + +import android.content.Context + +class AppSettings(private val storage: KeyValueStorage) { + + constructor(context: Context) : this(SharedPrefsStorage(context, "app_settings_prefs")) + + companion object { + private const val KEY_BIOMETRIC_ENABLED = "key_biometric_enabled" + private const val KEY_BG_MONITOR_ENABLED = "key_bg_monitor_enabled" + private const val KEY_LAST_STATUS_PREFIX = "last_status_" + } + + var isBiometricEnabled: Boolean + get() = storage.getBoolean(KEY_BIOMETRIC_ENABLED, true) + set(value) = storage.putBoolean(KEY_BIOMETRIC_ENABLED, value) + + var isBackgroundMonitoringEnabled: Boolean + get() = storage.getBoolean(KEY_BG_MONITOR_ENABLED, true) + set(value) = storage.putBoolean(KEY_BG_MONITOR_ENABLED, value) + + fun getLastStatus(deviceId: String): Boolean? { + val key = "$KEY_LAST_STATUS_PREFIX$deviceId" + return if (storage.contains(key)) storage.getBoolean(key, false) else null + } + + fun setLastStatus(deviceId: String, isOnline: Boolean) { + val key = "$KEY_LAST_STATUS_PREFIX$deviceId" + storage.putBoolean(key, isOnline) + } +} diff --git a/app/src/main/java/com/expapp/trigger/data/repository/DeviceRepository.kt b/app/src/main/java/com/expapp/trigger/data/repository/DeviceRepository.kt index c774dab..8b401b3 100644 --- a/app/src/main/java/com/expapp/trigger/data/repository/DeviceRepository.kt +++ b/app/src/main/java/com/expapp/trigger/data/repository/DeviceRepository.kt @@ -9,11 +9,18 @@ import com.google.gson.reflect.TypeToken interface KeyValueStorage { fun getString(key: String, defaultValue: String?): String? fun putString(key: String, value: String?) + fun getBoolean(key: String, defaultValue: Boolean): Boolean = defaultValue + fun putBoolean(key: String, value: Boolean) {} + fun contains(key: String): Boolean = false + fun remove(key: String) {} } -class SharedPrefsStorage(context: Context) : KeyValueStorage { +class SharedPrefsStorage( + context: Context, + prefsName: String = "device_trigger_prefs" +) : KeyValueStorage { private val prefs: SharedPreferences = - context.getSharedPreferences("device_trigger_prefs", Context.MODE_PRIVATE) + context.getSharedPreferences(prefsName, Context.MODE_PRIVATE) override fun getString(key: String, defaultValue: String?): String? = prefs.getString(key, defaultValue) @@ -21,6 +28,20 @@ class SharedPrefsStorage(context: Context) : KeyValueStorage { override fun putString(key: String, value: String?) { prefs.edit().putString(key, value).apply() } + + override fun getBoolean(key: String, defaultValue: Boolean): Boolean = + prefs.getBoolean(key, defaultValue) + + override fun putBoolean(key: String, value: Boolean) { + prefs.edit().putBoolean(key, value).apply() + } + + override fun contains(key: String): Boolean = + prefs.contains(key) + + override fun remove(key: String) { + prefs.edit().remove(key).apply() + } } class DeviceRepository(private val storage: KeyValueStorage) { diff --git a/app/src/main/java/com/expapp/trigger/data/repository/TriggerHistoryRepository.kt b/app/src/main/java/com/expapp/trigger/data/repository/TriggerHistoryRepository.kt new file mode 100644 index 0000000..0e50e2b --- /dev/null +++ b/app/src/main/java/com/expapp/trigger/data/repository/TriggerHistoryRepository.kt @@ -0,0 +1,54 @@ +package com.expapp.trigger.data.repository + +import android.content.Context +import com.expapp.trigger.data.model.TriggerLog +import com.google.gson.Gson +import com.google.gson.reflect.TypeToken + +class TriggerHistoryRepository(private val storage: KeyValueStorage) { + + constructor(context: Context) : this(SharedPrefsStorage(context, "trigger_history_prefs")) + + private val gson = Gson() + private val storageKey = "history_logs_json" + private val maxLogs = 500 + + @Synchronized + fun getLogs(): List { + val json = storage.getString(storageKey, null) ?: return emptyList() + val type = object : TypeToken>() {}.type + return try { + val list = gson.fromJson>(json, type) ?: emptyList() + list.sortedByDescending { it.timestamp } + } catch (e: Exception) { + emptyList() + } + } + + @Synchronized + fun addLog(log: TriggerLog) { + val current = getLogs().toMutableList() + current.add(0, log) + if (current.size > maxLogs) { + current.subList(maxLogs, current.size).clear() + } + saveLogs(current) + } + + @Synchronized + fun clearOlderThan(durationMillis: Long) { + val cutoff = System.currentTimeMillis() - durationMillis + val filtered = getLogs().filter { it.timestamp >= cutoff } + saveLogs(filtered) + } + + @Synchronized + fun clearAll() { + storage.remove(storageKey) + } + + private fun saveLogs(logs: List) { + val json = gson.toJson(logs) + storage.putString(storageKey, json) + } +} diff --git a/app/src/main/java/com/expapp/trigger/network/TriggerClient.kt b/app/src/main/java/com/expapp/trigger/network/TriggerClient.kt index 297fb39..d77f5e9 100644 --- a/app/src/main/java/com/expapp/trigger/network/TriggerClient.kt +++ b/app/src/main/java/com/expapp/trigger/network/TriggerClient.kt @@ -120,6 +120,28 @@ class TriggerClient( }) } + fun sendTriggerSync(device: DeviceConfig, action: TriggerAction): TriggerResponse { + return try { + val request = buildRequest(device, action) + val response = client.newCall(request).execute() + response.use { + val code = it.code + val bodyText = it.body?.string().orEmpty() + TriggerResponse( + isSuccess = it.isSuccessful, + statusCode = code, + message = if (bodyText.isNotEmpty()) bodyText else "HTTP $code" + ) + } + } catch (e: Exception) { + TriggerResponse( + isSuccess = false, + statusCode = -1, + message = e.localizedMessage ?: "Request failed" + ) + } + } + fun fetchR2Config( url: String, callback: (Result) -> Unit @@ -156,9 +178,7 @@ class TriggerClient( device: DeviceConfig, callback: (NodeStatus) -> Unit ) { - // Only use statusUrl from JSON config — no hardcoded fallback val baseStatusUrl = device.statusUrl.trim() - if (baseStatusUrl.isBlank()) { runOnMain { callback(NodeStatus(isOnline = false, statusText = "NO STATUS URL")) @@ -183,64 +203,77 @@ class TriggerClient( } override fun onResponse(call: Call, response: Response) { - response.use { + val nodeStatus = response.use { val body = it.body?.string().orEmpty().trim() - if (body.startsWith("{")) { - try { - val json = com.google.gson.JsonParser.parseString(body).asJsonObject - val online = when { - json.has("online") && json.get("online").isJsonPrimitive && json.get("online").asJsonPrimitive.isBoolean -> - json.get("online").asBoolean - json.has("status") && json.get("status").isJsonPrimitive -> - json.get("status").asString.equals("online", ignoreCase = true) - else -> false - } - val ip = if (json.has("ip") && !json.get("ip").isJsonNull) json.get("ip").asString else null - val uptime = when { - json.has("uptime") && !json.get("uptime").isJsonNull -> json.get("uptime").asString - json.has("on_since_duration") && !json.get("on_since_duration").isJsonNull -> json.get("on_since_duration").asString - else -> null - } - val onSinceIst = if (json.has("on_since_ist") && !json.get("on_since_ist").isJsonNull) { - json.get("on_since_ist").asString - } else null - val lastActiveAgo = if (json.has("last_active_ago") && !json.get("last_active_ago").isJsonNull) { - json.get("last_active_ago").asString - } else null - val lastActiveIst = if (json.has("last_active_ist") && !json.get("last_active_ist").isJsonNull) { - json.get("last_active_ist").asString - } else null - - runOnMain { - callback( - NodeStatus( - isOnline = online, - statusText = if (online) "ONLINE" else "OFFLINE", - ip = ip, - uptime = uptime, - onSinceIst = onSinceIst, - lastActiveAgo = lastActiveAgo, - lastActiveIst = lastActiveIst - ) - ) - } - } catch (e: Exception) { - runOnMain { - callback(NodeStatus(isOnline = false, statusText = "ERROR")) - } - } - } else if (it.isSuccessful) { - val isOnline = body.equals("ONLINE", ignoreCase = true) - runOnMain { - callback(NodeStatus(isOnline = isOnline, statusText = if (isOnline) "ONLINE" else "OFFLINE")) - } - } else { - runOnMain { - callback(NodeStatus(isOnline = false, statusText = "OFFLINE")) - } - } + parseNodeStatus(body, it.isSuccessful) } + runOnMain { callback(nodeStatus) } } }) } + + fun checkStatusSync(device: DeviceConfig): NodeStatus { + val baseStatusUrl = device.statusUrl.trim() + if (baseStatusUrl.isBlank()) { + return NodeStatus(isOnline = false, statusText = "NO STATUS URL") + } + + return try { + val request = Request.Builder().url(baseStatusUrl).get().build() + val response = client.newCall(request).execute() + response.use { + val body = it.body?.string().orEmpty().trim() + parseNodeStatus(body, it.isSuccessful) + } + } catch (e: Exception) { + NodeStatus(isOnline = false, statusText = "OFFLINE") + } + } + + private fun parseNodeStatus(body: String, isHttpSuccess: Boolean): NodeStatus { + if (body.startsWith("{")) { + return try { + val json = com.google.gson.JsonParser.parseString(body).asJsonObject + val online = when { + json.has("online") && json.get("online").isJsonPrimitive && json.get("online").asJsonPrimitive.isBoolean -> + json.get("online").asBoolean + json.has("status") && json.get("status").isJsonPrimitive -> + json.get("status").asString.equals("online", ignoreCase = true) + else -> false + } + val ip = if (json.has("ip") && !json.get("ip").isJsonNull) json.get("ip").asString else null + val uptime = when { + json.has("uptime") && !json.get("uptime").isJsonNull -> json.get("uptime").asString + json.has("on_since_duration") && !json.get("on_since_duration").isJsonNull -> json.get("on_since_duration").asString + else -> null + } + val onSinceIst = if (json.has("on_since_ist") && !json.get("on_since_ist").isJsonNull) { + json.get("on_since_ist").asString + } else null + val lastActiveAgo = if (json.has("last_active_ago") && !json.get("last_active_ago").isJsonNull) { + json.get("last_active_ago").asString + } else null + val lastActiveIst = if (json.has("last_active_ist") && !json.get("last_active_ist").isJsonNull) { + json.get("last_active_ist").asString + } else null + + NodeStatus( + isOnline = online, + statusText = if (online) "ONLINE" else "OFFLINE", + ip = ip, + uptime = uptime, + onSinceIst = onSinceIst, + lastActiveAgo = lastActiveAgo, + lastActiveIst = lastActiveIst + ) + } catch (e: Exception) { + NodeStatus(isOnline = false, statusText = "ERROR") + } + } else if (isHttpSuccess) { + val isOnline = body.equals("ONLINE", ignoreCase = true) + return NodeStatus(isOnline = isOnline, statusText = if (isOnline) "ONLINE" else "OFFLINE") + } else { + return NodeStatus(isOnline = false, statusText = "OFFLINE") + } + } } diff --git a/app/src/main/java/com/expapp/trigger/nfc/NfcHelper.kt b/app/src/main/java/com/expapp/trigger/nfc/NfcHelper.kt new file mode 100644 index 0000000..794028c --- /dev/null +++ b/app/src/main/java/com/expapp/trigger/nfc/NfcHelper.kt @@ -0,0 +1,121 @@ +package com.expapp.trigger.nfc + +import android.app.Activity +import android.app.PendingIntent +import android.content.Context +import android.content.Intent +import android.content.IntentFilter +import android.net.Uri +import android.nfc.NdefMessage +import android.nfc.NdefRecord +import android.nfc.NfcAdapter +import android.nfc.Tag +import android.nfc.tech.Ndef +import android.nfc.tech.NdefFormatable +import android.os.Build +import com.expapp.trigger.network.TriggerAction + +data class NfcTriggerPayload( + val nodeOrDeviceId: String, + val action: TriggerAction +) + +object NfcHelper { + + fun isNfcSupported(context: Context): Boolean { + val adapter = NfcAdapter.getDefaultAdapter(context) + return adapter != null + } + + fun isNfcEnabled(context: Context): Boolean { + val adapter = NfcAdapter.getDefaultAdapter(context) + return adapter != null && adapter.isEnabled + } + + fun enableForegroundDispatch(activity: Activity) { + val adapter = NfcAdapter.getDefaultAdapter(activity) ?: return + val intent = Intent(activity, activity.javaClass).addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP) + val pendingIntent = PendingIntent.getActivity( + activity, + 0, + intent, + PendingIntent.FLAG_UPDATE_CURRENT or (if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) PendingIntent.FLAG_MUTABLE else 0) + ) + + val ndefFilter = IntentFilter(NfcAdapter.ACTION_NDEF_DISCOVERED).apply { + addDataScheme("expapp") + } + val tagFilter = IntentFilter(NfcAdapter.ACTION_TAG_DISCOVERED) + + adapter.enableForegroundDispatch(activity, pendingIntent, arrayOf(ndefFilter, tagFilter), null) + } + + fun disableForegroundDispatch(activity: Activity) { + val adapter = NfcAdapter.getDefaultAdapter(activity) ?: return + adapter.disableForegroundDispatch(activity) + } + + fun createNdefMessage(nodeOrDeviceId: String, action: TriggerAction): NdefMessage { + val uriString = "expapp://trigger?device=$nodeOrDeviceId&action=${action.name.lowercase()}" + val uriRecord = NdefRecord.createUri(Uri.parse(uriString)) + val aarRecord = NdefRecord.createApplicationRecord("com.expapp.trigger") + return NdefMessage(arrayOf(uriRecord, aarRecord)) + } + + fun writeTag(tag: Tag, message: NdefMessage): Result { + return try { + val ndef = Ndef.get(tag) + if (ndef != null) { + ndef.connect() + if (!ndef.isWritable) { + ndef.close() + return Result.failure(Exception("NFC Tag is read-only")) + } + if (ndef.maxSize < message.byteArrayLength) { + ndef.close() + return Result.failure(Exception("Tag capacity too small (${ndef.maxSize} bytes < ${message.byteArrayLength} bytes)")) + } + ndef.writeNdefMessage(message) + ndef.close() + Result.success(Unit) + } else { + val formatable = NdefFormatable.get(tag) + if (formatable != null) { + formatable.connect() + formatable.format(message) + formatable.close() + Result.success(Unit) + } else { + Result.failure(Exception("Tag does not support NDEF format")) + } + } + } catch (e: Exception) { + Result.failure(e) + } + } + + fun parseTriggerPayload(intent: Intent): NfcTriggerPayload? { + val uri: Uri? = intent.data ?: run { + // Check NdefMessage extra + val rawMessages = intent.getParcelableArrayExtra(NfcAdapter.EXTRA_NDEF_MESSAGES) + if (rawMessages != null && rawMessages.isNotEmpty()) { + val ndefMessage = rawMessages[0] as? NdefMessage + val record = ndefMessage?.records?.firstOrNull() + record?.toUri() + } else null + } + + if (uri != null && uri.scheme == "expapp" && uri.host == "trigger") { + val device = uri.getQueryParameter("device") ?: return null + val actionStr = uri.getQueryParameter("action") ?: return null + val action = when (actionStr.lowercase()) { + "power_on", "on", "poweron" -> TriggerAction.POWER_ON + "power_off", "off", "poweroff", "shutdown" -> TriggerAction.POWER_OFF + "reboot", "restart" -> TriggerAction.REBOOT + else -> null + } ?: return null + return NfcTriggerPayload(device, action) + } + return null + } +} diff --git a/app/src/main/java/com/expapp/trigger/security/BiometricHelper.kt b/app/src/main/java/com/expapp/trigger/security/BiometricHelper.kt new file mode 100644 index 0000000..e1f46f8 --- /dev/null +++ b/app/src/main/java/com/expapp/trigger/security/BiometricHelper.kt @@ -0,0 +1,60 @@ +package com.expapp.trigger.security + +import android.content.Context +import androidx.biometric.BiometricManager +import androidx.biometric.BiometricPrompt +import androidx.core.content.ContextCompat +import androidx.fragment.app.FragmentActivity + +object BiometricHelper { + + fun isBiometricAvailable(context: Context): Boolean { + val biometricManager = BiometricManager.from(context) + val authenticators = BiometricManager.Authenticators.BIOMETRIC_STRONG or + BiometricManager.Authenticators.BIOMETRIC_WEAK or + BiometricManager.Authenticators.DEVICE_CREDENTIAL + return biometricManager.canAuthenticate(authenticators) == BiometricManager.BIOMETRIC_SUCCESS + } + + fun authenticate( + activity: FragmentActivity, + title: String, + subtitle: String = "Verify your identity to proceed", + onResult: (success: Boolean, errorMessage: String?) -> Unit + ) { + val executor = ContextCompat.getMainExecutor(activity) + + val prompt = BiometricPrompt( + activity, + executor, + object : BiometricPrompt.AuthenticationCallback() { + override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) { + super.onAuthenticationSucceeded(result) + onResult(true, null) + } + + override fun onAuthenticationError(errorCode: Int, errString: CharSequence) { + super.onAuthenticationError(errorCode, errString) + // If user clicked cancel or back, return false with message + onResult(false, errString.toString()) + } + + override fun onAuthenticationFailed() { + super.onAuthenticationFailed() + // Intermediate failure (e.g. unrecognised finger), BiometricPrompt handles retry UI + } + } + ) + + val promptInfo = BiometricPrompt.PromptInfo.Builder() + .setTitle(title) + .setSubtitle(subtitle) + .setAllowedAuthenticators( + BiometricManager.Authenticators.BIOMETRIC_STRONG or + BiometricManager.Authenticators.DEVICE_CREDENTIAL + ) + .build() + + prompt.authenticate(promptInfo) + } +} diff --git a/app/src/main/java/com/expapp/trigger/ui/components/HistoryDialog.kt b/app/src/main/java/com/expapp/trigger/ui/components/HistoryDialog.kt new file mode 100644 index 0000000..140a56a --- /dev/null +++ b/app/src/main/java/com/expapp/trigger/ui/components/HistoryDialog.kt @@ -0,0 +1,510 @@ +package com.expapp.trigger.ui.components + +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxHeight +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.LazyRow +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.CheckCircle +import androidx.compose.material.icons.filled.Close +import androidx.compose.material.icons.filled.DeleteSweep +import androidx.compose.material.icons.filled.Error +import androidx.compose.material.icons.filled.History +import androidx.compose.material3.AlertDialog +import androidx.compose.material3.Button +import androidx.compose.material3.ButtonDefaults +import androidx.compose.material3.DropdownMenu +import androidx.compose.material3.DropdownMenuItem +import androidx.compose.material3.FilterChip +import androidx.compose.material3.FilterChipDefaults +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButton +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.compose.ui.window.Dialog +import androidx.compose.ui.window.DialogProperties +import com.expapp.trigger.data.model.TriggerLog +import com.expapp.trigger.network.TriggerAction +import com.expapp.trigger.ui.theme.AmberVibrant +import com.expapp.trigger.ui.theme.BgCard +import com.expapp.trigger.ui.theme.BgElevated +import com.expapp.trigger.ui.theme.BgSurface +import com.expapp.trigger.ui.theme.BorderDefault +import com.expapp.trigger.ui.theme.BorderSubtle +import com.expapp.trigger.ui.theme.GreenVibrant +import com.expapp.trigger.ui.theme.RedVibrant +import com.expapp.trigger.ui.theme.TextMuted +import com.expapp.trigger.ui.theme.TextPrimary +import com.expapp.trigger.ui.theme.TextSecondary +import java.text.SimpleDateFormat +import java.util.Date +import java.util.Locale +import java.util.concurrent.TimeUnit + +@Composable +fun HistoryDialog( + logs: List, + onClearOlderThan: (durationMillis: Long) -> Unit, + onClearAll: () -> Unit, + onDismiss: () -> Unit +) { + var filterAction by remember { mutableStateOf(null) } + var filterSuccessOnly by remember { mutableStateOf(null) } + var showClearMenu by remember { mutableStateOf(false) } + + val filteredLogs = logs.filter { log -> + val actionMatches = filterAction == null || log.action == filterAction + val successMatches = filterSuccessOnly == null || log.isSuccess == filterSuccessOnly + actionMatches && successMatches + } + + Dialog( + onDismissRequest = onDismiss, + properties = DialogProperties(usePlatformDefaultWidth = false) + ) { + Surface( + modifier = Modifier + .fillMaxWidth(0.95f) + .fillMaxHeight(0.85f), + shape = RoundedCornerShape(24.dp), + color = BgSurface, + tonalElevation = 6.dp + ) { + Column( + modifier = Modifier + .padding(20.dp) + ) { + // Header Row + Row( + modifier = Modifier.fillMaxWidth(), + verticalAlignment = Alignment.CenterVertically + ) { + Icon( + Icons.Default.History, + contentDescription = null, + tint = GreenVibrant, + modifier = Modifier.size(24.dp) + ) + Spacer(modifier = Modifier.width(10.dp)) + Text( + text = "TRIGGER HISTORY", + fontSize = 15.sp, + fontWeight = FontWeight.Bold, + letterSpacing = 1.2.sp, + color = TextPrimary, + fontFamily = FontFamily.Monospace, + modifier = Modifier.weight(1f) + ) + + // Clear options menu button + Box { + IconButton( + onClick = { showClearMenu = true }, + modifier = Modifier.size(36.dp) + ) { + Icon( + Icons.Default.DeleteSweep, + contentDescription = "Clear History", + tint = TextSecondary + ) + } + + DropdownMenu( + expanded = showClearMenu, + onDismissRequest = { showClearMenu = false }, + modifier = Modifier.background(BgElevated) + ) { + DropdownMenuItem( + text = { Text("Clear older than 24 hours", color = TextPrimary, fontSize = 13.sp) }, + onClick = { + showClearMenu = false + onClearOlderThan(TimeUnit.HOURS.toMillis(24)) + } + ) + DropdownMenuItem( + text = { Text("Clear older than 7 days", color = TextPrimary, fontSize = 13.sp) }, + onClick = { + showClearMenu = false + onClearOlderThan(TimeUnit.DAYS.toMillis(7)) + } + ) + DropdownMenuItem( + text = { Text("Clear older than 30 days", color = TextPrimary, fontSize = 13.sp) }, + onClick = { + showClearMenu = false + onClearOlderThan(TimeUnit.DAYS.toMillis(30)) + } + ) + DropdownMenuItem( + text = { Text("Clear all history", color = RedVibrant, fontWeight = FontWeight.Bold, fontSize = 13.sp) }, + onClick = { + showClearMenu = false + onClearAll() + } + ) + } + } + + IconButton( + onClick = onDismiss, + modifier = Modifier.size(36.dp) + ) { + Icon( + Icons.Default.Close, + contentDescription = "Close", + tint = TextMuted + ) + } + } + + Spacer(modifier = Modifier.height(12.dp)) + + // Filter chips row + LazyRow( + horizontalArrangement = Arrangement.spacedBy(8.dp), + modifier = Modifier.fillMaxWidth() + ) { + item { + FilterChip( + selected = filterAction == null && filterSuccessOnly == null, + onClick = { + filterAction = null + filterSuccessOnly = null + }, + label = { Text("All (${logs.size})", fontSize = 11.sp) }, + colors = FilterChipDefaults.filterChipColors( + selectedContainerColor = GreenVibrant.copy(alpha = 0.2f), + selectedLabelColor = GreenVibrant, + containerColor = BgElevated, + labelColor = TextSecondary + ), + border = FilterChipDefaults.filterChipBorder( + enabled = true, + selected = filterAction == null && filterSuccessOnly == null, + borderColor = BorderSubtle, + selectedBorderColor = GreenVibrant.copy(alpha = 0.4f) + ) + ) + } + item { + FilterChip( + selected = filterAction == TriggerAction.POWER_ON, + onClick = { + filterAction = if (filterAction == TriggerAction.POWER_ON) null else TriggerAction.POWER_ON + }, + label = { Text("Power On", fontSize = 11.sp) }, + colors = FilterChipDefaults.filterChipColors( + selectedContainerColor = GreenVibrant.copy(alpha = 0.2f), + selectedLabelColor = GreenVibrant, + containerColor = BgElevated, + labelColor = TextSecondary + ), + border = FilterChipDefaults.filterChipBorder( + enabled = true, + selected = filterAction == TriggerAction.POWER_ON, + borderColor = BorderSubtle, + selectedBorderColor = GreenVibrant.copy(alpha = 0.4f) + ) + ) + } + item { + FilterChip( + selected = filterAction == TriggerAction.REBOOT, + onClick = { + filterAction = if (filterAction == TriggerAction.REBOOT) null else TriggerAction.REBOOT + }, + label = { Text("Reboot", fontSize = 11.sp) }, + colors = FilterChipDefaults.filterChipColors( + selectedContainerColor = AmberVibrant.copy(alpha = 0.2f), + selectedLabelColor = AmberVibrant, + containerColor = BgElevated, + labelColor = TextSecondary + ), + border = FilterChipDefaults.filterChipBorder( + enabled = true, + selected = filterAction == TriggerAction.REBOOT, + borderColor = BorderSubtle, + selectedBorderColor = AmberVibrant.copy(alpha = 0.4f) + ) + ) + } + item { + FilterChip( + selected = filterAction == TriggerAction.POWER_OFF, + onClick = { + filterAction = if (filterAction == TriggerAction.POWER_OFF) null else TriggerAction.POWER_OFF + }, + label = { Text("Shutdown", fontSize = 11.sp) }, + colors = FilterChipDefaults.filterChipColors( + selectedContainerColor = RedVibrant.copy(alpha = 0.2f), + selectedLabelColor = RedVibrant, + containerColor = BgElevated, + labelColor = TextSecondary + ), + border = FilterChipDefaults.filterChipBorder( + enabled = true, + selected = filterAction == TriggerAction.POWER_OFF, + borderColor = BorderSubtle, + selectedBorderColor = RedVibrant.copy(alpha = 0.4f) + ) + ) + } + item { + FilterChip( + selected = filterSuccessOnly == false, + onClick = { + filterSuccessOnly = if (filterSuccessOnly == false) null else false + }, + label = { Text("Failed Only", fontSize = 11.sp) }, + colors = FilterChipDefaults.filterChipColors( + selectedContainerColor = RedVibrant.copy(alpha = 0.2f), + selectedLabelColor = RedVibrant, + containerColor = BgElevated, + labelColor = TextSecondary + ), + border = FilterChipDefaults.filterChipBorder( + enabled = true, + selected = filterSuccessOnly == false, + borderColor = BorderSubtle, + selectedBorderColor = RedVibrant.copy(alpha = 0.4f) + ) + ) + } + } + + Spacer(modifier = Modifier.height(14.dp)) + + // Logs list or empty state + if (filteredLogs.isEmpty()) { + Box( + modifier = Modifier + .fillMaxWidth() + .weight(1f), + contentAlignment = Alignment.Center + ) { + Column(horizontalAlignment = Alignment.CenterHorizontally) { + Icon( + Icons.Default.History, + contentDescription = null, + tint = TextMuted.copy(alpha = 0.4f), + modifier = Modifier.size(48.dp) + ) + Spacer(modifier = Modifier.height(10.dp)) + Text( + "No trigger events recorded", + color = TextMuted, + fontSize = 13.sp + ) + if (filterAction != null || filterSuccessOnly != null) { + TextButton( + onClick = { + filterAction = null + filterSuccessOnly = null + } + ) { + Text("Reset Filters", color = GreenVibrant, fontSize = 12.sp) + } + } + } + } + } else { + LazyColumn( + modifier = Modifier + .fillMaxWidth() + .weight(1f), + verticalArrangement = Arrangement.spacedBy(8.dp) + ) { + items(filteredLogs, key = { it.id }) { log -> + HistoryItemCard(log) + } + } + } + } + } + } +} + +@Composable +fun HistoryItemCard(log: TriggerLog) { + val actionColor = when (log.action) { + TriggerAction.POWER_ON -> GreenVibrant + TriggerAction.REBOOT -> AmberVibrant + TriggerAction.POWER_OFF -> RedVibrant + } + + val actionName = when (log.action) { + TriggerAction.POWER_ON -> "POWER ON" + TriggerAction.REBOOT -> "REBOOT" + TriggerAction.POWER_OFF -> "SHUTDOWN" + } + + val formattedTime = remember(log.timestamp) { + val sdf = SimpleDateFormat("MMM dd, HH:mm:ss", Locale.getDefault()) + sdf.format(Date(log.timestamp)) + } + + val relativeTime = remember(log.timestamp) { + val diff = System.currentTimeMillis() - log.timestamp + when { + diff < 60_000L -> "Just now" + diff < 3600_000L -> "${diff / 60_000L}m ago" + diff < 86400_000L -> "${diff / 3600_000L}h ago" + else -> "${diff / 86400_000L}d ago" + } + } + + Box( + modifier = Modifier + .fillMaxWidth() + .clip(RoundedCornerShape(14.dp)) + .background(BgCard) + .border(1.dp, BorderSubtle, RoundedCornerShape(14.dp)) + .padding(12.dp) + ) { + Column { + Row( + modifier = Modifier.fillMaxWidth(), + verticalAlignment = Alignment.CenterVertically + ) { + // Action Pill + Box( + modifier = Modifier + .clip(RoundedCornerShape(6.dp)) + .background(actionColor.copy(alpha = 0.15f)) + .padding(horizontal = 8.dp, vertical = 3.dp) + ) { + Text( + actionName, + color = actionColor, + fontSize = 11.sp, + fontWeight = FontWeight.Bold, + fontFamily = FontFamily.Monospace + ) + } + + Spacer(modifier = Modifier.width(8.dp)) + + // Source Pill (App / Widget / NFC) + Box( + modifier = Modifier + .clip(RoundedCornerShape(6.dp)) + .background(BgElevated) + .border(1.dp, BorderSubtle, RoundedCornerShape(6.dp)) + .padding(horizontal = 6.dp, vertical = 2.dp) + ) { + Text( + log.source, + color = TextMuted, + fontSize = 10.sp, + fontWeight = FontWeight.SemiBold + ) + } + + Spacer(modifier = Modifier.weight(1f)) + + // Success/Failure Icon + Status Code + if (log.isSuccess) { + Icon( + Icons.Default.CheckCircle, + contentDescription = "Success", + tint = GreenVibrant, + modifier = Modifier.size(15.dp) + ) + Spacer(modifier = Modifier.width(4.dp)) + Text( + "${log.statusCode}", + color = GreenVibrant, + fontSize = 11.sp, + fontFamily = FontFamily.Monospace, + fontWeight = FontWeight.Bold + ) + } else { + Icon( + Icons.Default.Error, + contentDescription = "Failed", + tint = RedVibrant, + modifier = Modifier.size(15.dp) + ) + Spacer(modifier = Modifier.width(4.dp)) + Text( + if (log.statusCode > 0) "${log.statusCode}" else "ERR", + color = RedVibrant, + fontSize = 11.sp, + fontFamily = FontFamily.Monospace, + fontWeight = FontWeight.Bold + ) + } + } + + Spacer(modifier = Modifier.height(6.dp)) + + // Device Name + Node + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically + ) { + Text( + text = "${log.deviceName} (${log.node})", + color = TextPrimary, + fontSize = 13.sp, + fontWeight = FontWeight.Medium + ) + Text( + text = relativeTime, + color = TextMuted, + fontSize = 11.sp + ) + } + + // Message / Details + if (log.message.isNotBlank()) { + Spacer(modifier = Modifier.height(4.dp)) + Text( + text = log.message, + color = if (log.isSuccess) TextSecondary else RedVibrant.copy(alpha = 0.8f), + fontSize = 11.sp, + fontFamily = FontFamily.Monospace, + maxLines = 2 + ) + } + + // Exact timestamp + Spacer(modifier = Modifier.height(2.dp)) + Text( + text = formattedTime, + color = TextMuted.copy(alpha = 0.6f), + fontSize = 10.sp + ) + } + } +} diff --git a/app/src/main/java/com/expapp/trigger/ui/components/NfcWriteDialog.kt b/app/src/main/java/com/expapp/trigger/ui/components/NfcWriteDialog.kt new file mode 100644 index 0000000..d8a99bd --- /dev/null +++ b/app/src/main/java/com/expapp/trigger/ui/components/NfcWriteDialog.kt @@ -0,0 +1,312 @@ +package com.expapp.trigger.ui.components + +import androidx.compose.animation.core.FastOutSlowInEasing +import androidx.compose.animation.core.RepeatMode +import androidx.compose.animation.core.animateFloat +import androidx.compose.animation.core.infiniteRepeatable +import androidx.compose.animation.core.rememberInfiniteTransition +import androidx.compose.animation.core.tween +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.CheckCircle +import androidx.compose.material.icons.filled.Close +import androidx.compose.material.icons.filled.Error +import androidx.compose.material.icons.filled.Nfc +import androidx.compose.material3.Button +import androidx.compose.material3.ButtonDefaults +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButton +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.runtime.DisposableEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.draw.scale +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.compose.ui.window.Dialog +import com.expapp.trigger.data.model.DeviceConfig +import com.expapp.trigger.network.TriggerAction +import com.expapp.trigger.nfc.NfcTriggerPayload +import com.expapp.trigger.ui.theme.AmberVibrant +import com.expapp.trigger.ui.theme.BgElevated +import com.expapp.trigger.ui.theme.BgSurface +import com.expapp.trigger.ui.theme.BorderSubtle +import com.expapp.trigger.ui.theme.GreenVibrant +import com.expapp.trigger.ui.theme.RedVibrant +import com.expapp.trigger.ui.theme.TextMuted +import com.expapp.trigger.ui.theme.TextPrimary +import com.expapp.trigger.ui.theme.TextSecondary + +@Composable +fun NfcWriteDialog( + devices: List, + writeResult: Result?, + onStartWriting: (NfcTriggerPayload) -> Unit, + onStopWriting: () -> Unit, + onDismiss: () -> Unit +) { + var selectedDevice by remember { mutableStateOf(devices.firstOrNull()) } + var selectedAction by remember { mutableStateOf(TriggerAction.POWER_ON) } + var isWaitingForTag by remember { mutableStateOf(false) } + + DisposableEffect(Unit) { + onDispose { + onStopWriting() + } + } + + val infiniteTransition = rememberInfiniteTransition(label = "nfc_pulse") + val pulseScale by infiniteTransition.animateFloat( + initialValue = 1.0f, + targetValue = 1.25f, + animationSpec = infiniteRepeatable( + animation = tween(1000, easing = FastOutSlowInEasing), + repeatMode = RepeatMode.Reverse + ), + label = "nfc_pulse_scale" + ) + + Dialog(onDismissRequest = { + onStopWriting() + onDismiss() + }) { + Surface( + modifier = Modifier.fillMaxWidth(0.95f), + shape = RoundedCornerShape(24.dp), + color = BgSurface, + tonalElevation = 6.dp + ) { + Column( + modifier = Modifier.padding(22.dp), + horizontalAlignment = Alignment.CenterHorizontally + ) { + // Header + Row( + modifier = Modifier.fillMaxWidth(), + verticalAlignment = Alignment.CenterVertically + ) { + Icon( + Icons.Default.Nfc, + contentDescription = null, + tint = GreenVibrant, + modifier = Modifier.size(24.dp) + ) + Spacer(modifier = Modifier.width(10.dp)) + Text( + text = "PROGRAM NFC TAG", + fontSize = 15.sp, + fontWeight = FontWeight.Bold, + letterSpacing = 1.2.sp, + color = TextPrimary, + fontFamily = FontFamily.Monospace, + modifier = Modifier.weight(1f) + ) + IconButton( + onClick = { + onStopWriting() + onDismiss() + }, + modifier = Modifier.size(36.dp) + ) { + Icon(Icons.Default.Close, contentDescription = "Close", tint = TextMuted) + } + } + + Spacer(modifier = Modifier.height(16.dp)) + + if (writeResult != null) { + // Result state + if (writeResult.isSuccess) { + Icon( + Icons.Default.CheckCircle, + contentDescription = "Success", + tint = GreenVibrant, + modifier = Modifier.size(54.dp) + ) + Spacer(modifier = Modifier.height(12.dp)) + Text( + "NFC Tag Programmed!", + color = TextPrimary, + fontWeight = FontWeight.Bold, + fontSize = 16.sp + ) + Spacer(modifier = Modifier.height(6.dp)) + Text( + "Tap this tag on your phone to trigger ${selectedAction.name} on ${selectedDevice?.name}.", + color = TextSecondary, + fontSize = 12.sp, + modifier = Modifier.padding(horizontal = 16.dp) + ) + } else { + Icon( + Icons.Default.Error, + contentDescription = "Failed", + tint = RedVibrant, + modifier = Modifier.size(54.dp) + ) + Spacer(modifier = Modifier.height(12.dp)) + Text( + "Write Failed", + color = RedVibrant, + fontWeight = FontWeight.Bold, + fontSize = 16.sp + ) + Spacer(modifier = Modifier.height(6.dp)) + Text( + writeResult.exceptionOrNull()?.message ?: "Could not write to NFC tag.", + color = TextSecondary, + fontSize = 12.sp + ) + } + Spacer(modifier = Modifier.height(20.dp)) + Button( + onClick = { + onStopWriting() + onDismiss() + }, + colors = ButtonDefaults.buttonColors(containerColor = GreenVibrant.copy(alpha = 0.2f)), + shape = RoundedCornerShape(12.dp) + ) { + Text("Done", color = GreenVibrant, fontWeight = FontWeight.Bold) + } + } else if (isWaitingForTag) { + // Waiting for tag scan animation + Box( + modifier = Modifier + .size(110.dp) + .scale(pulseScale) + .clip(CircleShape) + .background(GreenVibrant.copy(alpha = 0.12f)) + .border(2.dp, GreenVibrant.copy(alpha = 0.5f), CircleShape), + contentAlignment = Alignment.Center + ) { + Icon( + Icons.Default.Nfc, + contentDescription = null, + tint = GreenVibrant, + modifier = Modifier.size(50.dp) + ) + } + + Spacer(modifier = Modifier.height(18.dp)) + Text( + "Hold Tag Near Phone", + color = TextPrimary, + fontSize = 16.sp, + fontWeight = FontWeight.Bold + ) + Spacer(modifier = Modifier.height(6.dp)) + Text( + "Ready to write ${selectedAction.name} for ${selectedDevice?.name ?: ""}.\nHold an NFC tag against the back of your phone.", + color = TextMuted, + fontSize = 12.sp, + textAlign = androidx.compose.ui.text.style.TextAlign.Center + ) + + Spacer(modifier = Modifier.height(20.dp)) + TextButton( + onClick = { + isWaitingForTag = false + onStopWriting() + } + ) { + Text("Cancel", color = TextSecondary) + } + } else { + // Selection form + Text( + "Select Device & Action to program into an NFC tag:", + color = TextSecondary, + fontSize = 13.sp, + modifier = Modifier.fillMaxWidth() + ) + + Spacer(modifier = Modifier.height(14.dp)) + + // Action Selector (3 buttons) + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.spacedBy(8.dp) + ) { + TriggerAction.values().forEach { action -> + val isSelected = selectedAction == action + val color = when (action) { + TriggerAction.POWER_ON -> GreenVibrant + TriggerAction.REBOOT -> AmberVibrant + TriggerAction.POWER_OFF -> RedVibrant + } + val label = when (action) { + TriggerAction.POWER_ON -> "Power On" + TriggerAction.REBOOT -> "Reboot" + TriggerAction.POWER_OFF -> "Shutdown" + } + + Box( + modifier = Modifier + .weight(1f) + .clip(RoundedCornerShape(10.dp)) + .background(if (isSelected) color.copy(alpha = 0.2f) else BgElevated) + .border( + 1.dp, + if (isSelected) color else BorderSubtle, + RoundedCornerShape(10.dp) + ) + .clickable { selectedAction = action } + .padding(vertical = 10.dp), + contentAlignment = Alignment.Center + ) { + Text( + label, + color = if (isSelected) color else TextSecondary, + fontSize = 12.sp, + fontWeight = if (isSelected) FontWeight.Bold else FontWeight.Normal + ) + } + } + } + + Spacer(modifier = Modifier.height(20.dp)) + + Button( + onClick = { + val dev = selectedDevice + if (dev != null) { + isWaitingForTag = true + onStartWriting(NfcTriggerPayload(nodeOrDeviceId = dev.node, action = selectedAction)) + } + }, + modifier = Modifier.fillMaxWidth(), + colors = ButtonDefaults.buttonColors(containerColor = GreenVibrant.copy(alpha = 0.2f)), + shape = RoundedCornerShape(12.dp) + ) { + Text("Write to Tag", color = GreenVibrant, fontWeight = FontWeight.Bold, fontSize = 14.sp) + } + } + } + } + } +} diff --git a/app/src/main/java/com/expapp/trigger/ui/components/SettingsDialog.kt b/app/src/main/java/com/expapp/trigger/ui/components/SettingsDialog.kt new file mode 100644 index 0000000..ace68a6 --- /dev/null +++ b/app/src/main/java/com/expapp/trigger/ui/components/SettingsDialog.kt @@ -0,0 +1,261 @@ +package com.expapp.trigger.ui.components + +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Close +import androidx.compose.material.icons.filled.Fingerprint +import androidx.compose.material.icons.filled.Nfc +import androidx.compose.material.icons.filled.Notifications +import androidx.compose.material.icons.filled.Settings +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButton +import androidx.compose.material3.Surface +import androidx.compose.material3.Switch +import androidx.compose.material3.SwitchDefaults +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.compose.ui.window.Dialog +import com.expapp.trigger.BuildConfig +import com.expapp.trigger.ui.theme.BgCard +import com.expapp.trigger.ui.theme.BgElevated +import com.expapp.trigger.ui.theme.BgSurface +import com.expapp.trigger.ui.theme.BorderSubtle +import com.expapp.trigger.ui.theme.GreenVibrant +import com.expapp.trigger.ui.theme.TextMuted +import com.expapp.trigger.ui.theme.TextPrimary +import com.expapp.trigger.ui.theme.TextSecondary + +@Composable +fun SettingsDialog( + isBiometricEnabled: Boolean, + onBiometricToggled: (Boolean) -> Unit, + isBgMonitorEnabled: Boolean, + onBgMonitorToggled: (Boolean) -> Unit, + isBiometricAvailable: Boolean, + isNfcAvailable: Boolean, + onOpenNfcWriter: () -> Unit, + onDismiss: () -> Unit +) { + Dialog(onDismissRequest = onDismiss) { + Surface( + modifier = Modifier.fillMaxWidth(0.95f), + shape = RoundedCornerShape(24.dp), + color = BgSurface, + tonalElevation = 6.dp + ) { + Column( + modifier = Modifier.padding(22.dp) + ) { + // Header + Row( + modifier = Modifier.fillMaxWidth(), + verticalAlignment = Alignment.CenterVertically + ) { + Icon( + Icons.Default.Settings, + contentDescription = null, + tint = GreenVibrant, + modifier = Modifier.size(24.dp) + ) + Spacer(modifier = Modifier.width(10.dp)) + Text( + text = "SETTINGS", + fontSize = 15.sp, + fontWeight = FontWeight.Bold, + letterSpacing = 1.2.sp, + color = TextPrimary, + fontFamily = FontFamily.Monospace, + modifier = Modifier.weight(1f) + ) + IconButton( + onClick = onDismiss, + modifier = Modifier.size(36.dp) + ) { + Icon(Icons.Default.Close, contentDescription = "Close", tint = TextMuted) + } + } + + Spacer(modifier = Modifier.height(18.dp)) + + // Biometric Setting + Box( + modifier = Modifier + .fillMaxWidth() + .clip(RoundedCornerShape(14.dp)) + .background(BgCard) + .border(1.dp, BorderSubtle, RoundedCornerShape(14.dp)) + .padding(14.dp) + ) { + Row( + modifier = Modifier.fillMaxWidth(), + verticalAlignment = Alignment.CenterVertically + ) { + Icon( + Icons.Default.Fingerprint, + contentDescription = null, + tint = if (isBiometricEnabled) GreenVibrant else TextMuted, + modifier = Modifier.size(28.dp) + ) + Spacer(modifier = Modifier.width(12.dp)) + Column(modifier = Modifier.weight(1f)) { + Text( + "Biometric Security", + color = TextPrimary, + fontSize = 14.sp, + fontWeight = FontWeight.SemiBold + ) + Spacer(modifier = Modifier.height(2.dp)) + Text( + if (isBiometricAvailable) { + "Require fingerprint before any power action" + } else { + "Biometrics not supported or enrolled on this device" + }, + color = TextMuted, + fontSize = 11.sp + ) + } + Switch( + checked = isBiometricEnabled && isBiometricAvailable, + onCheckedChange = { onBiometricToggled(it) }, + enabled = isBiometricAvailable, + colors = SwitchDefaults.colors( + checkedThumbColor = GreenVibrant, + checkedTrackColor = GreenVibrant.copy(alpha = 0.3f), + uncheckedThumbColor = TextMuted, + uncheckedTrackColor = BgElevated + ) + ) + } + } + + Spacer(modifier = Modifier.height(12.dp)) + + // Background Monitor Setting + Box( + modifier = Modifier + .fillMaxWidth() + .clip(RoundedCornerShape(14.dp)) + .background(BgCard) + .border(1.dp, BorderSubtle, RoundedCornerShape(14.dp)) + .padding(14.dp) + ) { + Row( + modifier = Modifier.fillMaxWidth(), + verticalAlignment = Alignment.CenterVertically + ) { + Icon( + Icons.Default.Notifications, + contentDescription = null, + tint = if (isBgMonitorEnabled) GreenVibrant else TextMuted, + modifier = Modifier.size(28.dp) + ) + Spacer(modifier = Modifier.width(12.dp)) + Column(modifier = Modifier.weight(1f)) { + Text( + "Server Status Alerts", + color = TextPrimary, + fontSize = 14.sp, + fontWeight = FontWeight.SemiBold + ) + Spacer(modifier = Modifier.height(2.dp)) + Text( + "Notify outside app if servers go offline or online", + color = TextMuted, + fontSize = 11.sp + ) + } + Switch( + checked = isBgMonitorEnabled, + onCheckedChange = { onBgMonitorToggled(it) }, + colors = SwitchDefaults.colors( + checkedThumbColor = GreenVibrant, + checkedTrackColor = GreenVibrant.copy(alpha = 0.3f), + uncheckedThumbColor = TextMuted, + uncheckedTrackColor = BgElevated + ) + ) + } + } + + Spacer(modifier = Modifier.height(12.dp)) + + // NFC Programmer Option + Box( + modifier = Modifier + .fillMaxWidth() + .clip(RoundedCornerShape(14.dp)) + .background(BgCard) + .border(1.dp, BorderSubtle, RoundedCornerShape(14.dp)) + .clickable(enabled = isNfcAvailable) { + onDismiss() + onOpenNfcWriter() + } + .padding(14.dp) + ) { + Row( + modifier = Modifier.fillMaxWidth(), + verticalAlignment = Alignment.CenterVertically + ) { + Icon( + Icons.Default.Nfc, + contentDescription = null, + tint = if (isNfcAvailable) GreenVibrant else TextMuted, + modifier = Modifier.size(28.dp) + ) + Spacer(modifier = Modifier.width(12.dp)) + Column(modifier = Modifier.weight(1f)) { + Text( + "Program NFC Tag", + color = if (isNfcAvailable) TextPrimary else TextMuted, + fontSize = 14.sp, + fontWeight = FontWeight.SemiBold + ) + Spacer(modifier = Modifier.height(2.dp)) + Text( + if (isNfcAvailable) { + "Tap an NFC sticker to send power signals" + } else { + "NFC is not supported or disabled on this device" + }, + color = TextMuted, + fontSize = 11.sp + ) + } + } + } + + Spacer(modifier = Modifier.height(18.dp)) + + // App version footer + Text( + text = "Server Control v${BuildConfig.VERSION_NAME} (${BuildConfig.VERSION_CODE})", + color = TextMuted.copy(alpha = 0.5f), + fontSize = 11.sp, + fontFamily = FontFamily.Monospace, + modifier = Modifier.align(Alignment.CenterHorizontally) + ) + } + } + } +} diff --git a/app/src/main/java/com/expapp/trigger/ui/screens/MainScreen.kt b/app/src/main/java/com/expapp/trigger/ui/screens/MainScreen.kt index 3998d4e..745fe49 100644 --- a/app/src/main/java/com/expapp/trigger/ui/screens/MainScreen.kt +++ b/app/src/main/java/com/expapp/trigger/ui/screens/MainScreen.kt @@ -24,7 +24,9 @@ import androidx.compose.foundation.shape.CircleShape import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material.icons.Icons import androidx.compose.material.icons.filled.Add +import androidx.compose.material.icons.filled.History import androidx.compose.material.icons.filled.Refresh +import androidx.compose.material.icons.filled.Settings import androidx.compose.material.icons.filled.SystemUpdate import androidx.compose.material.icons.filled.Terminal import androidx.compose.material3.TopAppBar @@ -57,10 +59,19 @@ import androidx.lifecycle.Lifecycle import androidx.lifecycle.LifecycleEventObserver import com.expapp.trigger.BuildConfig import com.expapp.trigger.data.model.DeviceConfig +import com.expapp.trigger.data.model.TriggerLog +import com.expapp.trigger.data.repository.AppSettings import com.expapp.trigger.data.repository.DeviceRepository +import com.expapp.trigger.data.repository.TriggerHistoryRepository import com.expapp.trigger.network.NodeStatus import com.expapp.trigger.network.TriggerAction import com.expapp.trigger.network.TriggerClient +import com.expapp.trigger.nfc.NfcHelper +import com.expapp.trigger.nfc.NfcTriggerPayload +import com.expapp.trigger.security.BiometricHelper +import com.expapp.trigger.ui.components.HistoryDialog +import com.expapp.trigger.ui.components.NfcWriteDialog +import com.expapp.trigger.ui.components.SettingsDialog import com.expapp.trigger.ui.components.UpdateDialog import com.expapp.trigger.ui.theme.BgBase import com.expapp.trigger.ui.theme.BgElevated @@ -77,6 +88,8 @@ import com.expapp.trigger.update.DownloadState import com.expapp.trigger.update.ReleaseInfo import com.expapp.trigger.update.UpdateCheckResult import com.expapp.trigger.update.UpdateManager +import com.expapp.trigger.widget.ServerWidgetProvider +import com.expapp.trigger.worker.ServerMonitorWorker import kotlinx.coroutines.delay import kotlinx.coroutines.isActive import kotlinx.coroutines.launch @@ -86,6 +99,12 @@ import kotlinx.coroutines.launch fun MainScreen( repository: DeviceRepository, triggerClient: TriggerClient, + appSettings: AppSettings, + historyRepository: TriggerHistoryRepository, + requestBiometricAuth: (title: String, subtitle: String, onResult: (Boolean) -> Unit) -> Unit = { _, _, cb -> cb(true) }, + nfcWriteResult: Result? = null, + onStartNfcWriting: (NfcTriggerPayload) -> Unit = {}, + onStopNfcWriting: () -> Unit = {}, modifier: Modifier = Modifier ) { val context = LocalContext.current @@ -114,6 +133,14 @@ fun MainScreen( var downloadState by remember { mutableStateOf(DownloadState.Idle) } var isCheckingUpdate by remember { mutableStateOf(false) } + // Dialog & Feature states + var showHistoryDialog by remember { mutableStateOf(false) } + var showSettingsDialog by remember { mutableStateOf(false) } + var showNfcWriteDialog by remember { mutableStateOf(false) } + var historyLogs by remember { mutableStateOf(historyRepository.getLogs()) } + var isBiometricEnabled by remember { mutableStateOf(appSettings.isBiometricEnabled) } + var isBgMonitorEnabled by remember { mutableStateOf(appSettings.isBackgroundMonitoringEnabled) } + fun checkAppUpdate(showToast: Boolean = false) { isCheckingUpdate = true updateManager.checkForUpdate(BuildConfig.VERSION_NAME) { result -> @@ -203,28 +230,71 @@ fun MainScreen( } fun executeAction(device: DeviceConfig, action: TriggerAction) { - loadingStates[device.id] = true - statusStates.remove(device.id) - triggerClient.sendTrigger(device, action) { response -> - loadingStates[device.id] = false - val msg = if (response.isSuccess) { - when (action) { - TriggerAction.POWER_ON -> "Power on signal sent" - TriggerAction.POWER_OFF -> "Shutdown signal sent" - TriggerAction.REBOOT -> "Restart signal sent" + val actionTitle = when (action) { + TriggerAction.POWER_ON -> "Power On" + TriggerAction.REBOOT -> "Reboot" + TriggerAction.POWER_OFF -> "Shutdown" + } + + val performDispatch = { + loadingStates[device.id] = true + statusStates.remove(device.id) + triggerClient.sendTrigger(device, action) { response -> + loadingStates[device.id] = false + val msg = if (response.isSuccess) { + when (action) { + TriggerAction.POWER_ON -> "Power on signal sent" + TriggerAction.POWER_OFF -> "Shutdown signal sent" + TriggerAction.REBOOT -> "Restart signal sent" + } + } else { + val raw = response.message.trim() + val clean = if (raw.startsWith("<")) "Request failed (HTTP ${response.statusCode})" else raw.take(60) + "Failed — $clean" + } + statusStates[device.id] = msg to response.isSuccess + Toast.makeText(context, msg, Toast.LENGTH_SHORT).show() + + // Save to history log + historyRepository.addLog( + TriggerLog( + deviceId = device.id, + deviceName = device.name, + node = device.node, + action = action, + isSuccess = response.isSuccess, + statusCode = response.statusCode, + message = msg, + source = "App" + ) + ) + historyLogs = historyRepository.getLogs() + + // Update home screen widgets + ServerWidgetProvider.updateAllWidgets(context) + + coroutineScope.launch { + delay(1500); refreshStatus(device, showIndicator = true) + delay(4000); refreshStatus(device) + delay(5000); refreshStatus(device) } - } else { - val raw = response.message.trim() - val clean = if (raw.startsWith("<")) "Request failed (HTTP ${response.statusCode})" else raw.take(60) - "Failed — $clean" } - statusStates[device.id] = msg to response.isSuccess - Toast.makeText(context, msg, Toast.LENGTH_SHORT).show() - coroutineScope.launch { - delay(1500); refreshStatus(device, showIndicator = true) - delay(4000); refreshStatus(device) - delay(5000); refreshStatus(device) + } + + // Biometric Security Gate + if (appSettings.isBiometricEnabled && BiometricHelper.isBiometricAvailable(context)) { + requestBiometricAuth( + "Confirm $actionTitle", + "Authenticate with fingerprint to trigger ${device.name}" + ) { success -> + if (success) { + performDispatch() + } else { + Toast.makeText(context, "Action cancelled", Toast.LENGTH_SHORT).show() + } } + } else { + performDispatch() } } @@ -251,29 +321,29 @@ fun MainScreen( tint = GreenVibrant, modifier = Modifier.size(18.dp) ) - Spacer(modifier = Modifier.width(8.dp)) + Spacer(modifier = Modifier.width(6.dp)) Text( text = "DEVICE TRIGGER", - fontSize = 13.sp, + fontSize = 12.sp, fontWeight = FontWeight.Bold, - letterSpacing = 1.5.sp, + letterSpacing = 1.2.sp, color = TextPrimary, fontFamily = FontFamily.Monospace, maxLines = 1 ) val onlineCount = devices.count { nodeStatuses[it.id]?.isOnline == true } if (devices.isNotEmpty() && onlineCount > 0) { - Spacer(modifier = Modifier.width(8.dp)) + Spacer(modifier = Modifier.width(6.dp)) Box( modifier = Modifier .clip(CircleShape) .background(OnlineBg) .border(1.dp, OnlineBorder, CircleShape) - .padding(horizontal = 7.dp, vertical = 2.dp) + .padding(horizontal = 6.dp, vertical = 2.dp) ) { Text( - "$onlineCount online", - fontSize = 10.sp, + "$onlineCount on", + fontSize = 9.sp, fontWeight = FontWeight.Bold, color = OnlineText, letterSpacing = 0.5.sp @@ -283,44 +353,85 @@ fun MainScreen( } }, actions = { + // Update Button if (availableUpdate != null) { IconButton( onClick = { showUpdateDialog = true }, - modifier = Modifier.size(40.dp) + modifier = Modifier.size(36.dp) ) { Box(contentAlignment = Alignment.TopEnd) { Icon( Icons.Default.SystemUpdate, contentDescription = "Update available", tint = GreenVibrant, - modifier = Modifier.size(20.dp) + modifier = Modifier.size(18.dp) ) Box( modifier = Modifier - .size(7.dp) + .size(6.dp) .background(GreenVibrant, CircleShape) .border(1.dp, BgSurface, CircleShape) ) } } } + + // Trigger History Button + IconButton( + onClick = { + historyLogs = historyRepository.getLogs() + showHistoryDialog = true + }, + modifier = Modifier.size(36.dp) + ) { + Icon( + Icons.Default.History, + contentDescription = "Trigger History", + tint = TextSecondary, + modifier = Modifier.size(20.dp) + ) + } + + // Settings Button + IconButton( + onClick = { showSettingsDialog = true }, + modifier = Modifier.size(36.dp) + ) { + Icon( + Icons.Default.Settings, + contentDescription = "Settings", + tint = TextSecondary, + modifier = Modifier.size(20.dp) + ) + } + + // R2 Sync Button IconButton( onClick = { syncEndpoints(true) }, enabled = !isSyncing, - modifier = Modifier.size(40.dp) + modifier = Modifier.size(36.dp) ) { Icon( Icons.Default.Refresh, "Sync", tint = if (isSyncing) TextMuted else GreenVibrant, - modifier = Modifier.rotate(rotationAngle) + modifier = Modifier + .size(20.dp) + .rotate(rotationAngle) ) } + + // Add Device Button IconButton( onClick = { coroutineScope.launch { pagerState.animateScrollToPage(devices.size) } }, - modifier = Modifier.size(40.dp) + modifier = Modifier.size(36.dp) ) { - Icon(Icons.Default.Add, "Add Device", tint = GreenVibrant) + Icon( + Icons.Default.Add, + "Add Device", + tint = GreenVibrant, + modifier = Modifier.size(22.dp) + ) } }, colors = TopAppBarDefaults.topAppBarColors( @@ -349,20 +460,26 @@ fun MainScreen( } Box( modifier = Modifier - .padding(horizontal = 3.dp) - .height(6.dp) - .width(if (selected) 22.dp else 6.dp) - .clip(if (selected) RoundedCornerShape(3.dp) else CircleShape) + .padding(horizontal = 4.dp) + .size(if (selected) 8.dp else 6.dp) + .clip(CircleShape) .background(dotColor) + .clickable { + coroutineScope.launch { + pagerState.animateScrollToPage(i) + } + } ) } } } } - ) { padding -> + ) { innerPadding -> HorizontalPager( state = pagerState, - modifier = Modifier.fillMaxSize().padding(padding) + modifier = Modifier + .fillMaxSize() + .padding(innerPadding) ) { page -> if (page < devices.size) { val dev = devices[page] @@ -376,35 +493,15 @@ fun MainScreen( onDismissStatus = { statusStates.remove(dev.id) }, onRefreshStatus = { refreshStatus(dev, showIndicator = true) }, onTrigger = { action -> executeAction(dev, action) }, - onDelete = { d -> repository.deleteDevice(d.id); devices = repository.getDevices() }, - onSyncConfig = { - triggerClient.fetchR2Config(dev.r2Url) { result -> - result.onSuccess { ep -> - val changed = repository.updateEndpoints(dev.id, ep.powerOn, ep.powerOff, ep.reboot, ep.status) - devices = repository.getDevices() - val msg = if (changed) "Endpoints updated from R2" else "Endpoints already up to date" - statusStates[dev.id] = msg to true - refreshStatus(dev, showIndicator = true) - }.onFailure { ex -> - statusStates[dev.id] = "Failed to fetch R2: ${ex.message}" to false - } - } + onDelete = { d -> + repository.deleteDevice(d.id) + devices = repository.getDevices() }, + onSyncConfig = { syncEndpoints(true) }, onUpdateDevice = { updated -> repository.updateDevice(updated) devices = repository.getDevices() - if (updated.r2Url.isNotBlank() && updated.r2Url != dev.r2Url) { - triggerClient.fetchR2Config(updated.r2Url) { result -> - result.onSuccess { ep -> - repository.updateEndpoints(updated.id, ep.powerOn, ep.powerOff, ep.reboot, ep.status) - devices = repository.getDevices() - statusStates[updated.id] = "Device & endpoints updated" to true - refreshStatus(updated, showIndicator = true) - } - } - } else { - statusStates[updated.id] = "Device updated" to true - } + refreshStatus(updated, showIndicator = true) } ) } else { @@ -424,6 +521,69 @@ fun MainScreen( } } + // Trigger History Dialog + if (showHistoryDialog) { + HistoryDialog( + logs = historyLogs, + onClearOlderThan = { millis -> + historyRepository.clearOlderThan(millis) + historyLogs = historyRepository.getLogs() + }, + onClearAll = { + historyRepository.clearAll() + historyLogs = emptyList() + }, + onDismiss = { showHistoryDialog = false } + ) + } + + // Settings Dialog + if (showSettingsDialog) { + SettingsDialog( + isBiometricEnabled = isBiometricEnabled, + onBiometricToggled = { enabled -> + isBiometricEnabled = enabled + appSettings.isBiometricEnabled = enabled + }, + isBgMonitorEnabled = isBgMonitorEnabled, + onBgMonitorToggled = { enabled -> + isBgMonitorEnabled = enabled + appSettings.isBackgroundMonitoringEnabled = enabled + if (enabled) { + ServerMonitorWorker.createNotificationChannel(context) + ServerMonitorWorker.schedule(context) + } else { + ServerMonitorWorker.cancel(context) + } + }, + isBiometricAvailable = BiometricHelper.isBiometricAvailable(context), + isNfcAvailable = NfcHelper.isNfcSupported(context), + onOpenNfcWriter = { + showNfcWriteDialog = true + }, + onDismiss = { showSettingsDialog = false } + ) + } + + // NFC Write Tag Dialog + if (showNfcWriteDialog) { + NfcWriteDialog( + devices = devices, + writeResult = nfcWriteResult, + onStartWriting = { payload -> + onStartNfcWriting(payload) + }, + onStopWriting = { + onStopNfcWriting() + }, + onDismiss = { + onStopNfcWriting() + showNfcWriteDialog = false + } + ) + } + + // Update Dialog if (showUpdateDialog && availableUpdate != null) { UpdateDialog( releaseInfo = availableUpdate!!, diff --git a/app/src/main/java/com/expapp/trigger/ui/theme/Color.kt b/app/src/main/java/com/expapp/trigger/ui/theme/Color.kt index 13fc2ef..3519266 100644 --- a/app/src/main/java/com/expapp/trigger/ui/theme/Color.kt +++ b/app/src/main/java/com/expapp/trigger/ui/theme/Color.kt @@ -7,6 +7,7 @@ val BgDeep = Color(0xFF060911) // deepest black-navy val BgBase = Color(0xFF0C0F1A) // main bg val BgSurface = Color(0xFF111827) // card surface val BgElevated = Color(0xFF1A2235) // elevated panels +val BgCard = Color(0xFF161F30) // card background val BgGlass = Color(0x14FFFFFF) // frosted glass overlay // ── Border System ───────────────────────────────────────────────────────── diff --git a/app/src/main/java/com/expapp/trigger/widget/ServerWidgetProvider.kt b/app/src/main/java/com/expapp/trigger/widget/ServerWidgetProvider.kt new file mode 100644 index 0000000..106b2f5 --- /dev/null +++ b/app/src/main/java/com/expapp/trigger/widget/ServerWidgetProvider.kt @@ -0,0 +1,271 @@ +package com.expapp.trigger.widget + +import android.app.PendingIntent +import android.appwidget.AppWidgetManager +import android.appwidget.AppWidgetProvider +import android.content.ComponentName +import android.content.Context +import android.content.Intent +import android.os.Build +import android.os.Handler +import android.os.Looper +import android.widget.RemoteViews +import android.widget.Toast +import com.expapp.trigger.MainActivity +import com.expapp.trigger.R +import com.expapp.trigger.data.model.DeviceConfig +import com.expapp.trigger.data.model.TriggerLog +import com.expapp.trigger.data.repository.AppSettings +import com.expapp.trigger.data.repository.DeviceRepository +import com.expapp.trigger.data.repository.SharedPrefsStorage +import com.expapp.trigger.data.repository.TriggerHistoryRepository +import com.expapp.trigger.network.NodeStatus +import com.expapp.trigger.network.TriggerAction +import com.expapp.trigger.network.TriggerClient +import java.util.concurrent.Executors + +class ServerWidgetProvider : AppWidgetProvider() { + + companion object { + const val ACTION_TRIGGER = "com.expapp.trigger.widget.ACTION_TRIGGER" + const val ACTION_REFRESH = "com.expapp.trigger.widget.ACTION_REFRESH" + const val ACTION_CYCLE_DEVICE = "com.expapp.trigger.widget.ACTION_CYCLE_DEVICE" + + const val EXTRA_DEVICE_ID = "extra_device_id" + const val EXTRA_ACTION = "extra_action" + + private val executor = Executors.newSingleThreadExecutor() + private val mainHandler = Handler(Looper.getMainLooper()) + + fun updateAllWidgets(context: Context) { + val appWidgetManager = AppWidgetManager.getInstance(context) + val thisWidget = ComponentName(context, ServerWidgetProvider::class.java) + val appWidgetIds = appWidgetManager.getAppWidgetIds(thisWidget) + if (appWidgetIds != null && appWidgetIds.isNotEmpty()) { + val intent = Intent(context, ServerWidgetProvider::class.java).apply { + action = AppWidgetManager.ACTION_APPWIDGET_UPDATE + putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, appWidgetIds) + } + context.sendBroadcast(intent) + } + } + } + + override fun onUpdate( + context: Context, + appWidgetManager: AppWidgetManager, + appWidgetIds: IntArray + ) { + val repository = DeviceRepository(SharedPrefsStorage(context)) + val devices = repository.getDevices() + + for (appWidgetId in appWidgetIds) { + val device = devices.firstOrNull() + renderWidget(context, appWidgetManager, appWidgetId, device, null) + + // If device exists, fetch live status asynchronously + if (device != null && device.statusUrl.isNotBlank()) { + executor.execute { + val status = TriggerClient().checkStatusSync(device) + mainHandler.post { + renderWidget(context, appWidgetManager, appWidgetId, device, status) + } + } + } + } + } + + override fun onReceive(context: Context, intent: Intent) { + super.onReceive(context, intent) + + when (intent.action) { + ACTION_TRIGGER -> { + val deviceId = intent.getStringExtra(EXTRA_DEVICE_ID) ?: return + val actionName = intent.getStringExtra(EXTRA_ACTION) ?: return + val action = try { TriggerAction.valueOf(actionName) } catch (e: Exception) { return } + + val appSettings = AppSettings(context) + if (appSettings.isBiometricEnabled) { + // Biometric is enabled: open MainActivity with Trigger intent + val launchIntent = Intent(context, MainActivity::class.java).apply { + flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP + this.action = ACTION_TRIGGER + putExtra(EXTRA_DEVICE_ID, deviceId) + putExtra(EXTRA_ACTION, actionName) + } + context.startActivity(launchIntent) + } else { + // Biometric disabled: execute directly in background + executor.execute { + val repository = DeviceRepository(SharedPrefsStorage(context)) + val device = repository.getDevices().find { it.id == deviceId } ?: return@execute + val client = TriggerClient() + + val response = client.sendTriggerSync(device, action) + val historyRepo = TriggerHistoryRepository(context) + historyRepo.addLog( + TriggerLog( + deviceId = device.id, + deviceName = device.name, + node = device.node, + action = action, + isSuccess = response.isSuccess, + statusCode = response.statusCode, + message = response.message, + source = "Widget" + ) + ) + + mainHandler.post { + val msg = if (response.isSuccess) { + when (action) { + TriggerAction.POWER_ON -> "Power on sent to ${device.name}" + TriggerAction.REBOOT -> "Restart sent to ${device.name}" + TriggerAction.POWER_OFF -> "Shutdown sent to ${device.name}" + } + } else { + "Failed: ${response.message.take(40)}" + } + Toast.makeText(context, msg, Toast.LENGTH_SHORT).show() + updateAllWidgets(context) + } + } + } + } + + ACTION_REFRESH -> { + executor.execute { + val repository = DeviceRepository(SharedPrefsStorage(context)) + val device = repository.getDevices().firstOrNull() + if (device != null) { + val status = TriggerClient().checkStatusSync(device) + mainHandler.post { + val appWidgetManager = AppWidgetManager.getInstance(context) + val thisWidget = ComponentName(context, ServerWidgetProvider::class.java) + val ids = appWidgetManager.getAppWidgetIds(thisWidget) + for (id in ids) { + renderWidget(context, appWidgetManager, id, device, status, "Updated just now") + } + Toast.makeText(context, "Widget refreshed", Toast.LENGTH_SHORT).show() + } + } + } + } + } + } + + private fun renderWidget( + context: Context, + appWidgetManager: AppWidgetManager, + appWidgetId: Int, + device: DeviceConfig?, + status: NodeStatus?, + footerOverride: String? = null + ) { + val views = RemoteViews(context.packageName, R.layout.widget_server_control) + + if (device == null) { + views.setTextViewText(R.id.widget_device_name, "No Device") + views.setTextViewText(R.id.widget_node_name, "Configure in app") + views.setTextViewText(R.id.widget_status_text, "OFFLINE") + views.setImageViewResource(R.id.widget_status_dot, R.drawable.widget_dot_gray) + views.setTextViewText(R.id.widget_footer_text, "Open app to add server") + + val appIntent = Intent(context, MainActivity::class.java) + val pendingApp = PendingIntent.getActivity( + context, 0, appIntent, + PendingIntent.FLAG_UPDATE_CURRENT or (if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) PendingIntent.FLAG_IMMUTABLE else 0) + ) + views.setOnClickPendingIntent(R.id.widget_header_clickable, pendingApp) + views.setOnClickPendingIntent(R.id.widget_root, pendingApp) + appWidgetManager.updateAppWidget(appWidgetId, views) + return + } + + views.setTextViewText(R.id.widget_device_name, device.name) + views.setTextViewText(R.id.widget_node_name, device.node) + + // Status display + if (status == null) { + views.setTextViewText(R.id.widget_status_text, "SYNCING") + views.setTextColor(R.id.widget_status_text, 0xFF71717A.toInt()) + views.setImageViewResource(R.id.widget_status_dot, R.drawable.widget_dot_gray) + } else if (status.isOnline) { + views.setTextViewText(R.id.widget_status_text, "ONLINE") + views.setTextColor(R.id.widget_status_text, 0xFF22C55E.toInt()) + views.setImageViewResource(R.id.widget_status_dot, R.drawable.widget_dot_green) + } else { + views.setTextViewText(R.id.widget_status_text, "OFFLINE") + views.setTextColor(R.id.widget_status_text, 0xFFEF4444.toInt()) + views.setImageViewResource(R.id.widget_status_dot, R.drawable.widget_dot_red) + } + + views.setTextViewText( + R.id.widget_footer_text, + footerOverride ?: (if (status?.uptime != null) "Up: ${status.uptime}" else "Tap header to open • Tap button to trigger") + ) + + // Header click -> Open app + val openAppIntent = Intent(context, MainActivity::class.java).apply { + flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP + } + val pendingOpenApp = PendingIntent.getActivity( + context, + appWidgetId * 10, + openAppIntent, + PendingIntent.FLAG_UPDATE_CURRENT or (if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) PendingIntent.FLAG_IMMUTABLE else 0) + ) + views.setOnClickPendingIntent(R.id.widget_header_clickable, pendingOpenApp) + + // Refresh click + val refreshIntent = Intent(context, ServerWidgetProvider::class.java).apply { + action = ACTION_REFRESH + } + val pendingRefresh = PendingIntent.getBroadcast( + context, + appWidgetId * 10 + 1, + refreshIntent, + PendingIntent.FLAG_UPDATE_CURRENT or (if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) PendingIntent.FLAG_IMMUTABLE else 0) + ) + views.setOnClickPendingIntent(R.id.widget_btn_refresh, pendingRefresh) + + // Power On click + views.setOnClickPendingIntent( + R.id.widget_btn_power_on, + createTriggerPendingIntent(context, appWidgetId * 10 + 2, device.id, TriggerAction.POWER_ON) + ) + + // Reboot click + views.setOnClickPendingIntent( + R.id.widget_btn_reboot, + createTriggerPendingIntent(context, appWidgetId * 10 + 3, device.id, TriggerAction.REBOOT) + ) + + // Power Off click + views.setOnClickPendingIntent( + R.id.widget_btn_power_off, + createTriggerPendingIntent(context, appWidgetId * 10 + 4, device.id, TriggerAction.POWER_OFF) + ) + + appWidgetManager.updateAppWidget(appWidgetId, views) + } + + private fun createTriggerPendingIntent( + context: Context, + requestCode: Int, + deviceId: String, + action: TriggerAction + ): PendingIntent { + val intent = Intent(context, ServerWidgetProvider::class.java).apply { + this.action = ACTION_TRIGGER + putExtra(EXTRA_DEVICE_ID, deviceId) + putExtra(EXTRA_ACTION, action.name) + } + return PendingIntent.getBroadcast( + context, + requestCode, + intent, + PendingIntent.FLAG_UPDATE_CURRENT or (if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) PendingIntent.FLAG_IMMUTABLE else 0) + ) + } +} diff --git a/app/src/main/java/com/expapp/trigger/worker/ServerMonitorWorker.kt b/app/src/main/java/com/expapp/trigger/worker/ServerMonitorWorker.kt new file mode 100644 index 0000000..fbcf4e9 --- /dev/null +++ b/app/src/main/java/com/expapp/trigger/worker/ServerMonitorWorker.kt @@ -0,0 +1,143 @@ +package com.expapp.trigger.worker + +import android.app.NotificationChannel +import android.app.NotificationManager +import android.app.PendingIntent +import android.content.Context +import android.content.Intent +import android.os.Build +import androidx.core.app.NotificationCompat +import androidx.core.app.NotificationManagerCompat +import androidx.work.Constraints +import androidx.work.CoroutineWorker +import androidx.work.ExistingPeriodicWorkPolicy +import androidx.work.NetworkType +import androidx.work.PeriodicWorkRequestBuilder +import androidx.work.WorkManager +import androidx.work.WorkerParameters +import com.expapp.trigger.MainActivity +import com.expapp.trigger.R +import com.expapp.trigger.data.repository.AppSettings +import com.expapp.trigger.data.repository.DeviceRepository +import com.expapp.trigger.data.repository.SharedPrefsStorage +import com.expapp.trigger.network.TriggerClient +import java.util.concurrent.TimeUnit + +class ServerMonitorWorker( + private val appContext: Context, + workerParams: WorkerParameters +) : CoroutineWorker(appContext, workerParams) { + + companion object { + const val WORK_NAME = "server_status_periodic_monitor" + const val CHANNEL_ID = "server_status_channel" + + fun schedule(context: Context, repeatIntervalMinutes: Long = 15) { + val constraints = Constraints.Builder() + .setRequiredNetworkType(NetworkType.CONNECTED) + .build() + + val workRequest = PeriodicWorkRequestBuilder( + repeatIntervalMinutes, + TimeUnit.MINUTES + ) + .setConstraints(constraints) + .build() + + WorkManager.getInstance(context).enqueueUniquePeriodicWork( + WORK_NAME, + ExistingPeriodicWorkPolicy.KEEP, + workRequest + ) + } + + fun cancel(context: Context) { + WorkManager.getInstance(context).cancelUniqueWork(WORK_NAME) + } + + fun createNotificationChannel(context: Context) { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { + val channel = NotificationChannel( + CHANNEL_ID, + "Server Status Alerts", + NotificationManager.IMPORTANCE_HIGH + ).apply { + description = "Alerts when your servers go offline or come back online" + enableVibration(true) + } + val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager + manager.createNotificationChannel(channel) + } + } + } + + override suspend fun doWork(): Result { + val appSettings = AppSettings(appContext) + if (!appSettings.isBackgroundMonitoringEnabled) { + return Result.success() + } + + createNotificationChannel(appContext) + + val repository = DeviceRepository(SharedPrefsStorage(appContext)) + val devices = repository.getDevices() + if (devices.isEmpty()) { + return Result.success() + } + + val triggerClient = TriggerClient() + + for (device in devices) { + if (device.statusUrl.isBlank()) continue + + val status = triggerClient.checkStatusSync(device) + val previousStatus = appSettings.getLastStatus(device.id) + + // Save new status + appSettings.setLastStatus(device.id, status.isOnline) + + // If we have a prior status recorded and it flipped, notify + if (previousStatus != null && previousStatus != status.isOnline) { + sendNotification( + device.id.hashCode(), + if (status.isOnline) "✅ Server Back Online" else "⚠️ Server Offline", + if (status.isOnline) { + "${device.name} is now online and reachable." + } else { + "${device.name} is unreachable or offline." + } + ) + } + } + + return Result.success() + } + + private fun sendNotification(id: Int, title: String, message: String) { + val intent = Intent(appContext, MainActivity::class.java).apply { + flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP + } + val pendingIntent = PendingIntent.getActivity( + appContext, + id, + intent, + PendingIntent.FLAG_UPDATE_CURRENT or (if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) PendingIntent.FLAG_IMMUTABLE else 0) + ) + + val notification = NotificationCompat.Builder(appContext, CHANNEL_ID) + .setSmallIcon(R.mipmap.ic_launcher) + .setContentTitle(title) + .setContentText(message) + .setStyle(NotificationCompat.BigTextStyle().bigText(message)) + .setPriority(NotificationCompat.PRIORITY_HIGH) + .setAutoCancel(true) + .setContentIntent(pendingIntent) + .build() + + try { + NotificationManagerCompat.from(appContext).notify(id, notification) + } catch (e: SecurityException) { + // Android 13+ permission might not be granted yet + } + } +} diff --git a/app/src/main/res/drawable/ic_refresh.xml b/app/src/main/res/drawable/ic_refresh.xml new file mode 100644 index 0000000..9d654ab --- /dev/null +++ b/app/src/main/res/drawable/ic_refresh.xml @@ -0,0 +1,9 @@ + + + diff --git a/app/src/main/res/drawable/ic_terminal.xml b/app/src/main/res/drawable/ic_terminal.xml new file mode 100644 index 0000000..ae4405d --- /dev/null +++ b/app/src/main/res/drawable/ic_terminal.xml @@ -0,0 +1,9 @@ + + + diff --git a/app/src/main/res/drawable/widget_bg.xml b/app/src/main/res/drawable/widget_bg.xml new file mode 100644 index 0000000..c8a3871 --- /dev/null +++ b/app/src/main/res/drawable/widget_bg.xml @@ -0,0 +1,9 @@ + + + + + + diff --git a/app/src/main/res/drawable/widget_btn_amber.xml b/app/src/main/res/drawable/widget_btn_amber.xml new file mode 100644 index 0000000..4399188 --- /dev/null +++ b/app/src/main/res/drawable/widget_btn_amber.xml @@ -0,0 +1,9 @@ + + + + + + diff --git a/app/src/main/res/drawable/widget_btn_green.xml b/app/src/main/res/drawable/widget_btn_green.xml new file mode 100644 index 0000000..017c4c3 --- /dev/null +++ b/app/src/main/res/drawable/widget_btn_green.xml @@ -0,0 +1,9 @@ + + + + + + diff --git a/app/src/main/res/drawable/widget_btn_red.xml b/app/src/main/res/drawable/widget_btn_red.xml new file mode 100644 index 0000000..1607461 --- /dev/null +++ b/app/src/main/res/drawable/widget_btn_red.xml @@ -0,0 +1,9 @@ + + + + + + diff --git a/app/src/main/res/drawable/widget_dot_gray.xml b/app/src/main/res/drawable/widget_dot_gray.xml new file mode 100644 index 0000000..65ed7f9 --- /dev/null +++ b/app/src/main/res/drawable/widget_dot_gray.xml @@ -0,0 +1,6 @@ + + + + + diff --git a/app/src/main/res/drawable/widget_dot_green.xml b/app/src/main/res/drawable/widget_dot_green.xml new file mode 100644 index 0000000..8bcc35d --- /dev/null +++ b/app/src/main/res/drawable/widget_dot_green.xml @@ -0,0 +1,6 @@ + + + + + diff --git a/app/src/main/res/drawable/widget_dot_red.xml b/app/src/main/res/drawable/widget_dot_red.xml new file mode 100644 index 0000000..ff9b89f --- /dev/null +++ b/app/src/main/res/drawable/widget_dot_red.xml @@ -0,0 +1,6 @@ + + + + + diff --git a/app/src/main/res/layout/widget_server_control.xml b/app/src/main/res/layout/widget_server_control.xml new file mode 100644 index 0000000..58426d3 --- /dev/null +++ b/app/src/main/res/layout/widget_server_control.xml @@ -0,0 +1,156 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/src/main/res/xml/server_widget_info.xml b/app/src/main/res/xml/server_widget_info.xml new file mode 100644 index 0000000..eb17d69 --- /dev/null +++ b/app/src/main/res/xml/server_widget_info.xml @@ -0,0 +1,8 @@ + + diff --git a/app/src/test/java/com/expapp/trigger/data/repository/AppSettingsTest.kt b/app/src/test/java/com/expapp/trigger/data/repository/AppSettingsTest.kt new file mode 100644 index 0000000..862e302 --- /dev/null +++ b/app/src/test/java/com/expapp/trigger/data/repository/AppSettingsTest.kt @@ -0,0 +1,61 @@ +package com.expapp.trigger.data.repository + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test + +class AppSettingsTest { + + private class FakeKeyValueStorage : KeyValueStorage { + private val data = mutableMapOf() + private val boolData = mutableMapOf() + + override fun getString(key: String, defaultValue: String?): String? = data[key] ?: defaultValue + override fun putString(key: String, value: String?) { data[key] = value } + override fun getBoolean(key: String, defaultValue: Boolean): Boolean = boolData[key] ?: defaultValue + override fun putBoolean(key: String, value: Boolean) { boolData[key] = value } + override fun contains(key: String): Boolean = data.containsKey(key) || boolData.containsKey(key) + override fun remove(key: String) { + data.remove(key) + boolData.remove(key) + } + } + + private lateinit var storage: FakeKeyValueStorage + private lateinit var settings: AppSettings + + @Before + fun setup() { + storage = FakeKeyValueStorage() + settings = AppSettings(storage) + } + + @Test + fun defaultValues_areTrue() { + assertTrue(settings.isBiometricEnabled) + assertTrue(settings.isBackgroundMonitoringEnabled) + } + + @Test + fun toggles_updateCorrectly() { + settings.isBiometricEnabled = false + assertFalse(settings.isBiometricEnabled) + + settings.isBackgroundMonitoringEnabled = false + assertFalse(settings.isBackgroundMonitoringEnabled) + } + + @Test + fun deviceStatus_tracksTransitions() { + assertNull(settings.getLastStatus("dev-1")) + + settings.setLastStatus("dev-1", true) + assertEquals(true, settings.getLastStatus("dev-1")) + + settings.setLastStatus("dev-1", false) + assertEquals(false, settings.getLastStatus("dev-1")) + } +} diff --git a/app/src/test/java/com/expapp/trigger/data/repository/TriggerHistoryRepositoryTest.kt b/app/src/test/java/com/expapp/trigger/data/repository/TriggerHistoryRepositoryTest.kt new file mode 100644 index 0000000..df7e1ee --- /dev/null +++ b/app/src/test/java/com/expapp/trigger/data/repository/TriggerHistoryRepositoryTest.kt @@ -0,0 +1,128 @@ +package com.expapp.trigger.data.repository + +import com.expapp.trigger.data.model.TriggerLog +import com.expapp.trigger.network.TriggerAction +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import java.util.concurrent.TimeUnit + +class TriggerHistoryRepositoryTest { + + private class FakeKeyValueStorage : KeyValueStorage { + private val data = mutableMapOf() + private val boolData = mutableMapOf() + + override fun getString(key: String, defaultValue: String?): String? = data[key] ?: defaultValue + override fun putString(key: String, value: String?) { data[key] = value } + override fun getBoolean(key: String, defaultValue: Boolean): Boolean = boolData[key] ?: defaultValue + override fun putBoolean(key: String, value: Boolean) { boolData[key] = value } + override fun contains(key: String): Boolean = data.containsKey(key) || boolData.containsKey(key) + override fun remove(key: String) { + data.remove(key) + boolData.remove(key) + } + } + + private lateinit var storage: FakeKeyValueStorage + private lateinit var repository: TriggerHistoryRepository + + @Before + fun setup() { + storage = FakeKeyValueStorage() + repository = TriggerHistoryRepository(storage) + } + + @Test + fun getLogs_whenEmpty_returnsEmptyList() { + assertTrue(repository.getLogs().isEmpty()) + } + + @Test + fun addLog_savesAndReturnsSortedByTimestampDescending() { + val now = System.currentTimeMillis() + val log1 = TriggerLog( + timestamp = now - 5000, + deviceId = "dev-1", + deviceName = "Server", + node = "debian", + action = TriggerAction.POWER_ON, + isSuccess = true, + statusCode = 200, + message = "Power on ok" + ) + val log2 = TriggerLog( + timestamp = now, + deviceId = "dev-1", + deviceName = "Server", + node = "debian", + action = TriggerAction.REBOOT, + isSuccess = true, + statusCode = 200, + message = "Reboot ok" + ) + + repository.addLog(log1) + repository.addLog(log2) + + val logs = repository.getLogs() + assertEquals(2, logs.size) + assertEquals(TriggerAction.REBOOT, logs[0].action) + assertEquals(TriggerAction.POWER_ON, logs[1].action) + } + + @Test + fun clearOlderThan_removesExpiredLogsOnly() { + val now = System.currentTimeMillis() + val oldLog = TriggerLog( + timestamp = now - TimeUnit.HOURS.toMillis(48), // 2 days ago + deviceId = "dev-1", + deviceName = "Server", + node = "debian", + action = TriggerAction.POWER_ON, + isSuccess = true, + statusCode = 200, + message = "Old" + ) + val freshLog = TriggerLog( + timestamp = now - TimeUnit.HOURS.toMillis(2), // 2 hours ago + deviceId = "dev-1", + deviceName = "Server", + node = "debian", + action = TriggerAction.REBOOT, + isSuccess = true, + statusCode = 200, + message = "Fresh" + ) + + repository.addLog(oldLog) + repository.addLog(freshLog) + assertEquals(2, repository.getLogs().size) + + // Clear older than 24 hours + repository.clearOlderThan(TimeUnit.HOURS.toMillis(24)) + + val remaining = repository.getLogs() + assertEquals(1, remaining.size) + assertEquals("Fresh", remaining[0].message) + } + + @Test + fun clearAll_clearsEverything() { + val log = TriggerLog( + deviceId = "dev-1", + deviceName = "Server", + node = "debian", + action = TriggerAction.POWER_ON, + isSuccess = true, + statusCode = 200, + message = "Test" + ) + repository.addLog(log) + assertEquals(1, repository.getLogs().size) + + repository.clearAll() + assertTrue(repository.getLogs().isEmpty()) + } +}