I need to request foreground service permission for media projection.

Author: google-labs-jules[bot]

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

@@ -21,38 +21,6 @@ enum class ModelOption(val displayName: String, val modelName: String) {
 }
 
 val GenerativeViewModelFactory = object : ViewModelProvider.Factory {
-    // Current selected model name
-    private var currentModelName = ModelOption.GEMINI_FLASH_PREVIEW.modelName
-    
-    /**
-     * Set the model to high reasoning capability (gemini-2.5-pro-preview-03-25)
-     */
-    fun highReasoningModel() {
-        currentModelName = ModelOption.GEMINI_PRO.modelName
-    }
-    
-    /**
-     * Set the model to low reasoning capability (gemini-2.0-flash-lite)
-     */
-    fun lowReasoningModel() {
-        currentModelName = ModelOption.GEMINI_FLASH_LITE.modelName
-    }
-    
-    /**
-     * Set the model to a specific model option
-     */
-    fun setModel(modelOption: ModelOption) {
-        currentModelName = modelOption.modelName
-    }
-    
-    /**
-     * Get the current model option
-     */
-    fun getCurrentModel(): ModelOption {
-        return ModelOption.values().find { it.modelName == currentModelName } 
-            ?: ModelOption.GEMINI_FLASH_LITE
-    }
-    
     override fun <T : ViewModel> create(
         viewModelClass: Class<T>,
         extras: CreationExtras
@@ -63,106 +31,46 @@ val GenerativeViewModelFactory = object : ViewModelProvider.Factory {
 
         // Get the application context from extras
         val application = checkNotNull(extras[ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY])
-        
+
         // Get the API key from MainActivity
         val mainActivity = MainActivity.getInstance()
         val apiKey = mainActivity?.getCurrentApiKey() ?: ""
-        
+
         if (apiKey.isEmpty()) {
             throw IllegalStateException("API key is not available. Please set an API key.")
         }
 
         return with(viewModelClass) {
             when {
-
                 isAssignableFrom(PhotoReasoningViewModel::class.java) -> {
+                    val currentModel = GenerativeAiViewModelFactory.getCurrentModel()
                     // Initialize a GenerativeModel with the currently selected model
                     // for multimodal text generation
                     val generativeModel = GenerativeModel(
-                        modelName = currentModelName,
+                        modelName = currentModel.modelName,
                         apiKey = apiKey,
                         generationConfig = config
                     )
                     // Pass the ApiKeyManager to the ViewModel for key rotation
                     val apiKeyManager = ApiKeyManager.getInstance(application)
-                    PhotoReasoningViewModel(generativeModel, apiKeyManager)
+                    PhotoReasoningViewModel(generativeModel, currentModel.modelName)
                 }
 
-
                 else ->
                     throw IllegalArgumentException("Unknown ViewModel class: ${viewModelClass.name}")
             }
         } as T
     }
 }
 
-// Add companion object with static methods for easier access
 object GenerativeAiViewModelFactory {
-    // Current selected model name - duplicated from GenerativeViewModelFactory
-    private var currentModelName = ModelOption.GEMINI_FLASH_PREVIEW.modelName
-    
-    /**
-     * Set the model to high reasoning capability (gemini-2.5-pro-preview-03-25)
-     */
-    fun highReasoningModel() {
-        currentModelName = ModelOption.GEMINI_PRO.modelName
-        // Also update the original factory to keep them in sync
-        (GenerativeViewModelFactory as ViewModelProvider.Factory).apply {
-            if (this is ViewModelProvider.Factory) {
-                try {
-                    val field = this.javaClass.getDeclaredField("currentModelName")
-                    field.isAccessible = true
-                    field.set(this, currentModelName)
-                } catch (e: Exception) {
-                    // Fallback if reflection fails
-                }
-            }
-        }
-    }
-    
-    /**
-     * Set the model to low reasoning capability (gemini-2.0-flash-lite)
-     */
-    fun lowReasoningModel() {
-        currentModelName = ModelOption.GEMINI_FLASH_LITE.modelName
-        // Also update the original factory to keep them in sync
-        (GenerativeViewModelFactory as ViewModelProvider.Factory).apply {
-            if (this is ViewModelProvider.Factory) {
-                try {
-                    val field = this.javaClass.getDeclaredField("currentModelName")
-                    field.isAccessible = true
-                    field.set(this, currentModelName)
-                } catch (e: Exception) {
-                    // Fallback if reflection fails
-                }
-            }
-        }
-    }
-    
-    /**
-     * Set the model to a specific model option
-     */
+    private var currentModel: ModelOption = ModelOption.GEMINI_FLASH_PREVIEW
+
     fun setModel(modelOption: ModelOption) {
-        currentModelName = modelOption.modelName
-        // Also update the original factory to keep them in sync
-        (GenerativeViewModelFactory as ViewModelProvider.Factory).apply {
-            if (this is ViewModelProvider.Factory) {
-                try {
-                    val field = this.javaClass.getDeclaredField("currentModelName")
-                    field.isAccessible = true
-                    field.set(this, currentModelName)
-                } catch (e: Exception) {
-                    // Fallback if reflection fails
-                }
-            }
-        }
+        currentModel = modelOption
     }
-    
-    /**
-     * Get the current model option
-     */
+
     fun getCurrentModel(): ModelOption {
-        return ModelOption.values().find { it.modelName == currentModelName } 
-            ?: ModelOption.GEMINI_FLASH_LITE
+        return currentModel
     }
 }

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

@@ -67,6 +67,7 @@ import androidx.compose.ui.unit.dp
 import androidx.compose.ui.window.Dialog
 import androidx.core.content.ContextCompat
 import androidx.lifecycle.lifecycleScope
+import android.Manifest
 import androidx.navigation.NavHostController
 import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.composable
@@ -122,6 +123,7 @@ class MainActivity : ComponentActivity() {
 
     private lateinit var navController: NavHostController
     private var isProcessingExplicitScreenshotRequest: Boolean = false
+    private var onMediaProjectionPermissionGranted: (() -> Unit)? = null
 
     private val screenshotRequestHandler = object : BroadcastReceiver() {
         override fun onReceive(context: Context?, intent: Intent?) {
@@ -166,10 +168,19 @@ class MainActivity : ComponentActivity() {
 
     // Permission Launchers
     private lateinit var requestNotificationPermissionLauncher: ActivityResultLauncher<String>
+    private lateinit var requestForegroundServicePermissionLauncher: ActivityResultLauncher<String>
     // private val requestPermissionLauncher = registerForActivityResult(...) // Deleted
 
-    private fun requestMediaProjectionPermission() {
+    fun requestMediaProjectionPermission(onGranted: (() -> Unit)? = null) {
         Log.d(TAG, "Requesting MediaProjection permission")
+        onMediaProjectionPermissionGranted = onGranted
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            if (ContextCompat.checkSelfPermission(this, Manifest.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION) != PackageManager.PERMISSION_GRANTED) {
+                requestForegroundServicePermissionLauncher.launch(Manifest.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION)
+            }
+        }
+
         // Ensure mediaProjectionManager is initialized before using it.
         // This should be guaranteed by its placement in onCreate.
         if (!::mediaProjectionManager.isInitialized) {
@@ -222,6 +233,11 @@ class MainActivity : ComponentActivity() {
     val isAccessibilityServiceEnabledFlow: StateFlow<Boolean> = _isAccessibilityServiceEnabled.asStateFlow()
     // END: Added for Accessibility Service Status
 
+    // START: Added for MediaProjection Permission Status
+    private val _isMediaProjectionPermissionGranted = MutableStateFlow(false)
+    val isMediaProjectionPermissionGrantedFlow: StateFlow<Boolean> = _isMediaProjectionPermissionGranted.asStateFlow()
+    // END: Added for MediaProjection Permission Status
+
     // SharedPreferences for first launch info
     private lateinit var prefs: SharedPreferences
     private var showFirstLaunchInfoDialog by mutableStateOf(false)
@@ -444,6 +460,9 @@ class MainActivity : ComponentActivity() {
                         Log.d(TAG, "Resetting isProcessingExplicitScreenshotRequest flag after successful explicit grant.")
                         this@MainActivity.isProcessingExplicitScreenshotRequest = false
                     }
+                    _isMediaProjectionPermissionGranted.value = true
+                    onMediaProjectionPermissionGranted?.invoke()
+                    onMediaProjectionPermissionGranted = null
                 } else {
                     Log.w(TAG, "MediaProjection permission denied or cancelled by user.")
                     Toast.makeText(this, "Screen capture permission denied", Toast.LENGTH_SHORT).show()
@@ -452,6 +471,7 @@ class MainActivity : ComponentActivity() {
                         Log.d(TAG, "Resetting isProcessingExplicitScreenshotRequest flag after explicit denial.")
                         this@MainActivity.isProcessingExplicitScreenshotRequest = false
                     }
+                    _isMediaProjectionPermissionGranted.value = false
                 }
             }
 
@@ -572,6 +592,14 @@ class MainActivity : ComponentActivity() {
             }
         }
 
+        requestForegroundServicePermissionLauncher = registerForActivityResult(ActivityResultContracts.RequestPermission()) { isGranted: Boolean ->
+            if (isGranted) {
+                Toast.makeText(this, "Foreground service permission granted.", Toast.LENGTH_SHORT).show()
+            } else {
+                Toast.makeText(this, "Foreground service permission denied. The app may not function correctly.", Toast.LENGTH_LONG).show()
+            }
+        }
+
         if (photoReasoningViewModel != null) {
             lifecycleScope.launch {
                 photoReasoningViewModel!!.showStopNotificationFlow.collect { show ->
@@ -589,11 +617,6 @@ class MainActivity : ComponentActivity() {
             Log.w(TAG, "photoReasoningViewModel is null at the end of onCreate. Notification flow collection might be delayed or not start if VM is set much later or never.")
         }
 
-            Log.d(TAG, "onCreate: Scheduling MediaProjection permission request")
-            Handler(Looper.getMainLooper()).postDelayed({
-                Log.d(TAG, "onCreate: Calling requestMediaProjectionPermission")
-                requestMediaProjectionPermission()
-            }, 1000) // 1 second delay to ensure everything is initialized
     }
 
     fun showStopOperationNotification() {

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

@@ -214,23 +214,37 @@ class ScreenOperatorAccessibilityService : AccessibilityService() {
                 true // Asynchronous
             }
             is Command.TakeScreenshot -> {
-                Log.d(TAG, "Command.TakeScreenshot: Capturing screen info and sending request broadcast to MainActivity.")
-                this.showToast("Preparing screenshot...", false) // Updated toast message
+                val modelName = GenerativeAiViewModelFactory.getCurrentModel().modelName
+                if (modelName == "gemma-3n-e4b-it") {
+                    Log.d(TAG, "Command.TakeScreenshot: Model is gemma-3n-e4b-it, capturing screen info only.")
+                    this.showToast("Capturing screen info...", false)
+                    val screenInfo = captureScreenInformation()
+                    val mainActivity = MainActivity.getInstance()
+                    mainActivity?.getPhotoReasoningViewModel()?.addScreenshotToConversation(
+                        Uri.EMPTY,
+                        applicationContext,
+                        screenInfo
+                    )
+                    false
+                } else {
+                    Log.d(TAG, "Command.TakeScreenshot: Capturing screen info and sending request broadcast to MainActivity.")
+                    this.showToast("Preparing screenshot...", false) // Updated toast message
 
-                val screenInfo = captureScreenInformation() // Capture fresh screen info
+                    val screenInfo = captureScreenInformation() // Capture fresh screen info
 
-                val intent = Intent(MainActivity.ACTION_REQUEST_MEDIAPROJECTION_SCREENSHOT).apply {
-                    putExtra(MainActivity.EXTRA_SCREEN_INFO, screenInfo)
-                    // Set package to ensure only our app's receiver gets it
-                    `package` = applicationContext.packageName
-                }
-                applicationContext.sendBroadcast(intent)
-                Log.d(TAG, "Sent broadcast ACTION_REQUEST_MEDIAPROJECTION_SCREENSHOT to MainActivity with screenInfo.")
+                    val intent = Intent(MainActivity.ACTION_REQUEST_MEDIAPROJECTION_SCREENSHOT).apply {
+                        putExtra(MainActivity.EXTRA_SCREEN_INFO, screenInfo)
+                        // Set package to ensure only our app's receiver gets it
+                        `package` = applicationContext.packageName
+                    }
+                    applicationContext.sendBroadcast(intent)
+                    Log.d(TAG, "Sent broadcast ACTION_REQUEST_MEDIAPROJECTION_SCREENSHOT to MainActivity with screenInfo.")
 
-                // The command is considered "handled" once the broadcast is sent.
-                // MainActivity and ScreenCaptureService will handle the rest asynchronously.
-                // Return false to allow the command queue to proceed immediately.
-                false
+                    // The command is considered "handled" once the broadcast is sent.
+                    // MainActivity and ScreenCaptureService will handle the rest asynchronously.
+                    // Return false to allow the command queue to proceed immediately.
+                    false
+                }
             }
             is Command.PressHomeButton -> {
                 Log.d(TAG, "Pressing home button")
@@ -325,13 +339,13 @@ class ScreenOperatorAccessibilityService : AccessibilityService() {
             is Command.UseHighReasoningModel -> {
                 Log.d(TAG, "Switching to high reasoning model (gemini-2.5-pro-preview-03-25)")
                 this.showToast("Switching to more powerful model (gemini-2.5-pro-preview-03-25)", false)
-                GenerativeAiViewModelFactory.highReasoningModel()
+                GenerativeAiViewModelFactory.setModel(ModelOption.GEMINI_PRO)
                 false // Synchronous
             }
             is Command.UseLowReasoningModel -> {
                 Log.d(TAG, "Switching to low reasoning model (gemini-2.0-flash-lite)")
                 this.showToast("Switching to faster model (gemini-2.0-flash-lite)", false)
-                GenerativeAiViewModelFactory.lowReasoningModel()
+                GenerativeAiViewModelFactory.setModel(ModelOption.GEMINI_FLASH_LITE)
                 false // Synchronous
             }
             is Command.PressEnterKey -> {