Overhaul how we forcibly open apps to the foreground

Author: tstromberg

README.md

@@ -23,19 +23,21 @@ Similar concept to [Yakk](https://yakk.bkappz.com/), but open-source with more s
 - Camera motion detection with adjustable sensitivity
 - Ambient light sensor for detecting lighting changes
 - Auto-unlock screen and launch your dashboard app
+- Automatic keyguard dismissal (works with swipe-to-unlock and no security)
+- Configurable notification sound on wake
 - Start at boot for set-and-forget operation
-- Material Design 3 with dark mode and tablet layouts
+- Clean, simple UI with tablet layouts
 - Full accessibility support with TalkBack
 
-## Setup Recommendations
+## Permissions
 
-**For best results, disable your device's lock screen security:**
+On first launch, the app will request the following permissions:
 
-Go to **Settings → Security → Screen Lock** and set it to **"None"** or **"Swipe"**.
+- **Camera** - For motion detection
+- **Display over other apps** (SYSTEM_ALERT_WINDOW) - Required to reliably launch apps from background on Android 10+
+- **Battery optimization exemption** - For reliable background operation
 
-**Why?** Android's security model prevents apps from bypassing PIN, pattern, or biometric authentication. If you have secure lock screen enabled, the app will wake the screen but you'll still need to authenticate manually. For wall-mounted tablets that don't leave your home, disabling the lock screen provides the smoothest experience.
-
-If you need security, consider using Smart Lock (Settings → Security → Smart Lock) with trusted locations or devices instead.
+These permissions are essential for the app to function properly.
 
 ## Building
 

app/build.gradle.kts

@@ -12,15 +12,16 @@ android {
         applicationId = "com.observer.effect"
         minSdk = 26
         targetSdk = 34
-        versionCode = 9
-        versionName = "0.7.2"
+        versionCode = 10
+        versionName = "0.7.3"
     }
 
     signingConfigs {
         create("release") {
             // Use keystore from environment variable or default locations
-            val keystorePath = System.getenv("ANDROID_KEYSTORE")
-                ?: "${System.getProperty("user.home")}/android.jks"
+            val keystorePath =
+                System.getenv("ANDROID_KEYSTORE")
+                    ?: "${System.getProperty("user.home")}/android.jks"
             val keystoreFile = file(keystorePath)
 
             if (keystoreFile.exists()) {

app/release/baselineProfiles/0/app-release.dm

@@ -4,15 +4,15 @@
     "type": "APK",
     "kind": "Directory"
   },
-  "applicationId": "com.heisenberg.lux",
+  "applicationId": "com.observer.effect",
   "variantName": "release",
   "elements": [
     {
       "type": "SINGLE",
       "filters": [],
       "attributes": [],
-      "versionCode": 8,
-      "versionName": "0.7.1",
+      "versionCode": 9,
+      "versionName": "0.7.2",
       "outputFile": "app-release.apk"
     }
   ],

app/release/baselineProfiles/1/app-release.dm

@@ -7,6 +7,7 @@
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_CAMERA" />
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
     <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
+    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
 
     <uses-feature android:name="android.hardware.camera" android:required="false" />
     <uses-feature android:name="android.hardware.sensor.light" android:required="false" />
@@ -35,6 +36,14 @@
             </intent-filter>
         </activity>
 
+        <!-- Transparent activity for dismissing keyguard and launching target app -->
+        <activity
+            android:name=".LauncherActivity"
+            android:excludeFromRecents="true"
+            android:exported="false"
+            android:launchMode="singleTask"
+            android:theme="@android:style/Theme.Translucent.NoTitleBar" />
+
         <service
             android:name=".DetectionService"
             android:enabled="true"

app/release/output-metadata.json

@@ -1,6 +1,5 @@
 package com.observer.effect
 
-import android.app.ActivityManager
 import android.app.KeyguardManager
 import android.app.Notification
 import android.app.NotificationChannel
@@ -11,7 +10,6 @@ import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
 import android.content.SharedPreferences
-import android.os.Build
 import android.os.IBinder
 import android.os.PowerManager
 import android.util.Log
@@ -266,52 +264,74 @@ class DetectionService : Service(), LifecycleOwner {
         try {
             // Don't auto-open if screen is already on (user is actively using device)
             if (powerManager.isInteractive) {
-                Log.d(TAG, "Screen already on, skipping auto-open")
+                Log.d(TAG, "Screen already on, skipping wake operation")
                 return
             }
 
+            // Check if wake lock is already held to prevent double-wake
+            if (wakeLock.isHeld) {
+                Log.d(TAG, "Wake lock already held, skipping duplicate wake operation")
+                return
+            }
+
+            Log.i(TAG, "Motion/light detected - initiating screen wake sequence")
+
             // CRITICAL FIX: Use acquire with timeout, don't release immediately
             // The timeout will auto-release after WAKE_DURATION_MS
-            if (!wakeLock.isHeld) {
-                Log.i(TAG, "Waking screen")
-                wakeLock.acquire(WAKE_DURATION_MS)
-                // Don't call release() - the timeout handles it automatically
-
-                // Play notification sound if configured
-                val notificationSoundUri = prefs.getString(MainActivity.KEY_NOTIFICATION_SOUND, "") ?: ""
-                if (notificationSoundUri.isNotEmpty()) {
-                    try {
-                        val ringtone = android.media.RingtoneManager.getRingtone(this, android.net.Uri.parse(notificationSoundUri))
-                        ringtone?.play()
-                        Log.i(TAG, "Playing notification sound: $notificationSoundUri")
-                    } catch (e: Exception) {
-                        Log.e(TAG, "Error playing notification sound", e)
+            wakeLock.acquire(WAKE_DURATION_MS)
+            Log.d(TAG, "Wake lock acquired for ${WAKE_DURATION_MS}ms")
+
+            // Play notification sound if configured
+            val notificationSoundUri = prefs.getString(MainActivity.KEY_NOTIFICATION_SOUND, "") ?: ""
+            if (notificationSoundUri.isNotEmpty()) {
+                try {
+                    Log.d(TAG, "Playing notification sound")
+                    val ringtone = android.media.RingtoneManager.getRingtone(this, android.net.Uri.parse(notificationSoundUri))
+                    if (ringtone != null) {
+                        ringtone.play()
+                        Log.i(TAG, "Notification sound started: $notificationSoundUri")
+                    } else {
+                        Log.w(TAG, "Ringtone object is null for URI: $notificationSoundUri")
                     }
+                } catch (e: SecurityException) {
+                    Log.e(TAG, "Security exception playing notification sound - missing permissions?", e)
+                } catch (e: Exception) {
+                    Log.e(TAG, "Unexpected error playing notification sound: $notificationSoundUri", e)
                 }
+            } else {
+                Log.d(TAG, "No notification sound configured")
+            }
+
+            // Launch app if configured
+            val launchApp = prefs.getString(MainActivity.KEY_LAUNCH_APP, "") ?: ""
+            if (launchApp.isNotEmpty()) {
+                try {
+                    Log.i(
+                        TAG,
+                        "Initiating app launch: package=$launchApp, keyguardLocked=${keyguardManager.isKeyguardLocked}",
+                    )
 
-                // Launch app if configured
-                val launchApp = prefs.getString(MainActivity.KEY_LAUNCH_APP, "") ?: ""
-                if (launchApp.isNotEmpty()) {
-                    try {
-                        Log.i(TAG, "Bringing app to foreground: $launchApp (locked=${keyguardManager.isKeyguardLocked})")
-
-                        val launchIntent = packageManager.getLaunchIntentForPackage(launchApp)
-                        if (launchIntent != null) {
-                            // Use CLEAR_TASK + NEW_TASK to forcefully bring the app to foreground
-                            // This clears the existing task and creates a fresh one on top
-                            launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
-                            startActivity(launchIntent)
-                            Log.i(TAG, "Launched app with CLEAR_TASK flags=${launchIntent.flags}")
-                        } else {
-                            Log.w(TAG, "No launch intent found for package: $launchApp")
+                    // Use our transparent LauncherActivity to properly dismiss keyguard
+                    // and then launch the target app
+                    val launcherIntent =
+                        Intent(this, LauncherActivity::class.java).apply {
+                            putExtra(LauncherActivity.EXTRA_TARGET_PACKAGE, launchApp)
+                            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
                         }
-                    } catch (e: Exception) {
-                        Log.e(TAG, "Error launching app: $launchApp", e)
-                    }
+                    startActivity(launcherIntent)
+                    Log.i(TAG, "LauncherActivity started successfully")
+                } catch (e: SecurityException) {
+                    Log.e(TAG, "Security exception starting LauncherActivity - missing permissions?", e)
+                } catch (e: Exception) {
+                    Log.e(TAG, "Unexpected error starting LauncherActivity for app: $launchApp", e)
                 }
+            } else {
+                Log.d(TAG, "No launch app configured")
             }
+        } catch (e: SecurityException) {
+            Log.e(TAG, "Security exception during screen wake - missing WAKE_LOCK permission?", e)
         } catch (e: Exception) {
-            Log.e(TAG, "Error waking screen", e)
+            Log.e(TAG, "Unexpected error during screen wake sequence", e)
         }
     }
 

app/src/main/AndroidManifest.xml

@@ -284,8 +284,23 @@ class MainActivity : AppCompatActivity() {
             requestPermissionLauncher.launch(Manifest.permission.CAMERA)
         }
 
-        // Request battery optimization exemption for reliable background operation
+        // Request SYSTEM_ALERT_WINDOW permission for reliable app launching from background
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            if (!android.provider.Settings.canDrawOverlays(this)) {
+                try {
+                    val intent =
+                        Intent(
+                            android.provider.Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
+                            android.net.Uri.parse("package:$packageName"),
+                        )
+                    startActivity(intent)
+                    Log.i(TAG, "Requesting overlay permission for background activity launch")
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error requesting overlay permission", e)
+                }
+            }
+
+            // Request battery optimization exemption for reliable background operation
             val powerManager = getSystemService(Context.POWER_SERVICE) as android.os.PowerManager
             if (!powerManager.isIgnoringBatteryOptimizations(packageName)) {
                 try {