Android应用关闭后自动禁用GPS的实现方案咨询（含程序化禁用需求）

Great question—this is such a common frustration for Android users, hitting both privacy concerns and battery drain. Let’s walk through practical ways to address this, including working code examples that align with modern Android best practices.

Approach 1: Use Accessibility Service (Recommended for Broad Compatibility) #

Accessibility Services let you listen to system-wide events like app window changes, which is perfect for detecting when an app moves out of the foreground or closes entirely. Here’s how to build one:

Step 1: Create the Accessibility Service Class #

This service will track the foreground app and trigger GPS checks when apps close:

class GpsAutoDisableService : AccessibilityService() {
    private var lastForegroundApp: String? = null

    override fun onAccessibilityEvent(event: AccessibilityEvent) {
        when (event.eventType) {
            AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED -> {
                val currentPackage = event.packageName?.toString()
                
                // Update the last known foreground app when a new app takes focus
                if (event.isForeground) {
                    lastForegroundApp = currentPackage
                } 
                // When an app leaves the foreground, check if we need to disable GPS
                else if (currentPackage == lastForegroundApp) {
                    if (!isAnyAppActivelyUsingGps()) {
                        triggerGpsDisable()
                    }
                }
            }
        }
    }

    private fun isAnyAppActivelyUsingGps(): Boolean {
        val appOpsManager = getSystemService(AppOpsManager::class.java)
        // Query if any app has active fine location access
        // Note: For full accuracy, you'd need to iterate over all installed apps, but this is a starting point
        val opsStatus = appOpsManager.queryOp(
            AppOpsManager.OPSTR_FINE_LOCATION,
            android.os.Process.myUid(),
            packageName
        )
        return opsStatus != AppOpsManager.MODE_IGNORED
    }

    private fun triggerGpsDisable() {
        // Directly disabling GPS requires the WRITE_SECURE_SETTINGS permission (restricted to system apps/adb)
        // For regular apps, the best approach is to redirect the user to location settings
        val settingsIntent = Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS).apply {
            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
        }
        startActivity(settingsIntent)

        // If you have WRITE_SECURE_SETTINGS (e.g., via adb grant), you can use:
        // Settings.Secure.putInt(contentResolver, Settings.Secure.LOCATION_MODE, Settings.Secure.LOCATION_MODE_OFF)
    }

    override fun onInterrupt() {
        // Handle service interruptions (e.g., system stopping the service temporarily)
    }
}

Step 2: Register the Service in AndroidManifest.xml #

Add this entry to your manifest to declare the service and required permissions:

<service
    android:name=".GpsAutoDisableService"
    android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE">
    <intent-filter>
        <action android:name="android.accessibilityservice.AccessibilityService" />
    </intent-filter>
    <meta-data
        android:name="android.accessibilityservice"
        android:resource="@xml/accessibility_service_config" />
</service>

Step 3: Create Accessibility Configuration XML #

Create res/xml/accessibility_service_config.xml to define what events the service listens to:

<?xml version="1.0" encoding="utf-8"?>
<accessibility-service xmlns:android="http://schemas.android.com/apk/res/android"
    android:accessibilityEventTypes="typeWindowStateChanged"
    android:accessibilityFeedbackType="feedbackGeneric"
    android:accessibilityFlags="flagDefault"
    android:canRetrieveWindowContent="true"
    android:description="@string/accessibility_service_desc" />

Don’t forget to add a description string in strings.xml (users will see this when enabling the service):

<string name="accessibility_service_desc">Automatically disables GPS when apps that used it are closed</string>

Step 4: Guide Users to Enable the Service #

Your app can’t enable accessibility services automatically—you’ll need to prompt users to turn it on via system settings:

fun promptAccessibilityEnable() {
    val intent = Intent(Settings.ACTION_ACCESSIBILITY_SETTINGS)
    startActivity(intent)
}

Approach 2: Leverage AppOps API (For Targeted Permission Control) #

On Android 6.0+, the AppOps API lets you check and manage app permissions. You can use this to revoke location permissions for apps that aren’t in use, which indirectly disables GPS for those apps:

fun revokeAppLocationPermission(packageName: String) {
    val appOpsManager = getSystemService(AppOpsManager::class.java)
    appOpsManager.setMode(
        AppOpsManager.OPSTR_FINE_LOCATION,
        android.os.Process.myUid(),
        packageName,
        AppOpsManager.MODE_IGNORED
    )
}

Note: This requires the android.permission.MANAGE_APP_OPS_MODES permission, which is restricted to system apps in newer Android versions. For regular apps, this approach is limited.

Key Considerations & Limitations #

• Permissions: Accessibility services require user consent, but it’s the most feasible way for regular apps to get system-wide event access. Direct GPS control needs restricted permissions.
• Android Version Compatibility: Android 12+ introduced stricter location permissions (e.g., one-time access), so your logic should account for these changes.
• Avoid False Positives: Always verify no other apps are actively using GPS before disabling it—you don’t want to disrupt a navigation app running in the background.

Wrap-Up #

While there’s no "one-click" solution that works without user interaction (thanks to Android’s security model), the Accessibility Service approach provides a reliable way to automate GPS disablement when apps close. It’s used by many battery-saving and privacy apps today.

内容的提问来源于stack exchange，提问作者Antonio Noack