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

package/android/src/main/java/com/brickssoft/locationtracking/model/TrackedLocation.kt

@@ -0,0 +1,53 @@
+package com.brickssoft.locationtracking.model
+
+import android.os.Build
+
+/**
+ * A location fix, independent of the backend that produced it.
+ * Optional fields are null when the fix does not carry them.
+ *
+ * @property time fix time, epoch ms.
+ * @property elapsedRealtimeNanos fix time on the elapsed-realtime clock (0 if unknown). Not part of the wire format.
+ * @property provider OS provider name (e.g. "gps", "fused"). Not part of the wire format.
+ */
+data class TrackedLocation(
+    val latitude: Double,
+    val longitude: Double,
+    val accuracy: Float,
+    val altitude: Double? = null,
+    val altitudeAccuracy: Float? = null,
+    val speed: Float? = null,
+    val speedAccuracy: Float? = null,
+    val heading: Float? = null,
+    val headingAccuracy: Float? = null,
+    val time: Long,
+    val elapsedRealtimeNanos: Long = 0,
+    val provider: String? = null,
+    val isMock: Boolean = false,
+) {
+    companion object {
+        /** Converts an Android [android.location.Location], keeping only the fields it actually has. */
+        fun from(l: android.location.Location): TrackedLocation {
+            val api26 = Build.VERSION.SDK_INT >= Build.VERSION_CODES.O
+            return TrackedLocation(
+                latitude = l.latitude,
+                longitude = l.longitude,
+                accuracy = l.accuracy,
+                altitude = if (l.hasAltitude()) l.altitude else null,
+                altitudeAccuracy = if (api26 && l.hasVerticalAccuracy()) l.verticalAccuracyMeters else null,
+                speed = if (l.hasSpeed()) l.speed else null,
+                speedAccuracy = if (api26 && l.hasSpeedAccuracy()) l.speedAccuracyMetersPerSecond else null,
+                heading = if (l.hasBearing()) l.bearing else null,
+                headingAccuracy = if (api26 && l.hasBearingAccuracy()) l.bearingAccuracyDegrees else null,
+                time = l.time,
+                elapsedRealtimeNanos = l.elapsedRealtimeNanos,
+                provider = l.provider,
+                isMock = isMock(l),
+            )
+        }
+
+        @Suppress("DEPRECATION")
+        private fun isMock(l: android.location.Location): Boolean =
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) l.isMock else l.isFromMockProvider
+    }
+}

package/android/src/main/java/com/brickssoft/locationtracking/permission/BackgroundRationaleDialog.kt

@@ -0,0 +1,85 @@
+package com.brickssoft.locationtracking.permission
+
+import android.app.Activity
+import android.app.AlertDialog
+import android.app.Application
+import android.content.Context
+import com.brickssoft.locationtracking.R
+import com.brickssoft.locationtracking.config.BackgroundPermissionRationale
+import com.brickssoft.locationtracking.core.Logger
+
+/**
+ * The rationale AlertDialog shown on API 30+ before background location is requested (which makes
+ * Android open the app's location-permission settings page, where the user picks "Allow all the time").
+ * Texts come from [BackgroundPermissionRationale]; blank or missing values fall back to the
+ * `lt_bg_rationale_*` string resources.
+ */
+internal object BackgroundRationaleDialog {
+    private const val TAG = "LT.Permissions"
+
+    /** Resolved dialog texts. */
+    data class Texts(val title: String, val message: String, val positive: String, val negative: String)
+
+    fun texts(context: Context, rationale: BackgroundPermissionRationale): Texts = Texts(
+        title = rationale.title.orResource(context, R.string.lt_bg_rationale_title),
+        message = rationale.message.orResource(context, R.string.lt_bg_rationale_message),
+        positive = rationale.positiveAction.orResource(context, R.string.lt_bg_rationale_positive),
+        negative = rationale.negativeAction.orResource(context, R.string.lt_bg_rationale_negative),
+    )
+
+    /**
+     * Shows the dialog on [activity] (main thread). [onResult] runs exactly once on the main thread: true for
+     * the positive button; false for the negative button, back/outside cancel, any other dismissal, or the
+     * Activity being destroyed while the dialog is up. Returns false (and never calls [onResult]) if the
+     * dialog could not be shown.
+     */
+    fun show(activity: Activity, rationale: BackgroundPermissionRationale, onResult: (Boolean) -> Unit): Boolean {
+        val application: Application? = activity.application
+        var watcher: Application.ActivityLifecycleCallbacks? = null
+        var resolved = false
+        val resolve = { accepted: Boolean ->
+            if (!resolved) {
+                resolved = true
+                watcher?.let { application?.unregisterActivityLifecycleCallbacks(it) }
+                onResult(accepted)
+            }
+        }
+        return try {
+            val texts = texts(activity, rationale)
+            val dialog = AlertDialog.Builder(activity)
+                .setTitle(texts.title)
+                .setMessage(texts.message)
+                .setPositiveButton(texts.positive) { _, _ -> resolve(true) }
+                .setNegativeButton(texts.negative) { _, _ -> resolve(false) }
+                .setOnCancelListener { resolve(false) }
+                .setOnDismissListener { resolve(false) }
+                .create()
+            // A destroyed Activity drops its windows without dismissing the dialog; never leave the caller hanging.
+            val owner = activity
+            val destroyWatcher = object : ActivityLifecycleAdapter() {
+                override fun onActivityDestroyed(activity: Activity) {
+                    if (activity !== owner) return
+                    resolve(false)
+                    try {
+                        dialog.dismiss()
+                    } catch (e: RuntimeException) {
+                        Logger.d(TAG, "rationale dialog already gone", e)
+                    }
+                }
+            }
+            watcher = destroyWatcher
+            application?.registerActivityLifecycleCallbacks(destroyWatcher)
+            dialog.show()
+            true
+        } catch (e: RuntimeException) {
+            // e.g. WindowManager.BadTokenException when the activity window is gone
+            resolved = true
+            watcher?.let { application?.unregisterActivityLifecycleCallbacks(it) }
+            Logger.w(TAG, "cannot show the background-location rationale dialog", e)
+            false
+        }
+    }
+
+    private fun String?.orResource(context: Context, resId: Int): String =
+        this?.takeIf { it.isNotBlank() } ?: context.getString(resId)
+}

package/android/src/main/java/com/brickssoft/locationtracking/permission/CurrentActivityTracker.kt

@@ -0,0 +1,72 @@
+package com.brickssoft.locationtracking.permission
+
+import android.app.Activity
+import android.app.Application
+import android.content.Context
+import android.os.Bundle
+import java.lang.ref.WeakReference
+
+/** [Application.ActivityLifecycleCallbacks] with no-op defaults. */
+internal abstract class ActivityLifecycleAdapter : Application.ActivityLifecycleCallbacks {
+    override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) = Unit
+
+    override fun onActivityStarted(activity: Activity) = Unit
+
+    override fun onActivityResumed(activity: Activity) = Unit
+
+    override fun onActivityPaused(activity: Activity) = Unit
+
+    override fun onActivityStopped(activity: Activity) = Unit
+
+    override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) = Unit
+
+    override fun onActivityDestroyed(activity: Activity) = Unit
+}
+
+/**
+ * Weakly remembers the most recently created, started or resumed Activity of the app, and the last
+ * [PermissionHost] Activity, so `shouldShowRequestPermissionRationale` can be asked outside a request.
+ * One tracker per Application ([attach]).
+ */
+internal class CurrentActivityTracker : ActivityLifecycleAdapter() {
+    @Volatile
+    private var ref: WeakReference<Activity>? = null
+
+    /** The remembered Activity, or null if there is none or it is finishing or destroyed. */
+    fun current(): Activity? = ref?.get()?.takeIf { it.isUsable() }
+
+    fun remember(activity: Activity) {
+        if (ref?.get() !== activity) ref = WeakReference(activity)
+    }
+
+    override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) = remember(activity)
+
+    override fun onActivityStarted(activity: Activity) = remember(activity)
+
+    override fun onActivityResumed(activity: Activity) = remember(activity)
+
+    override fun onActivityDestroyed(activity: Activity) {
+        if (ref?.get() === activity) ref = null
+    }
+
+    companion object {
+        private var sharedApp: Application? = null
+        private var shared: CurrentActivityTracker? = null
+
+        /** The tracker registered on [context]'s Application (created and registered on first use). */
+        @Synchronized
+        fun attach(context: Context): CurrentActivityTracker {
+            val app = context.applicationContext as? Application ?: context as? Application
+                ?: return CurrentActivityTracker()
+            shared?.let { if (sharedApp === app) return it }
+            val tracker = CurrentActivityTracker()
+            app.registerActivityLifecycleCallbacks(tracker)
+            sharedApp = app
+            shared = tracker
+            return tracker
+        }
+    }
+}
+
+/** True if [this] can still host a dialog or answer permission-rationale queries. */
+internal fun Activity.isUsable(): Boolean = !isFinishing && !isDestroyed

package/android/src/main/java/com/brickssoft/locationtracking/permission/DefaultPermissionManager.kt

@@ -0,0 +1,333 @@
+package com.brickssoft.locationtracking.permission
+
+import android.Manifest
+import android.app.Activity
+import android.content.Context
+import android.content.SharedPreferences
+import android.content.pm.PackageManager
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import androidx.annotation.VisibleForTesting
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
+import com.brickssoft.locationtracking.config.BackgroundPermissionRationale
+import com.brickssoft.locationtracking.core.Constants
+import com.brickssoft.locationtracking.core.Logger
+
+/**
+ * API-level-aware [PermissionManager].
+ *
+ * Status: location is granted if fine or coarse is granted. Permissions that do not exist on the device's
+ * API level are mapped: background location below API 29 equals location; activity recognition below 29
+ * and notifications below 33 are granted. A permission that is not granted is `PROMPT_WITH_RATIONALE` if
+ * Android says a rationale should be shown, `PROMPT` if the plugin never asked for it, otherwise `DENIED`.
+ * "Asked" flags (scoped to the current install, cleared once granted) and the last rationale answer (used
+ * when no Activity is at hand) are kept in the plugin prefs under `perm_` keys.
+ *
+ * Request order: location, notifications, activity recognition, background location — one alias group at
+ * a time, skipping granted and not-applicable types. Background location is requested only once foreground
+ * location is granted: directly on API 29, after [BackgroundRationaleDialog] on API 30+. Overlapping
+ * `request` calls run one after another.
+ *
+ * @param activityProvider optional source of the Activity used for `shouldShowRequestPermissionRationale`.
+ *   When it returns null, the app's last started/resumed Activity or the last [PermissionHost] Activity is used.
+ */
+class DefaultPermissionManager @VisibleForTesting internal constructor(
+    context: Context,
+    private val activityProvider: () -> Activity?,
+    private val sdkInt: Int,
+) : PermissionManager {
+    constructor(context: Context, activityProvider: () -> Activity? = { null }) :
+        this(context, activityProvider, Build.VERSION.SDK_INT)
+
+    private val appContext: Context = context.applicationContext ?: context
+    private val prefs: SharedPreferences by lazy {
+        appContext.getSharedPreferences(Constants.PREFS_NAME, Context.MODE_PRIVATE)
+    }
+
+    /** Identifies this install, so "asked" flags restored from a backup onto a new install are ignored. */
+    private val installMarker: Long by lazy {
+        try {
+            @Suppress("DEPRECATION")
+            appContext.packageManager.getPackageInfo(appContext.packageName, 0).firstInstallTime
+        } catch (e: Exception) {
+            Logger.w(TAG, "cannot read the install time", e)
+            0L
+        }
+    }
+    private val activityTracker = CurrentActivityTracker.attach(appContext)
+    private val mainHandler by lazy { Handler(Looper.getMainLooper()) }
+
+    // Request flows; main thread only.
+    private var activeFlow: RequestFlow? = null
+    private val queuedFlows = ArrayDeque<RequestFlow>()
+
+    override fun status(): Map<PermissionType, PermissionState> {
+        val activity = currentActivity()
+        return PermissionType.entries.associateWith { stateOf(it, activity) }
+    }
+
+    override fun hasForegroundLocation(): Boolean =
+        isGranted(Manifest.permission.ACCESS_FINE_LOCATION) || isGranted(Manifest.permission.ACCESS_COARSE_LOCATION)
+
+    override fun hasBackgroundLocation(): Boolean = if (sdkInt < Build.VERSION_CODES.Q) {
+        hasForegroundLocation()
+    } else {
+        hasForegroundLocation() && isGranted(Manifest.permission.ACCESS_BACKGROUND_LOCATION)
+    }
+
+    override fun hasActivityRecognition(): Boolean =
+        sdkInt < Build.VERSION_CODES.Q || isGranted(Manifest.permission.ACTIVITY_RECOGNITION)
+
+    override fun hasNotifications(): Boolean =
+        sdkInt < Build.VERSION_CODES.TIRAMISU || isGranted(Manifest.permission.POST_NOTIFICATIONS)
+
+    override fun request(
+        host: PermissionHost,
+        types: List<PermissionType>,
+        rationale: BackgroundPermissionRationale,
+        onDone: (Map<PermissionType, PermissionState>) -> Unit,
+    ) {
+        if (!isMainThread()) {
+            mainHandler.post { request(host, types, rationale, onDone) }
+            return
+        }
+        hostActivity(host)?.let { activityTracker.remember(it) }
+        val flow = RequestFlow(host, types.toSet(), rationale, onDone)
+        if (activeFlow != null) {
+            Logger.d(TAG, "a permission request is in progress; queued ${types.map { it.alias }}")
+            queuedFlows.addLast(flow)
+            return
+        }
+        activeFlow = flow
+        flow.next()
+    }
+
+    // ---- status
+
+    private fun stateOf(type: PermissionType, activity: Activity?): PermissionState = when {
+        type == PermissionType.BACKGROUND_LOCATION && sdkInt < Build.VERSION_CODES.Q ->
+            stateOf(PermissionType.LOCATION, activity)
+        isGranted(type) -> PermissionState.GRANTED.also { forget(type) }
+        activity != null && shouldShowRationale(type, activity) -> PermissionState.PROMPT_WITH_RATIONALE
+        !wasAsked(type) -> PermissionState.PROMPT
+        activity == null && lastRationale(type) -> PermissionState.PROMPT_WITH_RATIONALE
+        else -> PermissionState.DENIED
+    }
+
+    private fun isGranted(type: PermissionType): Boolean = when (type) {
+        PermissionType.LOCATION -> hasForegroundLocation()
+        PermissionType.BACKGROUND_LOCATION -> hasBackgroundLocation()
+        PermissionType.ACTIVITY_RECOGNITION -> hasActivityRecognition()
+        PermissionType.NOTIFICATIONS -> hasNotifications()
+    }
+
+    /** True if [type] is a runtime permission on this API level (otherwise it is implied or not needed). */
+    private fun isRuntime(type: PermissionType): Boolean = when (type) {
+        PermissionType.LOCATION -> true
+        PermissionType.BACKGROUND_LOCATION, PermissionType.ACTIVITY_RECOGNITION -> sdkInt >= Build.VERSION_CODES.Q
+        PermissionType.NOTIFICATIONS -> sdkInt >= Build.VERSION_CODES.TIRAMISU
+    }
+
+    private fun isGranted(permission: String): Boolean =
+        ContextCompat.checkSelfPermission(appContext, permission) == PackageManager.PERMISSION_GRANTED
+
+    private fun shouldShowRationale(type: PermissionType, activity: Activity): Boolean =
+        isRuntime(type) && androidPermissions(type).any { permission ->
+            try {
+                ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)
+            } catch (e: RuntimeException) {
+                Logger.w(TAG, "shouldShowRequestPermissionRationale($permission) failed", e)
+                false
+            }
+        }
+
+    private fun currentActivity(): Activity? =
+        activityProvider()?.takeIf { it.isUsable() } ?: activityTracker.current()
+
+    private fun hostActivity(host: PermissionHost): Activity? =
+        try {
+            host.activity?.takeIf { it.isUsable() }
+        } catch (e: RuntimeException) {
+            Logger.w(TAG, "permission host has no activity", e)
+            null
+        }
+
+    // ---- persisted flags (plugin prefs, `perm_` keys only)
+
+    private fun wasAsked(type: PermissionType): Boolean =
+        try {
+            prefs.getLong(askedKey(type), NEVER) == installMarker
+        } catch (e: ClassCastException) {
+            false
+        }
+
+    private fun lastRationale(type: PermissionType): Boolean =
+        try {
+            prefs.getBoolean(rationaleKey(type), false)
+        } catch (e: ClassCastException) {
+            false
+        }
+
+    private fun markAsked(type: PermissionType) {
+        prefs.edit().putLong(askedKey(type), installMarker).apply()
+    }
+
+    /** Drops [type]'s flags: once granted, a later revocation or auto-reset starts from "never asked". */
+    private fun forget(type: PermissionType) {
+        if (prefs.contains(askedKey(type)) || prefs.contains(rationaleKey(type))) {
+            prefs.edit().remove(askedKey(type)).remove(rationaleKey(type)).apply()
+        }
+    }
+
+    /** After a request for [type] finished: remember whether Android would show a rationale now. */
+    private fun recordResult(type: PermissionType, activity: Activity?) {
+        if (activity == null || isGranted(type)) return
+        prefs.edit().putBoolean(rationaleKey(type), shouldShowRationale(type, activity)).apply()
+    }
+
+    // ---- request flow
+
+    private fun onFlowFinished(flow: RequestFlow) {
+        if (activeFlow !== flow) return
+        val next = queuedFlows.removeFirstOrNull()
+        activeFlow = next
+        if (next != null) mainHandler.post { next.next() }
+    }
+
+    /** One `request()` call: walks [REQUEST_ORDER] and calls [onDone] exactly once, on the main thread. */
+    private inner class RequestFlow(
+        private val host: PermissionHost,
+        private val types: Set<PermissionType>,
+        private val rationale: BackgroundPermissionRationale,
+        private val onDone: (Map<PermissionType, PermissionState>) -> Unit,
+    ) {
+        private val pending = ArrayDeque(REQUEST_ORDER.filter { it in types })
+        private var finished = false
+
+        /** Runs steps until one waits for the user (it calls [next] again later) or none is left. */
+        fun next() {
+            while (!finished) {
+                val type = pending.removeFirstOrNull() ?: return finish()
+                val waiting = if (type == PermissionType.BACKGROUND_LOCATION) requestBackground() else requestPlain(type)
+                if (waiting) return
+            }
+        }
+
+        private fun finish() {
+            if (finished) return
+            finished = true
+            try {
+                onDone(status())
+            } finally {
+                onFlowFinished(this)
+            }
+        }
+
+        /** Location, notifications, activity recognition. Returns true if a request is in flight. */
+        private fun requestPlain(type: PermissionType): Boolean {
+            if (!isRuntime(type)) {
+                Logger.d(TAG, "${type.alias}: not a runtime permission on API $sdkInt, skipped")
+                return false
+            }
+            if (isGranted(type)) return false
+            return ask(type)
+        }
+
+        private fun requestBackground(): Boolean {
+            val type = PermissionType.BACKGROUND_LOCATION
+            if (!isRuntime(type)) {
+                Logger.d(TAG, "backgroundLocation: implied by location on API $sdkInt, skipped")
+                return false
+            }
+            if (isGranted(type)) return false
+            if (!hasForegroundLocation()) {
+                Logger.i(TAG, "backgroundLocation: skipped, foreground location is not granted")
+                return false
+            }
+            if (sdkInt < Build.VERSION_CODES.R) return ask(type)
+
+            val activity = hostActivity(host) ?: currentActivity()
+            if (activity == null) {
+                Logger.w(TAG, "backgroundLocation: skipped, no activity to show the rationale dialog")
+                return false
+            }
+            return BackgroundRationaleDialog.show(activity, rationale) { accepted ->
+                onMain {
+                    if (accepted) {
+                        ask(type)
+                    } else {
+                        Logger.i(TAG, "backgroundLocation: rationale declined")
+                        next()
+                    }
+                }
+            }
+        }
+
+        /**
+         * Requests [type]'s alias through the host; always returns true, the host callback continues the flow.
+         * The continuation is posted when the host calls back synchronously or off the main thread, so the rest
+         * of the flow never runs inside `requestAliases`. A host that throws leaves [type] "never asked".
+         */
+        private fun ask(type: PermissionType): Boolean {
+            val askedBefore = wasAsked(type)
+            markAsked(type)
+            var continued = false
+            var insideHostCall = true
+            val continueFlow = {
+                if (!continued) {
+                    continued = true
+                    recordResult(type, hostActivity(host) ?: currentActivity())
+                    next()
+                }
+            }
+            try {
+                host.requestAliases(listOf(type.alias)) {
+                    if (insideHostCall || !isMainThread()) mainHandler.post(continueFlow) else continueFlow()
+                }
+            } catch (e: RuntimeException) {
+                Logger.w(TAG, "requesting ${type.alias} failed", e)
+                if (!askedBefore) prefs.edit().remove(askedKey(type)).apply()
+                if (!continued) {
+                    continued = true
+                    mainHandler.post { next() }
+                }
+            } finally {
+                insideHostCall = false
+            }
+            return true
+        }
+    }
+
+    private fun isMainThread(): Boolean = Looper.myLooper() == Looper.getMainLooper()
+
+    private fun onMain(block: () -> Unit) {
+        if (isMainThread()) block() else mainHandler.post(block)
+    }
+
+    private companion object {
+        const val TAG = "LT.Permissions"
+        const val KEY_PREFIX = "perm_"
+        const val NEVER = -1L
+
+        val REQUEST_ORDER = listOf(
+            PermissionType.LOCATION,
+            PermissionType.NOTIFICATIONS,
+            PermissionType.ACTIVITY_RECOGNITION,
+            PermissionType.BACKGROUND_LOCATION,
+        )
+
+        fun askedKey(type: PermissionType) = "${KEY_PREFIX}asked_${type.alias}"
+
+        fun rationaleKey(type: PermissionType) = "${KEY_PREFIX}rationale_${type.alias}"
+
+        fun androidPermissions(type: PermissionType): List<String> = when (type) {
+            PermissionType.LOCATION ->
+                listOf(Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION)
+            PermissionType.BACKGROUND_LOCATION -> listOf(Manifest.permission.ACCESS_BACKGROUND_LOCATION)
+            PermissionType.ACTIVITY_RECOGNITION -> listOf(Manifest.permission.ACTIVITY_RECOGNITION)
+            PermissionType.NOTIFICATIONS -> listOf(Manifest.permission.POST_NOTIFICATIONS)
+        }
+    }
+}

package/android/src/main/java/com/brickssoft/locationtracking/permission/PermissionManager.kt

@@ -0,0 +1,54 @@
+package com.brickssoft.locationtracking.permission
+
+import android.app.Activity
+import com.brickssoft.locationtracking.config.BackgroundPermissionRationale
+
+/** JS `PermissionType`; [alias] is the `@CapacitorPlugin` permission alias. */
+enum class PermissionType(val alias: String) {
+    LOCATION("location"),
+    BACKGROUND_LOCATION("backgroundLocation"),
+    ACTIVITY_RECOGNITION("activityRecognition"),
+    NOTIFICATIONS("notifications"),
+    ;
+
+    companion object {
+        fun fromAlias(alias: String?): PermissionType? = entries.firstOrNull { it.alias == alias }
+    }
+}
+
+/** Capacitor `PermissionState`; [js] is the JS value. */
+enum class PermissionState(val js: String) {
+    GRANTED("granted"),
+    DENIED("denied"),
+    PROMPT("prompt"),
+    PROMPT_WITH_RATIONALE("prompt-with-rationale"),
+}
+
+/** Implemented by the bridge (U2) on top of the Capacitor plugin. */
+interface PermissionHost {
+    val activity: Activity?
+
+    /** Wraps `requestPermissionForAliases` + `@PermissionCallback`; [onDone] runs on the main thread. */
+    fun requestAliases(aliases: List<String>, onDone: () -> Unit)
+}
+
+interface PermissionManager {
+    /** API-level aware: background < 29 = foreground; activity recognition < 29 granted; notifications < 33 granted. */
+    fun status(): Map<PermissionType, PermissionState>
+
+    fun hasForegroundLocation(): Boolean
+
+    fun hasBackgroundLocation(): Boolean
+
+    fun hasActivityRecognition(): Boolean
+
+    fun hasNotifications(): Boolean
+
+    /** Main thread. Background location is always requested last. */
+    fun request(
+        host: PermissionHost,
+        types: List<PermissionType>,
+        rationale: BackgroundPermissionRationale,
+        onDone: (Map<PermissionType, PermissionState>) -> Unit,
+    )
+}