chore: release v4.1.5

#1038

.github/workflows/build-aab.yml

@@ -0,0 +1,130 @@
+name: build-aab
+
+permissions:
+  contents: read
+
+on:
+  workflow_dispatch:
+    inputs:
+      build_type:
+        type: choice
+        description: "Build type"
+        required: true
+        default: release
+        options:
+          - release
+      flavor:
+        type: choice
+        description: "Product flavor"
+        required: true
+        default: google
+        options:
+          - google
+    secrets:
+      SIGNING_KEY_ALIAS:
+        required: false
+      SIGNING_KEY_PASSWORD:
+        required: false
+      SIGNING_STORE_PASSWORD:
+        required: false
+      SERVICE_ACCOUNT_JSON:
+        required: false
+      KEYSTORE:
+        required: false
+  workflow_call:
+    inputs:
+      build_type:
+        type: string
+        description: "Build type"
+        required: true
+        default: release
+      flavor:
+        type: string
+        description: "Product flavor"
+        required: false
+        default: google
+    secrets:
+      SIGNING_KEY_ALIAS:
+        required: false
+      SIGNING_KEY_PASSWORD:
+        required: false
+      SIGNING_STORE_PASSWORD:
+        required: false
+      SERVICE_ACCOUNT_JSON:
+        required: false
+      KEYSTORE:
+        required: false
+
+env:
+  UPLOAD_DIR_ANDROID: android_artifacts
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    env:
+      SIGNING_KEY_ALIAS: ${{ secrets.SIGNING_KEY_ALIAS }}
+      SIGNING_KEY_PASSWORD: ${{ secrets.SIGNING_KEY_PASSWORD }}
+      SIGNING_STORE_PASSWORD: ${{ secrets.SIGNING_STORE_PASSWORD }}
+      KEY_STORE_FILE: 'android_keystore.jks'
+      KEY_STORE_LOCATION: ${{ github.workspace }}/app/keystore/
+    outputs:
+      UPLOAD_DIR_ANDROID: ${{ env.UPLOAD_DIR_ANDROID }}
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v5
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+          cache: gradle
+
+      - name: Grant execute permission for gradlew
+        run: chmod +x gradlew
+
+      - name: Decode Keystore
+        id: decode_keystore
+        uses: timheuer/base64-to-file@v1.2
+        with:
+          fileName: ${{ env.KEY_STORE_FILE }}
+          fileDir: ${{ env.KEY_STORE_LOCATION }}
+          encodedString: ${{ secrets.KEYSTORE }}
+
+      - name: Create keystore path env var
+        if: ${{ inputs.build_type != 'debug' }}
+        run: |
+          store_path=${{ env.KEY_STORE_LOCATION }}${{ env.KEY_STORE_FILE }}
+          echo "KEY_STORE_PATH=$store_path" >> $GITHUB_ENV
+
+      - name: Build AAB (noSplits=true)
+        run: |
+          flavor=${{ inputs.flavor }}
+          build_type=${{ inputs.build_type }}
+          case $build_type in
+            "release")
+              ./gradlew :app:bundle${flavor^}Release \
+                -PnoSplits=true \
+                --info
+              ;;
+          esac
+
+      - name: Get release AAB path
+        id: aab-path
+        run: |
+          AAB_PATH=$(find app/build/outputs/bundle -iname "*google*release*.aab" -type f | head -1)
+          if [ -z "$AAB_PATH" ]; then
+            echo "Error: AAB not found!" >&2
+            exit 1
+          fi
+          echo "Found AAB: $AAB_PATH"
+          echo "path=$AAB_PATH" >> $GITHUB_OUTPUT
+
+      - name: Upload AAB Artifact
+        uses: actions/upload-artifact@v5
+        with:
+          name: google-play-aab
+          path: ${{ steps.aab-path.outputs.path }}
+          retention-days: 7
+          if-no-files-found: error

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/service/ServiceManager.kt

@@ -21,6 +21,7 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeoutOrNull
 import timber.log.Timber
 
 class ServiceManager
@@ -137,17 +138,25 @@ constructor(
 
     suspend fun startTunnelService(appMode: AppMode) =
         tunnelMutex.withLock {
-            if (_tunnelService.value != null) return@withLock
-            val serviceClass =
-                when (appMode) {
-                    AppMode.VPN,
-                    AppMode.LOCK_DOWN -> VpnForegroundService::class.java
-                    AppMode.KERNEL,
-                    AppMode.PROXY -> TunnelForegroundService::class.java
-                }
-            val intent = Intent(context, serviceClass)
-            context.startForegroundService(intent)
-            context.bindService(intent, tunnelServiceConnection, Context.BIND_AUTO_CREATE)
+            if (_tunnelService.value != null) {
+                Timber.d("Service already exists, waiting for disconnect")
+                withTimeoutOrNull(2000L) { _tunnelService.first { it == null } }
+                    ?: Timber.w("Timeout waiting for existing service to disconnect")
+            }
+            if (_tunnelService.value == null) {
+                val serviceClass =
+                    when (appMode) {
+                        AppMode.VPN,
+                        AppMode.LOCK_DOWN -> VpnForegroundService::class.java
+                        AppMode.KERNEL,
+                        AppMode.PROXY -> TunnelForegroundService::class.java
+                    }
+                val intent = Intent(context, serviceClass)
+                context.startForegroundService(intent)
+                context.bindService(intent, tunnelServiceConnection, Context.BIND_AUTO_CREATE)
+            } else {
+                Timber.e("Service still not null after timeout")
+            }
         }
 
     suspend fun stopTunnelService() =
@@ -157,7 +166,7 @@ constructor(
                 try {
                     context.unbindService(tunnelServiceConnection)
                 } catch (e: Exception) {
-                    Timber.e(e, "Failed to stop Tunnel Service")
+                    Timber.e(e, "Failed to unbind Tunnel Service")
                 }
             }
         }

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/service/autotunnel/AutoTunnelService.kt

@@ -61,6 +61,9 @@ class AutoTunnelService : LifecycleService() {
 
     private val autoTunnelStateFlow = MutableStateFlow(defaultState)
 
+    private var autoTunnelJob: Job? = null
+    private var permissionsJob: Job? = null
+
     class LocalBinder(service: AutoTunnelService) : Binder() {
         private val serviceRef = WeakReference(service)
 
@@ -89,8 +92,10 @@ class AutoTunnelService : LifecycleService() {
 
     fun start() {
         launchWatcherNotification()
-        startAutoTunnelStateJob()
-        startLocationPermissionsNotificationJob()
+        autoTunnelJob?.cancel()
+        autoTunnelJob = startAutoTunnelStateJob()
+        permissionsJob?.cancel()
+        permissionsJob = startLocationPermissionsNotificationJob()
     }
 
     fun stop() {
@@ -99,7 +104,6 @@ class AutoTunnelService : LifecycleService() {
 
     override fun onDestroy() {
         serviceManager.handleAutoTunnelServiceDestroy()
-        networkMonitor.destroy()
         ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
         super.onDestroy()
     }
@@ -130,7 +134,7 @@ class AutoTunnelService : LifecycleService() {
         )
     }
 
-    private fun startAutoTunnelStateJob() =
+    private fun startAutoTunnelStateJob(): Job =
         lifecycleScope.launch(ioDispatcher) {
             val networkFlow =
                 debouncedConnectivityStateFlow

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/state/AutoTunnelState.kt

@@ -59,8 +59,8 @@ data class AutoTunnelState(
         return DoNothing
     }
 
-    private val ethernetActive: Boolean = networkState.activeNetwork is ActiveNetwork.Cellular
-    private val mobileDataActive: Boolean = networkState.activeNetwork is ActiveNetwork.Ethernet
+    private val ethernetActive: Boolean = networkState.activeNetwork is ActiveNetwork.Ethernet
+    private val mobileDataActive: Boolean = networkState.activeNetwork is ActiveNetwork.Cellular
     private val wifiActive: Boolean = networkState.activeNetwork is ActiveNetwork.Wifi
 
     private fun preferredMobileDataTunnel(): TunnelConfig? {

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/settings/lockdown/LockdownSettingsScreen.kt

@@ -1,5 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.settings.lockdown
 
+import android.os.Build
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
@@ -103,12 +104,14 @@ fun LockdownSettingsScreen(viewModel: LockdownViewModel = hiltViewModel()) {
                 trailing = { ThemedSwitch(checked = bypassLan, onClick = { bypassLan = it }) },
                 onClick = { bypassLan = !bypassLan },
             )
-            SurfaceRow(
-                leading = { Icon(Icons.Outlined.DataUsage, contentDescription = null) },
-                title = stringResource(R.string.metered_tunnel),
-                trailing = { ThemedSwitch(checked = metered, onClick = { metered = it }) },
-                onClick = { metered = !metered },
-            )
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                SurfaceRow(
+                    leading = { Icon(Icons.Outlined.DataUsage, contentDescription = null) },
+                    title = stringResource(R.string.metered_tunnel),
+                    trailing = { ThemedSwitch(checked = metered, onClick = { metered = it }) },
+                    onClick = { metered = !metered },
+                )
+            }
             SurfaceRow(
                 leading = {
                     Icon(ImageVector.vectorResource(R.drawable.host), contentDescription = null)

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/tunnels/settings/TunnelSettingsScreen.kt

@@ -1,5 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.settings
 
+import android.os.Build
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
@@ -148,36 +149,38 @@ fun TunnelSettingsScreen(viewModel: TunnelViewModel) {
                 },
                 onClick = { viewModel.setIpv4Preferred(!tunnel.isIpv4Preferred) },
             )
-            SurfaceRow(
-                leading = {
-                    Icon(
-                        Icons.Outlined.DataUsage,
-                        contentDescription = null,
-                        tint =
-                            if (sharedUiState.proxyEnabled) Disabled
-                            else MaterialTheme.colorScheme.onSurface,
-                    )
-                },
-                title = stringResource(R.string.metered_tunnel),
-                enabled = !sharedUiState.proxyEnabled,
-                description =
-                    if (sharedUiState.proxyEnabled) {
-                        {
-                            DescriptionText(
-                                stringResource(R.string.unavailable_in_mode),
-                                disabled = true,
-                            )
-                        }
-                    } else null,
-                trailing = {
-                    ThemedSwitch(
-                        checked = tunnel.isMetered,
-                        onClick = { viewModel.setMetered(it) },
-                        enabled = !sharedUiState.proxyEnabled,
-                    )
-                },
-                onClick = { viewModel.setMetered(!tunnel.isMetered) },
-            )
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                SurfaceRow(
+                    leading = {
+                        Icon(
+                            Icons.Outlined.DataUsage,
+                            contentDescription = null,
+                            tint =
+                                if (sharedUiState.proxyEnabled) Disabled
+                                else MaterialTheme.colorScheme.onSurface,
+                        )
+                    },
+                    title = stringResource(R.string.metered_tunnel),
+                    enabled = !sharedUiState.proxyEnabled,
+                    description =
+                        if (sharedUiState.proxyEnabled) {
+                            {
+                                DescriptionText(
+                                    stringResource(R.string.unavailable_in_mode),
+                                    disabled = true,
+                                )
+                            }
+                        } else null,
+                    trailing = {
+                        ThemedSwitch(
+                            checked = tunnel.isMetered,
+                            onClick = { viewModel.setMetered(it) },
+                            enabled = !sharedUiState.proxyEnabled,
+                        )
+                    },
+                    onClick = { viewModel.setMetered(!tunnel.isMetered) },
+                )
+            }
         }
     }
 }

buildSrc/src/main/kotlin/Constants.kt

@@ -1,6 +1,6 @@
 object Constants {
-	const val VERSION_NAME = "4.1.3"
-    const val VERSION_CODE = 40103
+	const val VERSION_NAME = "4.1.5"
+    const val VERSION_CODE = 40105
     const val TARGET_SDK = 36
     const val MIN_SDK = 26
     const val APP_ID = "com.zaneschepke.wireguardautotunnel"

fastlane/metadata/android/en-US/changelogs/40104.txt

@@ -0,0 +1,3 @@
+What's new:
+- Auto tunnel network detection bugfix
+- Tunnel notification sometimes don't start bugfix

fastlane/metadata/android/en-US/changelogs/40105.txt

@@ -0,0 +1,3 @@
+What's new:
+- Fixes crash on older Android versions where metered tunnel override is unavailable
+- Fixes auto-tunnel network monitor incorrectly detecting VPN changes

fastlane/metadata/android/en-US/full_description.txt

@@ -1,15 +1,13 @@
-- Tunnel Import Methods: Easily add tunnels using .conf files, ZIP archives, manual entry, or QR code scanning.
-- Auto-Tunneling: Automatically activate tunnels based on Wi-Fi SSID, Ethernet connections, or mobile data networks.
-- Split Tunneling: Flexible support for routing specific apps or traffic through the VPN.
-- WireGuard Modes: Full compatibility with WireGuard in both kernel and userspace implementations.
-- AmneziaWG Integration: Userspace mode for AmneziaWG, providing robust censorship evasion.
-- Always-On VPN: Ensures continuous protection with Android's Always-On VPN feature.
-- Quick Controls: Quick Settings tile and home screen shortcuts for easy VPN toggling.
-- Automation Support: Intent-based automation for controlling tunnels.
-- Auto-Restore: Seamlessly restores auto-tunneling and active tunnels after device restarts or app updates.
-- Proxying Options: Built-in HTTP and SOCKS5 proxy support within tunnels.
-- Lockdown Mode: Custom kill switch for maximum leak prevention and security.
-- Dynamic DNS Handling: Detects and updates DNS changes without tunnel restarts.
-- Monitoring Tools: Advanced tunnel monitoring features for tunnel performance monitoring.
-- Android TV Support: Android TV support for secure streaming and browsing.
-- Advanced DNS: DNS over HTTPS support for tunnel endpoint resolutions.
+WG Tunnel is a WireGuard VPN client that strikes the balance between simplicity and robustness, making it the ideal client for casual and power users alike.
+Whether you simply want to automate when you're connected to your VPN or you're a power user with advanced privacy use cases, WG Tunnel has you covered.
+
+- **Auto-Tunneling:** Automatically activate tunnels based on Wi-Fi SSID, Ethernet connections, or mobile data networks.
+- **Split Tunneling:** Flexible support for routing specific apps or traffic through the VPN.
+- **App Modes:** Support for multiple tunnel modes, including standard VPN, kernel, lockdown (custom kill switch), and proxy modes.
+- **AmneziaWG Integration:** Full support for AmneziaWG, providing robust censorship evasion.
+- **Proxying Options:** Built-in HTTP and SOCKS5 proxy support allowing third-party apps to tunnel their traffic.
+- **Quick Controls:** Quick Settings tile and home screen shortcuts for easy toggling actions.
+- **Automation Support:** Intent-based automation for controlling tunnels and auto-tunneling.
+- **Dynamic DNS Handling:** Detects and updates DNS changes without tunnel restarts.
+- **Monitoring Tools:** Advanced tunnel monitoring features for tunnel performance monitoring.
+- **Android TV Support:** Android TV support for nearly all app features.

gradle/libs.versions.toml

@@ -1,7 +1,7 @@
 [versions]
 accompanist = "0.37.3"
 activityCompose = "1.11.0"
-amneziawgAndroid = "2.2.1"
+amneziawgAndroid = "2.2.2"
 androidx-junit = "1.3.0"
 icmp4a = "1.0.0"
 ipaddress = "5.5.1"
@@ -11,18 +11,18 @@ roomdatabasebackup = "1.1.0"
 shizuku = "13.1.5"
 appcompat = "1.7.1"
 coreKtx = "1.17.0"
-datastorePreferences = "1.2.0-beta01"
+datastorePreferences = "1.2.0-rc01"
 desugar_jdk_libs = "2.1.5"
 espressoCore = "3.7.0"
 hiltAndroid = "2.57.2"
 hiltCompiler = "1.3.0"
 hiltNavigationCompose = "1.3.0"
-navigation3 = "1.0.0-beta01"
+navigation3 = "1.0.0-rc01"
 junit = "4.13.2"
 kotlinx-serialization-json = "1.9.0"
 ktorClientCore = "3.3.1"
 lifecycle-runtime-compose = "2.9.4"
-material3 = "1.5.0-alpha07"
+material3 = "1.5.0-alpha08"
 pinLockCompose = "1.0.5"
 qrose = "1.0.1"
 roomVersion = "2.8.3"
@@ -33,19 +33,19 @@ tunnel = "1.4.0"
 androidGradlePlugin = "8.12.3"
 kotlin = "2.2.21"
 ksp = "2.3.0"
-composeBom = "2025.10.01"
+composeBom = "2025.11.00"
 compose = "1.9.4"
 icons = "1.7.8"
 workRuntimeKtxVersion = "2.11.0"
 zxingAndroidEmbedded = "4.3.0"
-coreSplashscreen = "1.0.1"
+coreSplashscreen = "1.2.0"
 gradlePlugins-grgit = "5.3.3"
 reorderable = "3.0.0"
 material = "1.13.0"
 storage = "1.6.0"
 ktfmt = "0.25.0"
 licensee = "1.14.1"
-lifecycleViewmodelNavigation3 = "2.10.0-beta01"
+lifecycleViewmodelNavigation3 = "2.10.0-rc01"
 
 [bundles]
 # Core AndroidX foundations

networkmonitor/src/main/java/com/zaneschepke/networkmonitor/AndroidNetworkMonitor.kt

@@ -1,25 +1,20 @@
 package com.zaneschepke.networkmonitor
 
-import android.Manifest
 import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
-import android.content.pm.PackageManager
 import android.location.LocationManager
 import android.net.ConnectivityManager
-import android.net.ConnectivityManager.NetworkCallback.FLAG_INCLUDE_LOCATION_INFO
 import android.net.Network
 import android.net.NetworkCapabilities
 import android.net.NetworkRequest
 import android.net.wifi.WifiManager
 import android.os.Build
-import androidx.core.content.ContextCompat
 import com.wireguard.android.util.RootShell
 import com.zaneschepke.networkmonitor.AndroidNetworkMonitor.WifiDetectionMethod.*
 import com.zaneschepke.networkmonitor.shizuku.ShizukuShell
 import com.zaneschepke.networkmonitor.util.*
-import java.util.concurrent.ConcurrentHashMap
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.channels.awaitClose
@@ -68,119 +63,107 @@ class AndroidNetworkMonitor(
     private val locationManager =
         appContext.getSystemService(Context.LOCATION_SERVICE) as LocationManager?
 
-    private val activeWifiNetworks =
-        ConcurrentHashMap<String, Pair<Network?, NetworkCapabilities?>>()
-
     private val permissionsChangedFlow = MutableStateFlow(false)
 
     private var permissionReceiver: BroadcastReceiver? = null
     private var locationServicesReceiver: BroadcastReceiver? = null
     private var defaultNetworkCallback: ConnectivityManager.NetworkCallback? = null
-    private var wifiInterfaceCallback: ConnectivityManager.NetworkCallback? = null
-    private var cellularInterfaceCallback: ConnectivityManager.NetworkCallback? = null
-
-    private val isAirplaneModeOn: Boolean
-        get() =
-            android.provider.Settings.Global.getInt(
-                appContext.contentResolver,
-                android.provider.Settings.Global.AIRPLANE_MODE_ON,
-                0,
-            ) != 0
+    private var wifiCallback: ConnectivityManager.NetworkCallback? = null
+    private var cellularCallback: ConnectivityManager.NetworkCallback? = null
+    private var ethernetCallback: ConnectivityManager.NetworkCallback? = null
 
     @OptIn(ExperimentalCoroutinesApi::class)
     private val defaultNetworkFlow: Flow<TransportEvent> =
-        combine(configurationListener.detectionMethod, permissionsChangedFlow) {
-                detectionMethod,
-                changed ->
-                Pair(detectionMethod, changed)
-            }
-            .flatMapLatest { (detectionMethod, _) ->
-                createDefaultNetworkCallbackFlow(detectionMethod)
+        combine(configurationListener.detectionMethod, permissionsChangedFlow) { detectionMethod, _
+                ->
+                detectionMethod
             }
+            .flatMapLatest { detectionMethod ->
+                callbackFlow {
+                    if (
+                        Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && detectionMethod == DEFAULT
+                    ) {
+                        defaultNetworkCallback =
+                            object :
+                                ConnectivityManager.NetworkCallback(FLAG_INCLUDE_LOCATION_INFO) {
+                                override fun onAvailable(network: Network) {
+                                    Timber.d("Default onAvailable: $network")
+                                }
 
-    private fun isAndroidTv(): Boolean =
-        appContext.packageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)
+                                override fun onLost(network: Network) {
+                                    trySend(TransportEvent.Lost(network))
+                                }
 
-    private fun hasRequiredLocationPermissions(): Boolean {
-        val fineLocationGranted =
-            ContextCompat.checkSelfPermission(
-                appContext,
-                Manifest.permission.ACCESS_FINE_LOCATION,
-            ) == PackageManager.PERMISSION_GRANTED
-        val backgroundLocationGranted =
-            if (
-                (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) &&
-                    // exclude Android TV on Q as background location is not required on this
-                    // version
-                    !(Build.VERSION.SDK_INT == Build.VERSION_CODES.Q && isAndroidTv())
-            ) {
-                ContextCompat.checkSelfPermission(
-                    appContext,
-                    Manifest.permission.ACCESS_BACKGROUND_LOCATION,
-                ) == PackageManager.PERMISSION_GRANTED
-            } else {
-                true // No need for ACCESS_BACKGROUND_LOCATION on Android P or Android TV on Q
-            }
-        return fineLocationGranted && backgroundLocationGranted
-    }
-
-    private fun createDefaultNetworkCallbackFlow(
-        detectionMethod: WifiDetectionMethod
-    ): Flow<TransportEvent> = callbackFlow {
-        val onAvailable: (Network) -> Unit = { network ->
-            Timber.d("Network onAvailable: network=$network")
-        }
-
-        val onLost: (Network) -> Unit = { network ->
-            Timber.d("Network onLost: network=$network")
-            trySend(TransportEvent.Lost(network))
-        }
-
-        val onCapabilitiesChanged: (Network, NetworkCapabilities) -> Unit =
-            { network, networkCapabilities ->
-                val isValidated =
-                    networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
-                val hasInternet =
-                    networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
-
-                Timber.d("onCapabilitiesChanged: network=$network, validated: $isValidated")
-
-                if (isValidated && hasInternet) {
-                    val event =
-                        when {
-                            networkCapabilities.hasTransport(
-                                NetworkCapabilities.TRANSPORT_WIFI
-                            ) -> {
-                                activeWifiNetworks[network.toString()] =
-                                    Pair(network, networkCapabilities)
-                                TransportEvent.CapabilitiesChanged(
-                                    network,
-                                    networkCapabilities,
-                                    detectionMethod,
-                                )
+                                override fun onCapabilitiesChanged(
+                                    network: Network,
+                                    caps: NetworkCapabilities,
+                                ) {
+                                    if (caps.hasTransport(NetworkCapabilities.TRANSPORT_VPN)) {
+                                        Timber.d("Ignoring VPN default network change: $network")
+                                        return
+                                    }
+                                    trySend(TransportEvent.CapabilitiesChanged(network, caps))
+                                }
                             }
-                            networkCapabilities.hasTransport(
-                                NetworkCapabilities.TRANSPORT_CELLULAR
-                            ) -> {
-                                activeWifiNetworks.clear()
-                                TransportEvent.CapabilitiesChanged(network, networkCapabilities)
+                    } else {
+                        defaultNetworkCallback =
+                            object : ConnectivityManager.NetworkCallback() {
+                                override fun onAvailable(network: Network) {
+                                    Timber.d("Default onAvailable: $network")
+                                }
+
+                                override fun onLost(network: Network) {
+                                    trySend(TransportEvent.Lost(network))
+                                }
+
+                                override fun onCapabilitiesChanged(
+                                    network: Network,
+                                    caps: NetworkCapabilities,
+                                ) {
+                                    trySend(TransportEvent.CapabilitiesChanged(network, caps))
+                                }
                             }
-                            networkCapabilities.hasTransport(
-                                NetworkCapabilities.TRANSPORT_ETHERNET
-                            ) -> {
-                                activeWifiNetworks.clear()
-                                TransportEvent.CapabilitiesChanged(network, networkCapabilities)
-                            }
-                            else -> TransportEvent.Unknown
-                        }
-                    trySend(event)
-                } else {
-                    activeWifiNetworks.remove(network.toString())
-                    trySend(TransportEvent.Lost(network))
+                    }
+                    connectivityManager?.registerDefaultNetworkCallback(defaultNetworkCallback!!)
+
+                    trySend(
+                        TransportEvent.Permissions(
+                            Permissions(
+                                locationManager?.isLocationServicesEnabled() ?: false,
+                                appContext.hasRequiredLocationPermissions(),
+                            )
+                        )
+                    )
+
+                    awaitClose {
+                        connectivityManager?.unregisterNetworkCallback(defaultNetworkCallback!!)
+                    }
                 }
             }
 
-        val callback: ConnectivityManager.NetworkCallback =
+    @OptIn(ExperimentalCoroutinesApi::class)
+    private val wifiFlow: Flow<TransportEvent> =
+        combine(configurationListener.detectionMethod, permissionsChangedFlow) { detectionMethod, _
+                ->
+                detectionMethod
+            }
+            .flatMapLatest { detectionMethod -> createWifiNetworkCallbackFlow(detectionMethod) }
+
+    private fun createWifiNetworkCallbackFlow(
+        detectionMethod: WifiDetectionMethod
+    ): Flow<TransportEvent> = callbackFlow {
+        val onAvailable: (Network) -> Unit = { network -> Timber.d("WiFi onAvailable: $network") }
+        val onLost: (Network) -> Unit = { network ->
+            Timber.d("WiFi onLost: $network")
+            trySend(TransportEvent.Lost(network))
+        }
+        val onCapabilitiesChanged: (Network, NetworkCapabilities) -> Unit = { network, caps ->
+            if (caps.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
+                trySend(TransportEvent.CapabilitiesChanged(network, caps))
+            }
+        }
+
+        wifiCallback =
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && detectionMethod == DEFAULT) {
                 object : ConnectivityManager.NetworkCallback(FLAG_INCLUDE_LOCATION_INFO) {
                     override fun onAvailable(network: Network) = onAvailable(network)
@@ -189,8 +172,8 @@ class AndroidNetworkMonitor(
 
                     override fun onCapabilitiesChanged(
                         network: Network,
-                        networkCapabilities: NetworkCapabilities,
-                    ) = onCapabilitiesChanged(network, networkCapabilities)
+                        caps: NetworkCapabilities,
+                    ) = onCapabilitiesChanged(network, caps)
                 }
             } else {
                 object : ConnectivityManager.NetworkCallback() {
@@ -200,94 +183,92 @@ class AndroidNetworkMonitor(
 
                     override fun onCapabilitiesChanged(
                         network: Network,
-                        networkCapabilities: NetworkCapabilities,
-                    ) = onCapabilitiesChanged(network, networkCapabilities)
+                        caps: NetworkCapabilities,
+                    ) = onCapabilitiesChanged(network, caps)
                 }
             }
-        defaultNetworkCallback = callback
-
-        connectivityManager?.registerDefaultNetworkCallback(defaultNetworkCallback!!)
-
-        trySend(
-            TransportEvent.Permissions(
-                permissions =
-                    Permissions(
-                        locationManager?.isLocationServicesEnabled() ?: false,
-                        hasRequiredLocationPermissions(),
-                    )
-            )
-        )
-
-        awaitClose {
-            runCatching { connectivityManager?.unregisterNetworkCallback(defaultNetworkCallback!!) }
-                .onFailure { Timber.e(it, "Error unregistering default network callback") }
-        }
-    }
-
-    private val wifiInterfaceFlow: Flow<Boolean> = callbackFlow {
-        val localCallback =
-            object : ConnectivityManager.NetworkCallback() {
-                override fun onAvailable(network: Network) {
-                    Timber.d("Wi-Fi onAvailable: network=$network")
-                    trySend(true)
-                }
-
-                override fun onLost(network: Network) {
-                    Timber.d("Wi-Fi onLost: network=$network")
-                    trySend(false)
-                }
-            }
-        wifiInterfaceCallback = localCallback
 
         val request =
             NetworkRequest.Builder().addTransportType(NetworkCapabilities.TRANSPORT_WIFI).build()
-
-        connectivityManager?.registerNetworkCallback(request, wifiInterfaceCallback!!)
-
-        @Suppress("DEPRECATION") val isWifiInitiallyOn = wifiManager?.isWifiEnabled == true
-        trySend(isWifiInitiallyOn)
+        connectivityManager?.registerNetworkCallback(request, wifiCallback!!)
 
         awaitClose {
-            runCatching { connectivityManager?.unregisterNetworkCallback(wifiInterfaceCallback!!) }
-                .onFailure { Timber.e(it, "Error unregistering Wi-Fi interface callback") }
+            runCatching { connectivityManager?.unregisterNetworkCallback(wifiCallback!!) }
+                .onFailure { Timber.e(it, "Error unregistering WiFi network callback") }
         }
     }
 
-    private val cellularInterfaceFlow: Flow<Boolean> = callbackFlow {
-        val localCallback =
-            object : ConnectivityManager.NetworkCallback() {
-                override fun onAvailable(network: Network) {
-                    Timber.d("Cellular onAvailable: network=$network")
-                    trySend(true)
-                }
+    private val cellularFlow: Flow<TransportEvent> = callbackFlow {
+        val onAvailable: (Network) -> Unit = { network ->
+            Timber.d("Cellular onAvailable: $network")
+        }
+        val onLost: (Network) -> Unit = { network ->
+            Timber.d("Cellular onLost: $network")
+            trySend(TransportEvent.Lost(network))
+        }
+        val onCapabilitiesChanged: (Network, NetworkCapabilities) -> Unit = { network, caps ->
+            Timber.d("Cellular onCapabilitiesChanged: $network")
+            trySend(TransportEvent.CapabilitiesChanged(network, caps))
+        }
 
-                override fun onLost(network: Network) {
-                    Timber.d("Cellular onLost: network=$network")
-                    trySend(false)
-                }
+        cellularCallback =
+            object : ConnectivityManager.NetworkCallback() {
+                override fun onAvailable(network: Network) = onAvailable(network)
+
+                override fun onLost(network: Network) = onLost(network)
+
+                override fun onCapabilitiesChanged(network: Network, caps: NetworkCapabilities) =
+                    onCapabilitiesChanged(network, caps)
             }
-        cellularInterfaceCallback = localCallback
 
         val request =
             NetworkRequest.Builder()
                 .addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
                 .build()
+        connectivityManager?.registerNetworkCallback(request, cellularCallback!!)
 
-        connectivityManager?.registerNetworkCallback(request, cellularInterfaceCallback!!)
-
-        // initial state
-        val initialCellularNetwork = connectivityManager?.activeNetwork
-        val initialCapabilities =
-            connectivityManager?.getNetworkCapabilities(initialCellularNetwork)
-        val isCellularInitiallyOn =
-            initialCapabilities?.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) == true
-        trySend(isCellularInitiallyOn)
+        trySend(TransportEvent.Unknown)
 
         awaitClose {
-            runCatching {
-                    connectivityManager?.unregisterNetworkCallback(cellularInterfaceCallback!!)
-                }
-                .onFailure { Timber.e(it, "Error unregistering cellular interface callback") }
+            runCatching { connectivityManager?.unregisterNetworkCallback(cellularCallback!!) }
+                .onFailure { Timber.e(it, "Error unregistering cellular network callback") }
+        }
+    }
+
+    private val ethernetFlow: Flow<TransportEvent> = callbackFlow {
+        val onAvailable: (Network) -> Unit = { network ->
+            Timber.d("Ethernet onAvailable: $network")
+        }
+        val onLost: (Network) -> Unit = { network ->
+            Timber.d("Ethernet onLost: $network")
+            trySend(TransportEvent.Lost(network))
+        }
+        val onCapabilitiesChanged: (Network, NetworkCapabilities) -> Unit = { network, caps ->
+            Timber.d("Ethernet onCapabilitiesChanged: $network")
+            trySend(TransportEvent.CapabilitiesChanged(network, caps))
+        }
+
+        ethernetCallback =
+            object : ConnectivityManager.NetworkCallback() {
+                override fun onAvailable(network: Network) = onAvailable(network)
+
+                override fun onLost(network: Network) = onLost(network)
+
+                override fun onCapabilitiesChanged(network: Network, caps: NetworkCapabilities) =
+                    onCapabilitiesChanged(network, caps)
+            }
+
+        val request =
+            NetworkRequest.Builder()
+                .addTransportType(NetworkCapabilities.TRANSPORT_ETHERNET)
+                .build()
+        connectivityManager?.registerNetworkCallback(request, ethernetCallback!!)
+
+        trySend(TransportEvent.Unknown)
+
+        awaitClose {
+            runCatching { connectivityManager?.unregisterNetworkCallback(ethernetCallback!!) }
+                .onFailure { Timber.e(it, "Error unregistering ethernet network callback") }
         }
     }
 
@@ -297,7 +278,7 @@ class AndroidNetworkMonitor(
                 override fun onReceive(context: Context, intent: Intent) {
                     if (intent.action == Intent.ACTION_AIRPLANE_MODE_CHANGED) {
                         Timber.d("Received airplane mode changed broadcast")
-                        trySend(isAirplaneModeOn)
+                        trySend(appContext.isAirplaneModeOn())
                     }
                 }
             }
@@ -306,7 +287,7 @@ class AndroidNetworkMonitor(
         appContext.registerReceiver(receiver, filter)
 
         // initial state
-        trySend(isAirplaneModeOn)
+        trySend(appContext.isAirplaneModeOn())
 
         awaitClose {
             runCatching { appContext.unregisterReceiver(receiver) }
@@ -314,6 +295,53 @@ class AndroidNetworkMonitor(
         }
     }
 
+    private val wifiStateFlow: Flow<NetworkCapabilities?> =
+        wifiFlow
+            .map { event ->
+                when (event) {
+                    is TransportEvent.CapabilitiesChanged -> event.networkCapabilities
+                    is TransportEvent.Lost -> null
+                    else -> null
+                }
+            }
+            .stateIn(applicationScope, SharingStarted.Eagerly, null)
+
+    private val cellularStateFlow: Flow<NetworkCapabilities?> =
+        cellularFlow
+            .map { event ->
+                when (event) {
+                    is TransportEvent.CapabilitiesChanged ->
+                        if (
+                            event.networkCapabilities.hasCapability(
+                                NetworkCapabilities.NET_CAPABILITY_INTERNET
+                            )
+                        )
+                            event.networkCapabilities
+                        else null
+                    is TransportEvent.Lost -> null
+                    else -> null
+                }
+            }
+            .stateIn(applicationScope, SharingStarted.Eagerly, null)
+
+    private val ethernetStateFlow: Flow<NetworkCapabilities?> =
+        ethernetFlow
+            .map { event ->
+                when (event) {
+                    is TransportEvent.CapabilitiesChanged ->
+                        if (
+                            event.networkCapabilities.hasCapability(
+                                NetworkCapabilities.NET_CAPABILITY_INTERNET
+                            )
+                        )
+                            event.networkCapabilities
+                        else null
+                    is TransportEvent.Lost -> null
+                    else -> null
+                }
+            }
+            .stateIn(applicationScope, SharingStarted.Eagerly, null)
+
     private suspend fun getSsidByDetectionMethod(
         detectionMethod: WifiDetectionMethod?,
         networkCapabilities: NetworkCapabilities?,
@@ -345,90 +373,100 @@ class AndroidNetworkMonitor(
             .also { Timber.d("Current SSID via ${method.name}: $it") }
     }
 
-    override val connectivityStateFlow: SharedFlow<ConnectivityState> =
-        combine(
-                defaultNetworkFlow.scan(
-                    ConnectivityState(
-                        activeNetwork = ActiveNetwork.Disconnected,
-                        locationPermissionsGranted = hasRequiredLocationPermissions(),
-                        locationServicesEnabled =
-                            locationManager?.isLocationServicesEnabled() ?: false,
-                    )
-                ) { previous, event ->
-                    when (event) {
-                        is TransportEvent.CapabilitiesChanged -> {
-                            when {
-                                event.networkCapabilities.hasTransport(
-                                    NetworkCapabilities.TRANSPORT_WIFI
-                                ) -> {
-                                    val ssid =
-                                        getSsidByDetectionMethod(
-                                            event.wifiDetectionMethod
-                                                ?: WifiDetectionMethod.DEFAULT,
-                                            event.networkCapabilities,
-                                        )
+    private data class NetworkData(
+        val defaultEvent: TransportEvent,
+        val wifiCaps: NetworkCapabilities?,
+        val cellularCaps: NetworkCapabilities?,
+        val ethernetCaps: NetworkCapabilities?,
+    )
 
-                                    previous.copy(
-                                        activeNetwork =
-                                            ActiveNetwork.Wifi(
-                                                ssid = ssid,
-                                                securityType = wifiManager?.getCurrentSecurityType(),
-                                            )
-                                    )
+    private val networkFlows: Flow<NetworkData> =
+        combine(defaultNetworkFlow, wifiStateFlow, cellularStateFlow, ethernetStateFlow) {
+            defaultEvent,
+            wifiCaps,
+            cellularCaps,
+            ethernetCaps ->
+            NetworkData(defaultEvent, wifiCaps, cellularCaps, ethernetCaps)
+        }
+
+    override val connectivityStateFlow: SharedFlow<ConnectivityState> =
+        combine(networkFlows, airplaneModeFlow, configurationListener.detectionMethod) {
+                networkData,
+                isAirplaneOn,
+                detectionMethod ->
+                val defaultEvent = networkData.defaultEvent
+                val wifiCaps = networkData.wifiCaps
+                val cellularCaps = networkData.cellularCaps
+                val ethernetCaps = networkData.ethernetCaps
+
+                val permissions =
+                    when (defaultEvent) {
+                        is TransportEvent.Permissions -> defaultEvent.permissions
+                        else ->
+                            Permissions(
+                                locationManager?.isLocationServicesEnabled() ?: false,
+                                appContext.hasRequiredLocationPermissions(),
+                            )
+                    }
+
+                val defaultCaps =
+                    when (defaultEvent) {
+                        is TransportEvent.CapabilitiesChanged -> defaultEvent.networkCapabilities
+                        else ->
+                            connectivityManager?.getNetworkCapabilities(
+                                connectivityManager.activeNetwork
+                            )
+                    }
+                        ?: return@combine ConnectivityState(
+                            ActiveNetwork.Disconnected,
+                            permissions.locationServicesEnabled,
+                            permissions.locationPermissionGranted,
+                        )
+
+                val isValidated =
+                    defaultCaps.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
+                val hasInternet =
+                    defaultCaps.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+
+                if (!isValidated || !hasInternet) {
+                    return@combine ConnectivityState(
+                        ActiveNetwork.Disconnected,
+                        permissions.locationServicesEnabled,
+                        permissions.locationPermissionGranted,
+                    )
+                } else {
+                    val activeNetwork: ActiveNetwork =
+                        if (defaultCaps.hasTransport(NetworkCapabilities.TRANSPORT_VPN)) {
+                            // Ignore VPN, determine underlying
+                            when {
+                                wifiCaps != null -> {
+                                    val ssid = getSsidByDetectionMethod(detectionMethod, wifiCaps)
+                                    ActiveNetwork.Wifi(ssid, wifiManager?.getCurrentSecurityType())
                                 }
-                                event.networkCapabilities.hasTransport(
-                                    NetworkCapabilities.TRANSPORT_CELLULAR
-                                ) -> {
-                                    activeWifiNetworks.clear()
-                                    previous.copy(activeNetwork = ActiveNetwork.Cellular)
+                                ethernetCaps != null -> ActiveNetwork.Ethernet
+                                cellularCaps != null && !isAirplaneOn -> ActiveNetwork.Cellular
+                                else -> ActiveNetwork.Disconnected
+                            }
+                        } else {
+                            when {
+                                defaultCaps.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> {
+                                    val ssid =
+                                        getSsidByDetectionMethod(detectionMethod, defaultCaps)
+                                    ActiveNetwork.Wifi(ssid, wifiManager?.getCurrentSecurityType())
                                 }
-                                event.networkCapabilities.hasTransport(
-                                    NetworkCapabilities.TRANSPORT_ETHERNET
-                                ) -> {
-                                    activeWifiNetworks.clear()
-                                    previous.copy(activeNetwork = ActiveNetwork.Ethernet)
-                                }
-                                else -> previous
+                                defaultCaps.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) &&
+                                    !isAirplaneOn -> ActiveNetwork.Cellular
+                                defaultCaps.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET) ->
+                                    ActiveNetwork.Ethernet
+                                else -> ActiveNetwork.Disconnected
                             }
                         }
-                        is TransportEvent.Lost ->
-                            previous.copy(activeNetwork = ActiveNetwork.Disconnected)
-                        is TransportEvent.Permissions -> {
-                            previous.copy(
-                                locationPermissionsGranted =
-                                    event.permissions.locationPermissionGranted,
-                                locationServicesEnabled = event.permissions.locationServicesEnabled,
-                            )
-                        }
-                        is TransportEvent.Available -> previous
-                        is TransportEvent.Unknown -> previous
-                    }
-                },
-                wifiInterfaceFlow,
-                airplaneModeFlow,
-                cellularInterfaceFlow,
-            ) { defaultState, isWifiInterfaceOn, isAirplaneModeOn, isCellularInterfaceOn ->
-                val activeNetwork =
-                    when {
-                        // Wi-Fi interface disabled, force disconnected
-                        !isWifiInterfaceOn && defaultState.activeNetwork is ActiveNetwork.Wifi ->
-                            ActiveNetwork.Disconnected
-                        // Cellular active when airplane mode on
-                        isAirplaneModeOn && defaultState.activeNetwork is ActiveNetwork.Cellular ->
-                            ActiveNetwork.Disconnected
-                        // Cellular active when cellular interface disabled
-                        !isCellularInterfaceOn &&
-                            defaultState.activeNetwork is ActiveNetwork.Cellular ->
-                            ActiveNetwork.Disconnected
-                        else -> defaultState.activeNetwork
-                    }
-
-                ConnectivityState(
-                        activeNetwork = activeNetwork,
-                        locationPermissionsGranted = defaultState.locationPermissionsGranted,
-                        locationServicesEnabled = defaultState.locationServicesEnabled,
+                    ConnectivityState(
+                        activeNetwork,
+                        permissions.locationServicesEnabled,
+                        permissions.locationPermissionGranted,
                     )
-                    .also { Timber.i("Connectivity Status: $it") }
+                }
             }
             .distinctUntilChanged()
             .shareIn(applicationScope, SharingStarted.Eagerly, replay = 1)
@@ -452,7 +490,7 @@ class AndroidNetworkMonitor(
             object : BroadcastReceiver() {
                 override fun onReceive(context: Context, intent: Intent) {
                     if (intent.action == actionPermissionCheck) {
-                        val isGranted = hasRequiredLocationPermissions()
+                        val isGranted = appContext.hasRequiredLocationPermissions()
                         Timber.d("Received permission check broadcast, isGranted: $isGranted")
                         if (
                             connectivityStateFlow.replayCache
@@ -462,7 +500,6 @@ class AndroidNetworkMonitor(
                             Timber.d(
                                 "Location permissions have changed, canceling and restarting callback flow"
                             )
-                            activeWifiNetworks.clear()
                             permissionsChangedFlow.update { !permissionsChangedFlow.value }
                         }
                     }
@@ -487,7 +524,6 @@ class AndroidNetworkMonitor(
                             Timber.d(
                                 "Location services have changed, canceling and restarting callback flow"
                             )
-                            activeWifiNetworks.clear()
                             permissionsChangedFlow.update { !permissionsChangedFlow.value }
                         }
                     }
@@ -508,10 +544,9 @@ class AndroidNetworkMonitor(
                 locationServicesReceiver?.let { appContext.unregisterReceiver(it) }
 
                 defaultNetworkCallback?.let { connectivityManager?.unregisterNetworkCallback(it) }
-                wifiInterfaceCallback?.let { connectivityManager?.unregisterNetworkCallback(it) }
-                cellularInterfaceCallback?.let {
-                    connectivityManager?.unregisterNetworkCallback(it)
-                }
+                wifiCallback?.let { connectivityManager?.unregisterNetworkCallback(it) }
+                cellularCallback?.let { connectivityManager?.unregisterNetworkCallback(it) }
+                ethernetCallback?.let { connectivityManager?.unregisterNetworkCallback(it) }
             }
             .onFailure { Timber.e(it, "Error during cleanup") }
         Timber.d("NetworkMonitor cleaned up")

networkmonitor/src/main/java/com/zaneschepke/networkmonitor/ConnectivityState.kt

@@ -27,17 +27,14 @@ data class ConnectivityState(
     }
 }
 
+data class Permissions(val locationServicesEnabled: Boolean, val locationPermissionGranted: Boolean)
+
 sealed class ActiveNetwork {
     data object Disconnected : ActiveNetwork()
 
-    data object Ethernet : ActiveNetwork()
+    data class Wifi(val ssid: String, val securityType: WifiSecurityType?) : ActiveNetwork()
 
     data object Cellular : ActiveNetwork()
 
-    data class Wifi(val ssid: String, val securityType: WifiSecurityType? = null) : ActiveNetwork()
+    data object Ethernet : ActiveNetwork()
 }
-
-data class Permissions(
-    val locationServicesEnabled: Boolean = false,
-    val locationPermissionGranted: Boolean = false,
-)

networkmonitor/src/main/java/com/zaneschepke/networkmonitor/util/Extensions.kt

@@ -1,10 +1,15 @@
 package com.zaneschepke.networkmonitor.util
 
+import android.Manifest
+import android.content.Context
+import android.content.pm.PackageManager
 import android.location.LocationManager
 import android.net.NetworkCapabilities
 import android.net.wifi.WifiInfo
 import android.net.wifi.WifiManager
 import android.os.Build
+import android.provider.Settings
+import androidx.core.content.ContextCompat
 import com.wireguard.android.util.RootShell
 import com.zaneschepke.networkmonitor.AndroidNetworkMonitor.Companion.ANDROID_UNKNOWN_SSID
 import kotlinx.coroutines.Dispatchers
@@ -62,3 +67,29 @@ fun LocationManager.isLocationServicesEnabled(): Boolean {
         false
     }
 }
+
+fun Context.hasRequiredLocationPermissions(): Boolean {
+    val fineLocationGranted =
+        ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) ==
+            PackageManager.PERMISSION_GRANTED
+    val backgroundLocationGranted =
+        if (
+            (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) &&
+                // exclude Android TV on Q as background location is not required on this
+                // version
+                !(Build.VERSION.SDK_INT == Build.VERSION_CODES.Q &&
+                    packageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK))
+        ) {
+            ContextCompat.checkSelfPermission(
+                this,
+                Manifest.permission.ACCESS_BACKGROUND_LOCATION,
+            ) == PackageManager.PERMISSION_GRANTED
+        } else {
+            true // No need for ACCESS_BACKGROUND_LOCATION on Android P or Android TV on Q
+        }
+    return fineLocationGranted && backgroundLocationGranted
+}
+
+fun Context.isAirplaneModeOn(): Boolean {
+    return Settings.Global.getInt(contentResolver, Settings.Global.AIRPLANE_MODE_ON, 0) != 0
+}