Skip to content

Colota - Android GPS Location tracker

fix: refresh battery critical UI when charger state changes

Max Dietrich7ae9dcfbd7fb
diff --git a/apps/mobile/android/app/src/main/java/com/colota/bridge/LocationServiceModule.kt b/apps/mobile/android/app/src/main/java/com/colota/bridge/LocationServiceModule.kt
index eb7c993d..9e6334bd 100644
--- a/apps/mobile/android/app/src/main/java/com/colota/bridge/LocationServiceModule.kt
+++ b/apps/mobile/android/app/src/main/java/com/colota/bridge/LocationServiceModule.kt
@@ -6,7 +6,11 @@
package com.Colota.bridge
import android.app.Activity
+import android.content.BroadcastReceiver
+import android.content.Context
import android.content.Intent
+import android.content.IntentFilter
+import androidx.core.content.ContextCompat
import com.Colota.BuildConfig
import com.Colota.data.DatabaseHelper
import com.Colota.data.GeofenceHelper
@@ -69,6 +73,16 @@ class LocationServiceModule(reactContext: ReactApplicationContext) :
private var safPickerPromise: Promise? = null
private val SAF_PICKER_REQUEST = 9002
+ private val chargingReceiver = object : BroadcastReceiver() {
+ override fun onReceive(context: Context?, intent: Intent?) {
+ when (intent?.action) {
+ Intent.ACTION_POWER_CONNECTED -> handleChargingChange(true)
+ Intent.ACTION_POWER_DISCONNECTED -> handleChargingChange(false)
+ }
+ }
+ }
+ private var chargingReceiverRegistered = false
+
private val activityEventListener = object : BaseActivityEventListener() {
override fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
if (requestCode != SAF_PICKER_REQUEST) return
@@ -192,20 +206,68 @@ class LocationServiceModule(reactContext: ReactApplicationContext) :
putString("zoneName", zoneName)
putString("pauseReason", pauseReason)
}
+
+ @JvmStatic
+ fun sendChargingStateEvent(isPlugged: Boolean): Boolean =
+ emit("onChargingStateChanged") { putBoolean("isPlugged", isPlugged) }
}
override fun getName(): String = "LocationServiceModule"
override fun onHostResume() {
isAppInForeground = true
+ registerChargingReceiver()
}
override fun onHostPause() {
isAppInForeground = false
+ unregisterChargingReceiver()
}
override fun onHostDestroy() {
isAppInForeground = false
+ unregisterChargingReceiver()
+ }
+
+ internal fun handleChargingChange(isPlugged: Boolean) {
+ AppLogger.d(TAG, "Power state changed: plugged=$isPlugged")
+ // Cache invalidation needed because DeviceInfoHelper caches battery status
+ // for 60s; without this the dashboard re-poll could see stale "discharging".
+ deviceInfo.invalidateBatteryCache()
+ sendChargingStateEvent(isPlugged)
+ }
+
+ internal fun resyncChargingState() {
+ handleChargingChange(deviceInfo.isPluggedIn())
+ }
+
+ internal fun registerChargingReceiver() {
+ if (chargingReceiverRegistered) return
+ val filter = IntentFilter().apply {
+ addAction(Intent.ACTION_POWER_CONNECTED)
+ addAction(Intent.ACTION_POWER_DISCONNECTED)
+ }
+ ContextCompat.registerReceiver(
+ reactApplicationContext,
+ chargingReceiver,
+ filter,
+ ContextCompat.RECEIVER_NOT_EXPORTED
+ )
+ chargingReceiverRegistered = true
+ // Power broadcasts aren't sticky; resync on resume to catch plug events
+ // that happened while backgrounded. Receiver-vs-resync race here is
+ // benign because the JS handler (re-poll isBatteryCritical) is idempotent.
+ resyncChargingState()
+ }
+
+ internal fun unregisterChargingReceiver() {
+ if (!chargingReceiverRegistered) return
+ try {
+ reactApplicationContext.unregisterReceiver(chargingReceiver)
+ } catch (e: IllegalArgumentException) {
+ AppLogger.w(TAG, "Charging receiver was not registered: ${e.message}")
+ }
+ chargingReceiverRegistered = false
}
override fun invalidate() {
diff --git a/apps/mobile/android/app/src/main/java/com/colota/util/DeviceInfoHelper.kt b/apps/mobile/android/app/src/main/java/com/colota/util/DeviceInfoHelper.kt
index 3b2adac0..74b92417 100644
--- a/apps/mobile/android/app/src/main/java/com/colota/util/DeviceInfoHelper.kt
+++ b/apps/mobile/android/app/src/main/java/com/colota/util/DeviceInfoHelper.kt
@@ -48,26 +48,8 @@ class DeviceInfoHelper(private val context: Context) {
fun getCachedBatteryStatus(): Pair<Int, Int> = batteryCache.get()
fun getBatteryStatus(): Pair<Int, Int> {
- val batteryIntent = context.registerReceiver(null, IntentFilter(Intent.ACTION_BATTERY_CHANGED))
-
- val level = batteryIntent?.getIntExtra(BatteryManager.EXTRA_LEVEL, -1) ?: -1
- val scale = batteryIntent?.getIntExtra(BatteryManager.EXTRA_SCALE, -1) ?: -1
- val batteryPct = if (level >= 0 && scale > 0) {
- (level * 100) / scale
- } else {
- 100 // Default to full if unable to read
- }
-
- val status = batteryIntent?.getIntExtra(BatteryManager.EXTRA_STATUS, -1) ?: -1
- val batteryStatus = when (status) {
- BatteryManager.BATTERY_STATUS_CHARGING -> 2 // Charging
- BatteryManager.BATTERY_STATUS_FULL -> 3 // Full
- BatteryManager.BATTERY_STATUS_DISCHARGING -> 1 // Unplugged/Discharging
- BatteryManager.BATTERY_STATUS_NOT_CHARGING -> 1 // Unplugged/Discharging
- else -> 0 // Unknown
- }
-
- return Pair(batteryPct, batteryStatus)
+ val snap = readBatterySticky()
+ return Pair(snap.level, snap.status)
}
fun getBatteryStatusString(): String {
@@ -87,6 +69,28 @@ class DeviceInfoHelper(private val context: Context) {
return level < threshold && status == 1 // Discharging
}
+ /** True when device is connected to any power source (AC, USB, wireless). */
+ fun isPluggedIn(): Boolean = readBatterySticky().isPlugged
+
+ private data class BatterySticky(val level: Int, val status: Int, val isPlugged: Boolean)
+
+ private fun readBatterySticky(): BatterySticky {
+ val intent = context.registerReceiver(null, IntentFilter(Intent.ACTION_BATTERY_CHANGED))
+ val rawLevel = intent?.getIntExtra(BatteryManager.EXTRA_LEVEL, -1) ?: -1
+ val scale = intent?.getIntExtra(BatteryManager.EXTRA_SCALE, -1) ?: -1
+ val pct = if (rawLevel >= 0 && scale > 0) (rawLevel * 100) / scale else 100
+ val rawStatus = intent?.getIntExtra(BatteryManager.EXTRA_STATUS, -1) ?: -1
+ val status = when (rawStatus) {
+ BatteryManager.BATTERY_STATUS_CHARGING -> 2 // Charging
+ BatteryManager.BATTERY_STATUS_FULL -> 3 // Full
+ BatteryManager.BATTERY_STATUS_DISCHARGING -> 1 // Unplugged/Discharging
+ BatteryManager.BATTERY_STATUS_NOT_CHARGING -> 1 // Unplugged/Discharging
+ else -> 0 // Unknown
+ }
+ val plugged = (intent?.getIntExtra(BatteryManager.EXTRA_PLUGGED, 0) ?: 0) != 0
+ return BatterySticky(pct, status, plugged)
+ }
+
fun invalidateBatteryCache() = batteryCache.invalidate()
fun isIgnoringBatteryOptimizations(): Boolean {
diff --git a/apps/mobile/android/app/src/test/java/com/Colota/bridge/LocationServiceModuleTest.kt b/apps/mobile/android/app/src/test/java/com/Colota/bridge/LocationServiceModuleTest.kt
index b2f820f6..4932eddd 100644
--- a/apps/mobile/android/app/src/test/java/com/Colota/bridge/LocationServiceModuleTest.kt
+++ b/apps/mobile/android/app/src/test/java/com/Colota/bridge/LocationServiceModuleTest.kt
@@ -11,6 +11,7 @@ import com.Colota.data.GeofenceHelper
import com.Colota.data.ProfileHelper
import com.Colota.service.LocationForegroundService
import com.Colota.util.AppLogger
+import com.Colota.util.DeviceInfoHelper
import com.facebook.react.bridge.Arguments
import com.facebook.react.bridge.JavaOnlyMap
import com.facebook.react.bridge.ReactApplicationContext
@@ -244,29 +245,133 @@ class LocationServiceModuleTest {
assertFalse(LocationServiceModule.sendPauseZoneEvent(true, "Office"))
}
+ // ========================================================================
+ // sendChargingStateEvent
+ // ========================================================================
+
+ @Test
+ fun `sendChargingStateEvent emits onChargingStateChanged when charging`() {
+ assertTrue(LocationServiceModule.sendChargingStateEvent(true))
+ verify { mockEmitter.emit("onChargingStateChanged", any()) }
+ }
+
+ @Test
+ fun `sendChargingStateEvent emits onChargingStateChanged when discharging`() {
+ assertTrue(LocationServiceModule.sendChargingStateEvent(false))
+ verify { mockEmitter.emit("onChargingStateChanged", any()) }
+ }
+
+ @Test
+ fun `sendChargingStateEvent returns false when no context`() {
+ setCompanionField("reactContextRef", WeakReference<ReactApplicationContext>(null))
+ assertFalse(LocationServiceModule.sendChargingStateEvent(true))
+ }
+
+ @Test
+ fun `sendChargingStateEvent returns false when no catalyst`() {
+ every { mockContext.hasActiveCatalystInstance() } returns false
+ assertFalse(LocationServiceModule.sendChargingStateEvent(true))
+ }
+
+ // ========================================================================
+ // handleChargingChange — invalidates cache and emits event
+ // ========================================================================
+
+ @Test
+ fun `handleChargingChange invalidates battery cache and emits charging event`() {
+ val module = createModule()
+ val deviceInfo = mockk<DeviceInfoHelper>(relaxed = true)
+ setField(module, "deviceInfo", deviceInfo)
+
+ module.handleChargingChange(true)
+
+ verify { deviceInfo.invalidateBatteryCache() }
+ verify { mockEmitter.emit("onChargingStateChanged", any()) }
+ }
+
+ @Test
+ fun `handleChargingChange emits discharging event`() {
+ val module = createModule()
+ val deviceInfo = mockk<DeviceInfoHelper>(relaxed = true)
+ setField(module, "deviceInfo", deviceInfo)
+
+ module.handleChargingChange(false)
+
+ verify { deviceInfo.invalidateBatteryCache() }
+ verify { mockEmitter.emit("onChargingStateChanged", any()) }
+ }
+
+ // ========================================================================
+ // resyncChargingState — reads sticky and forwards to handleChargingChange
+ // ========================================================================
+
+ @Test
+ fun `resyncChargingState forwards plugged state to handleChargingChange`() {
+ val module = spyk(createModule())
+ val deviceInfo = mockk<DeviceInfoHelper>(relaxed = true) {
+ every { isPluggedIn() } returns true
+ }
+ setField(module, "deviceInfo", deviceInfo)
+ every { module.handleChargingChange(any()) } just Runs
+
+ module.resyncChargingState()
+
+ verify { deviceInfo.isPluggedIn() }
+ verify { module.handleChargingChange(true) }
+ }
+
+ @Test
+ fun `resyncChargingState forwards unplugged state to handleChargingChange`() {
+ val module = spyk(createModule())
+ val deviceInfo = mockk<DeviceInfoHelper>(relaxed = true) {
+ every { isPluggedIn() } returns false
+ }
+ setField(module, "deviceInfo", deviceInfo)
+ every { module.handleChargingChange(any()) } just Runs
+
+ module.resyncChargingState()
+
+ verify { module.handleChargingChange(false) }
+ }
+
// ========================================================================
// Lifecycle methods
// ========================================================================
@Test
- fun `onHostResume sets foreground true`() {
+ fun `onHostResume sets foreground true and registers receiver`() {
setCompanionField("isAppInForeground", false)
- createModule().onHostResume()
+ val module = spyk(createModule())
+ every { module.registerChargingReceiver() } just Runs
+
+ module.onHostResume()
+
assertTrue(getCompanionField("isAppInForeground") as Boolean)
+ verify { module.registerChargingReceiver() }
}
@Test
- fun `onHostPause sets foreground false`() {
+ fun `onHostPause sets foreground false and unregisters receiver`() {
setCompanionField("isAppInForeground", true)
- createModule().onHostPause()
+ val module = spyk(createModule())
+ every { module.unregisterChargingReceiver() } just Runs
+
+ module.onHostPause()
+
assertFalse(getCompanionField("isAppInForeground") as Boolean)
+ verify { module.unregisterChargingReceiver() }
}
@Test
- fun `onHostDestroy sets foreground false`() {
+ fun `onHostDestroy sets foreground false and unregisters receiver`() {
setCompanionField("isAppInForeground", true)
- createModule().onHostDestroy()
+ val module = spyk(createModule())
+ every { module.unregisterChargingReceiver() } just Runs
+
+ module.onHostDestroy()
+
assertFalse(getCompanionField("isAppInForeground") as Boolean)
+ verify { module.unregisterChargingReceiver() }
}
// ========================================================================
diff --git a/apps/mobile/android/app/src/test/java/com/Colota/util/DeviceInfoHelperTest.kt b/apps/mobile/android/app/src/test/java/com/Colota/util/DeviceInfoHelperTest.kt
index aed7ca3f..436bb48b 100644
--- a/apps/mobile/android/app/src/test/java/com/Colota/util/DeviceInfoHelperTest.kt
+++ b/apps/mobile/android/app/src/test/java/com/Colota/util/DeviceInfoHelperTest.kt
@@ -206,13 +206,38 @@ class DeviceInfoHelperTest {
assertEquals(0, statusCode)
}
+ @Test
+ fun `isPluggedIn returns true when plugged via AC`() {
+ mockBatteryIntent(level = 50, scale = 100, status = BatteryManager.BATTERY_STATUS_CHARGING, plugged = BatteryManager.BATTERY_PLUGGED_AC)
+ assertTrue(helper.isPluggedIn())
+ }
+
+ @Test
+ fun `isPluggedIn returns true when plugged via USB`() {
+ mockBatteryIntent(level = 50, scale = 100, status = BatteryManager.BATTERY_STATUS_CHARGING, plugged = BatteryManager.BATTERY_PLUGGED_USB)
+ assertTrue(helper.isPluggedIn())
+ }
+
+ @Test
+ fun `isPluggedIn returns false when unplugged`() {
+ mockBatteryIntent(level = 50, scale = 100, status = BatteryManager.BATTERY_STATUS_DISCHARGING, plugged = 0)
+ assertFalse(helper.isPluggedIn())
+ }
+
+ @Test
+ fun `isPluggedIn returns false when intent is null`() {
+ every { context.registerReceiver(null, any()) } returns null
+ assertFalse(helper.isPluggedIn())
+ }
+
// --- Helper ---
- private fun mockBatteryIntent(level: Int, scale: Int, status: Int) {
+ private fun mockBatteryIntent(level: Int, scale: Int, status: Int, plugged: Int = 0) {
val batteryIntent = mockk<Intent> {
every { getIntExtra(BatteryManager.EXTRA_LEVEL, -1) } returns level
every { getIntExtra(BatteryManager.EXTRA_SCALE, -1) } returns scale
every { getIntExtra(BatteryManager.EXTRA_STATUS, -1) } returns status
+ every { getIntExtra(BatteryManager.EXTRA_PLUGGED, 0) } returns plugged
}
every { context.registerReceiver(null, any()) } returns batteryIntent
}
diff --git a/apps/mobile/src/screens/DashboardScreen.tsx b/apps/mobile/src/screens/DashboardScreen.tsx
index be1b0bc1..9c21bda2 100644
--- a/apps/mobile/src/screens/DashboardScreen.tsx
+++ b/apps/mobile/src/screens/DashboardScreen.tsx
@@ -135,6 +135,13 @@ export function DashboardScreen({ navigation }: ScreenProps) {
return () => listener.remove()
}, [updatePauseZone])
+ useEffect(() => {
+ const chargingListener = DeviceEventEmitter.addListener("onChargingStateChanged", () => {
+ NativeLocationService.isBatteryCritical().then(setIsBatteryCritical)
+ })
+ return () => chargingListener.remove()
+ }, [])
+
useEffect(() => {
const pauseZoneListener = DeviceEventEmitter.addListener(
"onPauseZoneChange",