@bricks-soft/capacitor-location-tracking 0.0.0-stage → 8.0.1

package/android/src/main/java/com/brickssoft/locationtracking/service/WhileInUseStartCheck.kt

@@ -0,0 +1,115 @@
+package com.brickssoft.locationtracking.service
+
+import android.Manifest
+import android.app.Activity
+import android.app.ActivityManager
+import android.app.Application
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.content.ContextCompat
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import com.brickssoft.locationtracking.core.Clock
+import com.brickssoft.locationtracking.permission.ActivityLifecycleAdapter
+import com.brickssoft.locationtracking.permission.CurrentActivityTracker
+
+/**
+ * Predicts, before `startForegroundService()`, whether Android 14+ would refuse a location foreground service because
+ * the app would not get while-in-use location access.
+ *
+ * On Android 14 (API 34) and later, `startForeground()` with type `location` throws `SecurityException` when the app
+ * has only while-in-use location permission (no `ACCESS_BACKGROUND_LOCATION`) and is not in a state that grants
+ * while-in-use access. The main such state is a visible activity; Android also grants it for 10 s after an activity of
+ * the app was started or finished. A boot, alarm or heartbeat start from the background therefore fails.
+ *
+ * [refusalReason] returns a reason (start refused) only when all of these are true:
+ * - API level ≥ 34;
+ * - `ACCESS_BACKGROUND_LOCATION` is not granted;
+ * - the process importance (`ActivityManager.getMyMemoryState`) is worse than `IMPORTANCE_VISIBLE`. An importance of
+ *   `IMPORTANCE_FOREGROUND_SERVICE` (another foreground service of the app runs, for example a companion plugin's) is
+ *   treated as possibly visible, because the activity state cannot be told from it;
+ * - the activity that `CurrentActivityTracker` remembers (the plugin seeds it with its activity at load) is not in the
+ *   `STARTED` lifecycle state or later;
+ * - no activity is started according to the lifecycle callbacks registered by this object (they see only events after
+ *   this object was created), and no activity was started, stopped or destroyed during the last [GRACE_MS] ms. This
+ *   covers Android's 10 s grace period with a margin.
+ *
+ * When the check cannot be evaluated (an exception), it does not refuse. Every uncertain case lets the start proceed:
+ * a start that Android then refuses is still handled by the service (`onServiceStartFailed`).
+ *
+ * Other Android exemptions (a notification tap, a PendingIntent from a visible app) are not modelled; a start in such a
+ * state without a visible activity is refused here.
+ */
+internal class WhileInUseStartCheck(context: Context, private val clock: Clock) {
+    private val context: Context = context.applicationContext ?: context
+
+    @Volatile
+    private var startedActivities = 0
+
+    /** `clock.elapsedRealtime()` of the last activity start, stop or destroy seen; null if none was seen. */
+    @Volatile
+    private var lastActivityChangeAt: Long? = null
+
+    private val callbacks = object : ActivityLifecycleAdapter() {
+        override fun onActivityStarted(activity: Activity) {
+            startedActivities++
+            lastActivityChangeAt = clock.elapsedRealtime()
+        }
+
+        override fun onActivityStopped(activity: Activity) {
+            startedActivities = (startedActivities - 1).coerceAtLeast(0)
+            lastActivityChangeAt = clock.elapsedRealtime()
+        }
+
+        override fun onActivityDestroyed(activity: Activity) {
+            lastActivityChangeAt = clock.elapsedRealtime()
+        }
+    }
+
+    init {
+        (this.context as? Application)?.registerActivityLifecycleCallbacks(callbacks)
+    }
+
+    /** Why a location foreground service started now would be refused, or null if it may be allowed. */
+    fun refusalReason(): String? {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.UPSIDE_DOWN_CAKE) return null
+        return try {
+            when {
+                granted(Manifest.permission.ACCESS_BACKGROUND_LOCATION) -> null
+                processMayBeVisible() -> null
+                rememberedActivityStarted() -> null
+                startedActivities > 0 -> null
+                activityChangedRecently() -> null
+                else -> "Android 14+: no visible activity and no background location permission"
+            }
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    private fun granted(permission: String): Boolean =
+        ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED
+
+    private fun processMayBeVisible(): Boolean {
+        val info = ActivityManager.RunningAppProcessInfo()
+        ActivityManager.getMyMemoryState(info)
+        return info.importance <= ActivityManager.RunningAppProcessInfo.IMPORTANCE_VISIBLE
+    }
+
+    private fun rememberedActivityStarted(): Boolean {
+        val owner = CurrentActivityTracker.attach(context).current() as? LifecycleOwner ?: return false
+        return owner.lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)
+    }
+
+    private fun activityChangedRecently(): Boolean {
+        val at = lastActivityChangeAt ?: return false
+        val age = clock.elapsedRealtime() - at
+        return age in 0 until GRACE_MS
+    }
+
+    companion object {
+        /** Android grants while-in-use access for 10 s after an activity start or finish; 15 s adds a margin. */
+        const val GRACE_MS = 15_000L
+    }
+}

package/android/src/main/java/com/brickssoft/locationtracking/settings/DefaultDeviceSettings.kt

@@ -0,0 +1,79 @@
+package com.brickssoft.locationtracking.settings
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+import android.provider.Settings
+import com.brickssoft.locationtracking.core.Logger
+import com.brickssoft.locationtracking.model.PowerManagerInfo
+
+/**
+ * Opens system and OEM settings screens. Screens start from the given Activity when it is usable, otherwise
+ * from the application context with `FLAG_ACTIVITY_NEW_TASK`. Any failure to start (ActivityNotFoundException,
+ * SecurityException, ...) returns false.
+ *
+ * The battery-optimization screen is the settings LIST (`ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS`); the
+ * plugin never uses `ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS`.
+ */
+class DefaultDeviceSettings(context: Context) : DeviceSettings {
+    private val appContext: Context = context.applicationContext ?: context
+
+    override fun openBatteryOptimizationSettings(activity: Activity?): Boolean =
+        launch(Intent(Settings.ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS), activity, "battery-optimization settings")
+
+    override fun powerManagerInfo(): PowerManagerInfo {
+        val manufacturer = manufacturer()
+        return PowerManagerInfo(
+            manufacturer = manufacturer,
+            available = OemPowerManagers.launchableIntents(appContext, manufacturer).isNotEmpty(),
+        )
+    }
+
+    override fun openPowerManagerSettings(activity: Activity?): Boolean {
+        val manufacturer = manufacturer()
+        val intents = OemPowerManagers.launchableIntents(appContext, manufacturer)
+        if (intents.isEmpty()) {
+            Logger.i(TAG, "no power-manager screen found for manufacturer '$manufacturer'")
+            return false
+        }
+        // Several candidates can resolve; fall through to the next one if a screen refuses to start.
+        return intents.any { intent -> launch(intent, activity, "power-manager screen ${describe(intent)}") }
+    }
+
+    override fun openLocationSettings(activity: Activity?): Boolean =
+        launch(Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS), activity, "location settings")
+
+    override fun openAppSettings(activity: Activity?): Boolean = launch(
+        Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS, Uri.fromParts("package", appContext.packageName, null)),
+        activity,
+        "app settings",
+    )
+
+    private fun launch(intent: Intent, activity: Activity?, what: String): Boolean {
+        val host = activity?.takeIf { !it.isFinishing && !it.isDestroyed }
+        return try {
+            if (host != null) {
+                host.startActivity(intent)
+            } else {
+                appContext.startActivity(Intent(intent).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK))
+            }
+            Logger.d(TAG, "opened $what")
+            true
+        } catch (e: RuntimeException) {
+            // ActivityNotFoundException, SecurityException, or an OEM ROM rejecting the intent
+            Logger.w(TAG, "cannot open $what: ${e.javaClass.simpleName}", e)
+            false
+        }
+    }
+
+    private fun manufacturer(): String = Build.MANUFACTURER.orEmpty()
+
+    private fun describe(intent: Intent): String =
+        intent.component?.flattenToShortString() ?: "${intent.`package`}/${intent.action}"
+
+    private companion object {
+        const val TAG = "LT.DeviceSettings"
+    }
+}

package/android/src/main/java/com/brickssoft/locationtracking/settings/DeviceSettings.kt

@@ -0,0 +1,21 @@
+package com.brickssoft.locationtracking.settings
+
+import android.app.Activity
+import com.brickssoft.locationtracking.model.PowerManagerInfo
+
+/**
+ * Opens system and OEM settings screens. Every `open*` returns false instead of throwing when the screen
+ * cannot be opened (ActivityNotFoundException, SecurityException).
+ */
+interface DeviceSettings {
+    /** Opens the battery-optimization list (`ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS`). */
+    fun openBatteryOptimizationSettings(activity: Activity?): Boolean
+
+    fun powerManagerInfo(): PowerManagerInfo
+
+    fun openPowerManagerSettings(activity: Activity?): Boolean
+
+    fun openLocationSettings(activity: Activity?): Boolean
+
+    fun openAppSettings(activity: Activity?): Boolean
+}

package/android/src/main/java/com/brickssoft/locationtracking/settings/OemPowerManagers.kt

@@ -0,0 +1,198 @@
+package com.brickssoft.locationtracking.settings
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import com.brickssoft.locationtracking.core.Logger
+import java.util.Locale
+
+/**
+ * Known OEM power-manager / auto-start / background-activity screens, picked by `Build.MANUFACTURER`
+ * (case-insensitive). Every package listed here is declared in the plugin manifest's `<queries>`, so
+ * `resolveActivity` can see it on Android 11+. All entries are best-effort: OEMs move these screens between
+ * ROM versions, which is why each maker has several candidates, tried in order.
+ */
+internal object OemPowerManagers {
+    private const val TAG = "LT.DeviceSettings"
+
+    /** Value put into an extra of an [OemScreen] intent. */
+    enum class ExtraValue { PACKAGE_NAME, APP_LABEL }
+
+    /** One candidate screen: an explicit component (or an action scoped to [packageName]). */
+    data class OemScreen(
+        val packageName: String,
+        val className: String?,
+        val action: String? = null,
+        val dataUri: String? = null,
+        val extras: Map<String, ExtraValue> = emptyMap(),
+    ) {
+        fun toIntent(context: Context): Intent {
+            val intent = if (className != null) {
+                Intent().setComponent(ComponentName(packageName, className))
+            } else {
+                Intent().setPackage(packageName)
+            }
+            action?.let { intent.setAction(it) }
+            dataUri?.let { intent.setData(Uri.parse(it)) }
+            extras.forEach { (key, value) ->
+                when (value) {
+                    ExtraValue.PACKAGE_NAME -> intent.putExtra(key, context.packageName)
+                    ExtraValue.APP_LABEL -> intent.putExtra(key, appLabel(context))
+                }
+            }
+            return intent
+        }
+    }
+
+    private class Family(val manufacturers: Set<String>, val screens: List<OemScreen>)
+
+    private const val HUAWEI = "com.huawei.systemmanager"
+    private const val HONOR = "com.hihonor.systemmanager"
+    private const val MIUI_SECURITY = "com.miui.securitycenter"
+    private const val MIUI_POWER = "com.miui.powerkeeper"
+    private const val COLOROS_SAFE = "com.coloros.safecenter"
+    private const val OPPO_SAFE = "com.oppo.safe"
+    private const val COLOROS_GUARD = "com.coloros.oppoguardelf"
+    private const val IQOO = "com.iqoo.secure"
+    private const val VIVO_PERMISSIONS = "com.vivo.permissionmanager"
+    private const val SAMSUNG_LOOL = "com.samsung.android.lool"
+    private const val SAMSUNG_SM = "com.samsung.android.sm"
+    private const val ONEPLUS = "com.oneplus.security"
+    private const val ASUS = "com.asus.mobilemanager"
+    private const val LETV = "com.letv.android.letvsafe"
+    private const val HTC = "com.htc.pitroad"
+    private const val MEIZU = "com.meizu.safe"
+    private const val NOKIA = "com.evenwell.powersaving.g3"
+
+    private val huaweiScreens = listOf(
+        OemScreen(HUAWEI, "$HUAWEI.startupmgr.ui.StartupNormalAppListActivity"),
+        OemScreen(HUAWEI, "$HUAWEI.optimize.process.ProtectActivity"),
+        OemScreen(HUAWEI, "$HUAWEI.appcontrol.activity.StartupAppControlActivity"),
+    )
+
+    private val honorScreens = listOf(
+        OemScreen(HONOR, "$HONOR.startupmgr.ui.StartupNormalAppListActivity"),
+        OemScreen(HONOR, "$HONOR.optimize.process.ProtectActivity"),
+        OemScreen(HONOR, "$HONOR.appcontrol.activity.StartupAppControlActivity"),
+    )
+
+    private val xiaomiScreens = listOf(
+        OemScreen(MIUI_SECURITY, "com.miui.permcenter.autostart.AutoStartManagementActivity"),
+        OemScreen(
+            MIUI_POWER,
+            "$MIUI_POWER.ui.HiddenAppsConfigActivity",
+            extras = mapOf("package_name" to ExtraValue.PACKAGE_NAME, "package_label" to ExtraValue.APP_LABEL),
+        ),
+    )
+
+    private val colorOsScreens = listOf(
+        OemScreen(COLOROS_SAFE, "$COLOROS_SAFE.permission.startup.StartupAppListActivity"),
+        OemScreen(COLOROS_SAFE, "$COLOROS_SAFE.startupapp.StartupAppListActivity"),
+        OemScreen(OPPO_SAFE, "$OPPO_SAFE.permission.startup.StartupAppListActivity"),
+        OemScreen(COLOROS_GUARD, "com.coloros.powermanager.fuelgaue.PowerUsageModelActivity"),
+        OemScreen(COLOROS_GUARD, "com.coloros.powermanager.fuelgaue.PowerSaverModeActivity"),
+    )
+
+    private val vivoScreens = listOf(
+        OemScreen(IQOO, "$IQOO.ui.phoneoptimize.AddWhiteListActivity"),
+        OemScreen(IQOO, "$IQOO.ui.phoneoptimize.BgStartUpManager"),
+        OemScreen(VIVO_PERMISSIONS, "$VIVO_PERMISSIONS.activity.BgStartUpManagerActivity"),
+    )
+
+    private val samsungScreens = listOf(
+        OemScreen(SAMSUNG_LOOL, "com.samsung.android.sm.ui.battery.BatteryActivity"),
+        OemScreen(SAMSUNG_LOOL, "com.samsung.android.sm.battery.ui.BatteryActivity"),
+        OemScreen(SAMSUNG_SM, "com.samsung.android.sm.ui.battery.BatteryActivity"),
+    )
+
+    private val onePlusScreens = listOf(
+        OemScreen(ONEPLUS, "$ONEPLUS.chainlaunch.view.ChainLaunchAppListActivity"),
+    )
+
+    private val asusScreens = listOf(
+        OemScreen(ASUS, "$ASUS.entry.FunctionActivity", dataUri = "mobilemanager://function/entry/AutoStart"),
+        OemScreen(ASUS, "$ASUS.autostart.AutoStartActivity"),
+        OemScreen(ASUS, "$ASUS.MainActivity"),
+    )
+
+    private val letvScreens = listOf(
+        OemScreen(LETV, "$LETV.AutobootManageActivity"),
+        OemScreen(LETV, "$LETV.BackgroundAppManageActivity"),
+    )
+
+    private val htcScreens = listOf(
+        OemScreen(HTC, "$HTC.landingpage.activity.LandingPageActivity"),
+    )
+
+    private val meizuScreens = listOf(
+        OemScreen(MEIZU, "$MEIZU.permission.SmartBGActivity"),
+        OemScreen(
+            MEIZU,
+            className = null,
+            action = "com.meizu.safe.security.SHOW_APPSEC",
+            extras = mapOf("packageName" to ExtraValue.PACKAGE_NAME),
+        ),
+    )
+
+    private val nokiaScreens = listOf(
+        OemScreen(NOKIA, "$NOKIA.exception.PowerSaverExceptionActivity"),
+    )
+
+    private val families = listOf(
+        Family(setOf("huawei"), huaweiScreens),
+        // Honor phones from before the 2020 split still ship Huawei's system manager.
+        Family(setOf("honor"), honorScreens + huaweiScreens),
+        Family(setOf("xiaomi", "redmi", "poco"), xiaomiScreens),
+        Family(setOf("oppo", "realme"), colorOsScreens),
+        // OxygenOS 12+ is built on ColorOS.
+        Family(setOf("oneplus"), onePlusScreens + colorOsScreens),
+        Family(setOf("vivo", "iqoo"), vivoScreens),
+        Family(setOf("samsung"), samsungScreens),
+        Family(setOf("asus"), asusScreens),
+        Family(setOf("letv", "leeco", "lemobile"), letvScreens),
+        Family(setOf("htc"), htcScreens),
+        Family(setOf("meizu"), meizuScreens),
+        Family(setOf("hmd global", "nokia"), nokiaScreens),
+    )
+
+    /** Every package the table can target (all must be in the manifest `<queries>`). */
+    val allPackages: Set<String> get() = families.flatMap { f -> f.screens.map { it.packageName } }.toSet()
+
+    /** Candidate screens for [manufacturer], in the order they should be tried. */
+    fun screensFor(manufacturer: String?): List<OemScreen> {
+        val name = manufacturer?.trim()?.lowercase(Locale.ROOT).orEmpty()
+        if (name.isEmpty()) return emptyList()
+        return families
+            .filter { family -> family.manufacturers.any { name == it || name.startsWith("$it ") } }
+            .flatMap { it.screens }
+            .distinct()
+    }
+
+    /** Intents for [manufacturer]'s screens that resolve to an exported activity we are allowed to start. */
+    fun launchableIntents(context: Context, manufacturer: String?): List<Intent> =
+        screensFor(manufacturer).map { it.toIntent(context) }.filter { isLaunchable(context, it) }
+
+    private fun isLaunchable(context: Context, intent: Intent): Boolean {
+        val info = try {
+            @Suppress("DEPRECATION")
+            // MATCH_DEFAULT_ONLY: startActivity adds CATEGORY_DEFAULT to the package-scoped (implicit) intents.
+            context.packageManager.resolveActivity(intent, PackageManager.MATCH_DEFAULT_ONLY)
+        } catch (e: RuntimeException) {
+            Logger.w(TAG, "resolveActivity failed for $intent", e)
+            null
+        }
+        val activity = info?.activityInfo ?: return false
+        if (!activity.exported) return false
+        val permission = activity.permission ?: return true
+        return context.checkSelfPermission(permission) == PackageManager.PERMISSION_GRANTED
+    }
+
+    private fun appLabel(context: Context): String =
+        try {
+            context.applicationInfo.loadLabel(context.packageManager).toString()
+        } catch (e: RuntimeException) {
+            context.packageName
+        }
+}

package/android/src/main/res/drawable/lt_ic_notification.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Monochrome location pin used as the default foreground-service notification icon. -->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="#FFFFFFFF"
+        android:pathData="M12,2C8.13,2 5,5.13 5,9c0,5.25 7,13 7,13s7,-7.75 7,-13c0,-3.87 -3.13,-7 -7,-7zM12,11.5c-1.38,0 -2.5,-1.12 -2.5,-2.5s1.12,-2.5 2.5,-2.5 2.5,1.12 2.5,2.5 -1.12,2.5 -2.5,2.5z" />
+</vector>

package/android/src/main/res/values/lt_strings.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="lt_notification_text">Location tracking is active</string>
+    <string name="lt_notification_channel_name">Location tracking</string>
+    <string name="lt_resume_notification_text">Location tracking is paused. Tap to resume.</string>
+    <string name="lt_resume_channel_name">Paused location tracking</string>
+    <string name="lt_bg_rationale_title">Allow background location</string>
+    <string name="lt_bg_rationale_message">To keep tracking your location while the app is closed or not in use, select \"Allow all the time\" on the next screen.</string>
+    <string name="lt_bg_rationale_positive">Change to \"Allow all the time\"</string>
+    <string name="lt_bg_rationale_negative">Not now</string>
+</resources>

package/android/src/main/res/xml/lt_file_paths.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths>
+    <files-path name="lt_logs" path="location-tracking-logs/" />
+    <cache-path name="lt_logs_cache" path="location-tracking-logs/" />
+</paths>