Here's a summary of the changes I've made to implement robust MediaProjection with a ForegroundService for Android 14 and above:

This update introduces screenshot functionality using MediaProjection within a ForegroundService (`ScreenCaptureService.kt`). This ensures compatibility with Android 14 and later, which require a foreground service for this purpose. This new approach replaces previous attempts to take screenshots directly within the `MainActivity`.

Key Changes:

1.  **`ScreenCaptureService.kt` Updated:**
    *   I've replaced the existing file with a new, more comprehensive version.
    *   It now calls `startForeground()` immediately in `onStartCommand()` with an appropriate notification.
    *   It correctly handles `Intent` data (resultCode, resultData), including the proper way to get `Parcelable` extras on Android Tiramisu and newer.
    *   It manages the lifecycles of `MediaProjection`, `ImageReader`, and `VirtualDisplay`.
    *   I've included robust error handling and resource cleanup, with a `cleanup()` method that's called in various situations, including within the `MediaProjection.Callback`.
    *   A dedicated notification channel has been created.

2.  **`MainActivity.kt` Refactored:**
    *   I simplified the class variables to just `mediaProjectionManager` and `mediaProjectionLauncher`.
    *   In `onCreate()`:
        *   I've ensured `mediaProjectionManager` and `mediaProjectionLauncher` are initialized in the correct order (after `refreshAccessibilityServiceStatus()`).
        *   The `mediaProjectionLauncher` callback now constructs an Intent for `ScreenCaptureService` and starts it using `startForegroundService` (or `startService` for older API levels).
        *   The call to `requestMediaProjectionPermission()` has been moved to the end of `onCreate`.
    *   I've removed the direct screenshot methods (`takeScreenshotDirect`, `saveScreenshot`) and related variables (`pendingScreenshot`).
    *   The `requestMediaProjectionPermission()` method now solely launches the screen capture intent via `mediaProjectionLauncher`.
    *   I've removed any `MediaProjection`-related resource cleanup from `onDestroy()`, as the service now manages its own resources.

3.  **`AndroidManifest.xml` Verified:**
    *   I've confirmed that the `FOREGROUND_SERVICE` and `FOREGROUND_SERVICE_MEDIA_PROJECTION` permissions are present.
    *   I've also verified the `ScreenCaptureService` declaration, ensuring it includes `android:exported="false"` and `android:foregroundServiceType="mediaProjection"`.

This approach should provide a more stable and compliant way for you to handle screen captures, especially on newer Android versions.

Author: google-labs-jules[bot]

app/src/main/kotlin/com/google/ai/sample/MainActivity.kt

@@ -119,7 +119,6 @@ class MainActivity : ComponentActivity() {
     // MediaProjection
     private lateinit var mediaProjectionManager: MediaProjectionManager
     private lateinit var mediaProjectionLauncher: ActivityResultLauncher<Intent>
-    private var pendingScreenshot = false
 
     private lateinit var navController: NavHostController
 
@@ -155,133 +154,17 @@ class MainActivity : ComponentActivity() {
     // Nach Zeile 920, vor "companion object {":
     private fun requestMediaProjectionPermission() {
         Log.d(TAG, "Requesting MediaProjection permission")
-        if (::mediaProjectionManager.isInitialized) {
-            pendingScreenshot = true
-            val intent = mediaProjectionManager.createScreenCaptureIntent()
-            mediaProjectionLauncher.launch(intent)
-        } else {
-            Log.e(TAG, "mediaProjectionManager not initialized!")
-        }
-    }
-
-    private fun takeScreenshotDirect(resultCode: Int, data: Intent) {
-        lifecycleScope.launch {
-            try {
-                val mediaProjection = mediaProjectionManager.getMediaProjection(resultCode, data)
-
-                // Register a callback to clean up when projection stops.
-                mediaProjection.registerCallback(object : MediaProjection.Callback() {
-                    override fun onStop() {
-                        super.onStop()
-                        Log.w(TAG, "MediaProjection session stopped. (Callback)")
-                        // Note: Resources are cleaned up in the finally block of takeScreenshotDirect's image listener.
-                        // Additional cleanup here might be redundant or could target specific things if needed.
-                    }
-                }, Handler(Looper.getMainLooper()))
-
-                val windowManager = getSystemService(Context.WINDOW_SERVICE) as WindowManager
-                val displayMetrics = DisplayMetrics()
-
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-                    display?.getRealMetrics(displayMetrics)
-                } else {
-                    @Suppress("DEPRECATION")
-                    windowManager.defaultDisplay.getMetrics(displayMetrics)
-                }
-
-                val width = displayMetrics.widthPixels
-                val height = displayMetrics.heightPixels
-                val density = displayMetrics.densityDpi
-
-                val imageReader = ImageReader.newInstance(width, height, PixelFormat.RGBA_8888, 1)
-
-                val virtualDisplay = mediaProjection.createVirtualDisplay(
-                    "ScreenCapture",
-                    width, height, density,
-                    DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR,
-                    imageReader.surface, null, null
-                )
-
-                imageReader.setOnImageAvailableListener({ reader ->
-                    val image = reader.acquireLatestImage()
-                    if (image != null) {
-                        try {
-                            val planes = image.planes
-                            val buffer = planes[0].buffer
-                            val pixelStride = planes[0].pixelStride
-                            val rowStride = planes[0].rowStride
-                            val rowPadding = rowStride - pixelStride * width
-
-                            val bitmap = Bitmap.createBitmap(
-                                width + rowPadding / pixelStride,
-                                height,
-                                Bitmap.Config.ARGB_8888
-                            )
-                            bitmap.copyPixelsFromBuffer(buffer)
-
-                            saveScreenshot(bitmap) // Calls the new saveScreenshot
-                        } catch (e: Exception) {
-                            Log.e(TAG, "Error processing image in takeScreenshotDirect", e)
-                        } finally {
-                            image.close()
-                            virtualDisplay.release()
-                            imageReader.close() // Close the reader itself
-                            mediaProjection.stop() // Stop the projection
-                            Log.d(TAG, "Cleaned up resources in takeScreenshotDirect's onImageAvailableListener.")
-                            pendingScreenshot = false
-                        }
-                    } else {
-                         Log.w(TAG, "takeScreenshotDirect: acquireLatestImage() returned null")
-                         virtualDisplay.release()
-                         imageReader.close()
-                         mediaProjection.stop()
-                         pendingScreenshot = false
-                    }
-                }, Handler(Looper.getMainLooper()))
-            } catch (e: Exception) {
-                Log.e(TAG, "Error taking screenshot in takeScreenshotDirect", e)
-                Toast.makeText(this@MainActivity, "Failed to take screenshot: ${e.message}", Toast.LENGTH_SHORT).show()
-                pendingScreenshot = false
-                // Attempt to clean up projection if it was created and an error occurred before listener
-                // This part is tricky because mediaProjection might not be assigned if getMediaProjection failed.
-                // However, if it did, it should be stopped. The user's example code for takeScreenshotDirect
-                // implicitly relies on the onImageAvailableListener's finally block for cleanup.
-                // If an exception occurs *before* the listener is set or image is available,
-                // mediaProjection might leak if not handled here.
-                // For now, sticking to the provided code.
-            }
-        }
-    }
-
-    private fun saveScreenshot(bitmap: Bitmap) { // This is the new saveScreenshot
-        try {
-            val picturesDir = File(getExternalFilesDir(Environment.DIRECTORY_PICTURES), "Screenshots")
-            if (!picturesDir.exists()) {
-                picturesDir.mkdirs()
-            }
-
-            val timestamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.getDefault()).format(Date())
-            val file = File(picturesDir, "screenshot_$timestamp.png")
-
-            val outputStream = FileOutputStream(file)
-            bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)
-            outputStream.flush()
-            outputStream.close()
-
-            Log.i(TAG, "Screenshot saved to: ${file.absolutePath}")
-            runOnUiThread {
-                Toast.makeText(
-                    this,
-                    "Screenshot saved to: Android/data/com.google.ai.sample/files/Pictures/Screenshots/",
-                    Toast.LENGTH_LONG
-                ).show()
-            }
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to save screenshot", e)
-            runOnUiThread {
-                Toast.makeText(this, "Failed to save screenshot: ${e.message}", Toast.LENGTH_LONG).show()
-            }
+        // Ensure mediaProjectionManager is initialized before using it.
+        // This should be guaranteed by its placement in onCreate.
+        if (!::mediaProjectionManager.isInitialized) {
+            Log.e(TAG, "requestMediaProjectionPermission: mediaProjectionManager not initialized!")
+            // Optionally, initialize it here as a fallback, though it indicates an issue with onCreate ordering
+            // mediaProjectionManager = getSystemService(Context.MEDIA_PROJECTION_SERVICE) as MediaProjectionManager
+            // Toast.makeText(this, "Error: Projection manager not ready. Please try again.", Toast.LENGTH_SHORT).show()
+            return
         }
+        val intent = mediaProjectionManager.createScreenCaptureIntent()
+        mediaProjectionLauncher.launch(intent)
     }
 
     // START: Added for Accessibility Service Status
@@ -493,18 +376,31 @@ class MainActivity : ComponentActivity() {
         refreshAccessibilityServiceStatus()
 
             // MediaProjection Initialisierung hier einfügen:
+            // Initialize MediaProjectionManager
             Log.d(TAG, "onCreate: Initializing MediaProjectionManager")
             mediaProjectionManager = getSystemService(Context.MEDIA_PROJECTION_SERVICE) as MediaProjectionManager
 
+            // Initialize MediaProjection launcher
             Log.d(TAG, "onCreate: Initializing MediaProjection launcher")
             mediaProjectionLauncher = registerForActivityResult(
                 ActivityResultContracts.StartActivityForResult()
             ) { result ->
+                Log.d(TAG, "MediaProjection result: resultCode=${result.resultCode}, hasData=${result.data != null}")
+
                 if (result.resultCode == Activity.RESULT_OK && result.data != null) {
-                    Log.i(TAG, "MediaProjection permission granted - taking screenshot directly")
-                    Handler(Looper.getMainLooper()).postDelayed({
-                        takeScreenshotDirect(result.resultCode, result.data!!)
-                    }, 100)
+                    Log.i(TAG, "MediaProjection permission granted, starting service")
+
+                    val serviceIntent = Intent(this, ScreenCaptureService::class.java).apply {
+                        action = ScreenCaptureService.ACTION_START_CAPTURE
+                        putExtra(ScreenCaptureService.EXTRA_RESULT_CODE, result.resultCode)
+                        putExtra(ScreenCaptureService.EXTRA_RESULT_DATA, result.data!!)
+                    }
+
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                        startForegroundService(serviceIntent)
+                    } else {
+                        startService(serviceIntent)
+                    }
                 } else {
                     Log.w(TAG, "MediaProjection permission denied")
                     Toast.makeText(this, "Screen capture permission denied", Toast.LENGTH_SHORT).show()