Fix: Aufgaben 1-3 implementiert - Stop-Taste GPU-Kill, Slider Swipe-Bug, SecurityException bei Human Expert, detect-changes für workflow_dispatch

Author: Android-PowerUser

.github/workflows/manual.yml

@@ -21,16 +21,7 @@ jobs:
     - name: Detect changed files
       id: changes
       run: |
-        # Bei workflow_dispatch immer alles bauen
-        if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-          echo "app=true" >> $GITHUB_OUTPUT
-          echo "humanoperator=true" >> $GITHUB_OUTPUT
-          echo "shared=true" >> $GITHUB_OUTPUT
-          echo "Manual dispatch - building all modules"
-          exit 0
-        fi
-        
-        # Geänderte Dateien im letzten Commit ermitteln
+        # Geänderte Dateien im letzten Commit ermitteln (gilt für push UND workflow_dispatch)
         CHANGED_FILES=$(git diff --name-only HEAD~1 HEAD 2>/dev/null || echo "")
         
         # Falls kein vorheriger Commit existiert (erster Commit), alles bauen

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

@@ -51,9 +51,47 @@ import android.os.StatFs
 import com.google.ai.sample.feature.multimodal.ModelDownloadManager
 import androidx.compose.runtime.collectAsState
 import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.input.pointer.PointerEventPass
+import androidx.compose.foundation.gestures.awaitEachGesture
+import androidx.compose.foundation.gestures.awaitFirstDown
 import androidx.compose.foundation.gestures.detectHorizontalDragGestures
 import java.io.File
 
+/**
+ * Modifier, der sicherstellt dass horizontale Touch-Events für Slider
+ * nicht von einer übergeordneten LazyColumn abgefangen werden.
+ * Behebt den Swipe-Bug wo das Wischen über Slider in LazyColumn hakelt.
+ *
+ * Konsumiert nur horizontale Drag-Events auf Main-Pass-Ebene,
+ * damit die LazyColumn nicht vorzeitig das Scrollen übernimmt.
+ * Der Slider selbst behält die volle Kontrolle über die Interaktion.
+ */
+fun Modifier.sliderFriendly(): Modifier = this.pointerInput(Unit) {
+    awaitEachGesture {
+        // Ersten Touch abwarten (keine Konsumation, nur beobachten)
+        val down = awaitFirstDown(requireUnconsumed = false)
+        var lastX = down.position.x
+        var isDraggingHorizontally = false
+
+        // Weitere Pointer-Events beobachten
+        do {
+            val event = awaitPointerEvent(pass = PointerEventPass.Main)
+            val change = event.changes.firstOrNull() ?: break
+
+            val dx = kotlin.math.abs(change.position.x - lastX)
+            val dy = kotlin.math.abs(change.position.y - change.previousPosition.y)
+
+            // Wenn horizontale Bewegung dominiert, konsumiere den Event
+            // damit die LazyColumn nicht vertikal scrollt
+            if (dx > dy || isDraggingHorizontally) {
+                isDraggingHorizontally = true
+                change.consume()
+            }
+            lastX = change.position.x
+        } while (event.changes.any { it.pressed })
+    }
+}
+
 data class MenuItem(
     val routeId: String,
     val titleResId: Int,
@@ -357,7 +395,7 @@ fun MenuScreen(
                                 },
                                 valueRange = 0f..2f,
                                 steps = 0,
-                                modifier = Modifier.fillMaxWidth()
+                                modifier = Modifier.fillMaxWidth().sliderFriendly()
                             )
 
                             Spacer(modifier = Modifier.height(8.dp))
@@ -380,7 +418,7 @@ fun MenuScreen(
                                 },
                                 valueRange = 0f..1f,
                                 steps = 0,
-                                modifier = Modifier.fillMaxWidth()
+                                modifier = Modifier.fillMaxWidth().sliderFriendly()
                             )
 
                             Spacer(modifier = Modifier.height(8.dp))
@@ -403,7 +441,7 @@ fun MenuScreen(
                                 },
                                 valueRange = 0f..100f,
                                 steps = 0,
-                                modifier = Modifier.fillMaxWidth()
+                                modifier = Modifier.fillMaxWidth().sliderFriendly()
                             )
 
                             if (selectedModel == ModelOption.GEMMA_3N_E4B_IT) {

app/src/main/kotlin/com/google/ai/sample/feature/multimodal/PhotoReasoningScreen.kt

@@ -172,6 +172,8 @@ internal fun PhotoReasoningRoute(
     val isInitialized by viewModel.isInitialized.collectAsState()
     val modelName by viewModel.modelNameState.collectAsState()
     val userInput by viewModel.userInput.collectAsState()
+    val isGenerationRunning by viewModel.isGenerationRunningFlow.collectAsState()
+    val isOfflineGpuModelLoaded by viewModel.isOfflineGpuModelLoadedFlow.collectAsState()
 
     // Hoisted: var showNotificationRationaleDialog by rememberSaveable { mutableStateOf(false) }
     // This state will now be managed in PhotoReasoningRoute and passed down.
@@ -248,12 +250,12 @@ internal fun PhotoReasoningRoute(
         },
         isKeyboardOpen = isKeyboardOpen,
         onStopClicked = { viewModel.onStopClicked() },
-        // showNotificationRationaleDialog = showNotificationRationaleDialogStateInRoute, // Removed
-        // onShowNotificationRationaleDialogChange = { showNotificationRationaleDialogStateInRoute = it }, // Removed
-        isInitialized = isInitialized, // Pass the collected state
+        isInitialized = isInitialized,
         modelName = modelName,
         userQuestion = userInput,
-        onUserQuestionChanged = { viewModel.updateUserInput(it) }
+        onUserQuestionChanged = { viewModel.updateUserInput(it) },
+        isGenerationRunning = isGenerationRunning,
+        isOfflineGpuModelLoaded = isOfflineGpuModelLoaded
     )
 }
 
@@ -274,12 +276,12 @@ fun PhotoReasoningScreen(
     onClearChatHistory: () -> Unit = {},
     isKeyboardOpen: Boolean,
     onStopClicked: () -> Unit = {},
-    // showNotificationRationaleDialog: Boolean, // Removed
-    // onShowNotificationRationaleDialogChange: (Boolean) -> Unit, // Removed
-    isInitialized: Boolean = true, // Added parameter with default for preview
+    isInitialized: Boolean = true,
     modelName: String = "",
     userQuestion: String = "",
-    onUserQuestionChanged: (String) -> Unit = {}
+    onUserQuestionChanged: (String) -> Unit = {},
+    isGenerationRunning: Boolean = false,
+    isOfflineGpuModelLoaded: Boolean = false
 ) {
     val imageUris = rememberSaveable(saver = UriSaver()) { mutableStateListOf() }
     var isSystemMessageFocused by rememberSaveable { mutableStateOf(false) }
@@ -499,11 +501,9 @@ fun PhotoReasoningScreen(
             )
         }
 
-        // Task 18: Always show Stop button for offline model to allow manual closing
-        val showStopButton = modelName == "gemma-3n-e4b-it" || uiState is PhotoReasoningUiState.Loading
-        
-        val isGenerating = (uiState is PhotoReasoningUiState.Loading) && (messages.lastOrNull()?.isPending == true)
-        val showTextFieldRow = !isGenerating
+        val showStopButton = isGenerationRunning || isOfflineGpuModelLoaded
+        val stopButtonText = if (isGenerationRunning) "Stop" else "Modell entladen"
+        val showTextFieldRow = !isGenerationRunning
 
         if (showTextFieldRow) {
             Card(modifier = Modifier.fillMaxWidth()) {
@@ -574,10 +574,18 @@ fun PhotoReasoningScreen(
             } // Closes Card
         }
 
-        // Task 1: Stop button is independent and below the text field
+        // Stop button: zeigt 'Stop' bei aktiver Generierung, 'Modell entladen' bei geladenem GPU-Modell
         if (showStopButton) {
             Spacer(modifier = Modifier.height(8.dp))
-            StopButton(onClick = onStopClicked)
+            Button(
+                onClick = onStopClicked,
+                colors = ButtonDefaults.buttonColors(containerColor = Color.Red),
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(8.dp)
+            ) {
+                Text(stopButtonText, color = Color.White)
+            }
         }
         }
 

app/src/main/kotlin/com/google/ai/sample/feature/multimodal/PhotoReasoningViewModel.kt

@@ -114,6 +114,12 @@ class PhotoReasoningViewModel(
 
     private val _showStopNotificationFlow = MutableStateFlow(false)
     val showStopNotificationFlow: StateFlow<Boolean> = _showStopNotificationFlow.asStateFlow()
+
+    private val _isGenerationRunningFlow = MutableStateFlow(false)
+    val isGenerationRunningFlow: StateFlow<Boolean> = _isGenerationRunningFlow.asStateFlow()
+
+    private val _isOfflineGpuModelLoadedFlow = MutableStateFlow(false)
+    val isOfflineGpuModelLoadedFlow: StateFlow<Boolean> = _isOfflineGpuModelLoadedFlow.asStateFlow()
 
     // Keep track of the latest screenshot URI
     private var latestScreenshotUri: Uri? = null
@@ -389,11 +395,32 @@ class PhotoReasoningViewModel(
         }
     }
 
+    private fun isGenerationRunning(): Boolean {
+        val lastMessage = _chatState.getAllMessages().lastOrNull()
+        val hasPendingModelMessage =
+            lastMessage?.participant == PhotoParticipant.MODEL && lastMessage.isPending
+        val hasActiveJob =
+            currentReasoningJob?.isActive == true || commandProcessingJob?.isActive == true
+        return hasPendingModelMessage || hasActiveJob
+    }
+
+    private fun isOfflineGpuModelLoaded(): Boolean {
+        return com.google.ai.sample.GenerativeAiViewModelFactory.getCurrentModel() == ModelOption.GEMMA_3N_E4B_IT &&
+            com.google.ai.sample.GenerativeAiViewModelFactory.getBackend() == InferenceBackend.GPU &&
+            llmInference != null
+    }
+
+    private fun refreshStopButtonState() {
+        _isGenerationRunningFlow.value = isGenerationRunning()
+        _isOfflineGpuModelLoadedFlow.value = isOfflineGpuModelLoaded()
+    }
+
     fun closeOfflineModel() {
         try {
             llmInference?.close()
             llmInference = null
             System.gc()
+            refreshStopButtonState()
             Log.d(TAG, "Offline model explicitly closed to free RAM")
         } catch (e: Exception) {
             Log.w(TAG, "Error closing offline model", e)
@@ -1073,18 +1100,27 @@ class PhotoReasoningViewModel(
     }
 
     fun onStopClicked() {
-        if (isLiveMode) {
-            // For live mode, close the connection
-            liveApiManager?.close()
+        _showStopNotificationFlow.value = false
+
+        val generationRunning = isGenerationRunning()
+
+        // Kein aktiver Lauf: zweiter Klick => Modell entladen, keine Chat-Nachricht
+        if (!generationRunning) {
+            if (isOfflineGpuModelLoaded()) {
+                closeOfflineModel()
+                Log.d(TAG, "Stop clicked while idle: offline GPU model closed to free RAM")
+            } else {
+                refreshStopButtonState()
+                Log.d(TAG, "Stop clicked while idle: nothing to stop and no offline GPU model loaded")
+            }
+            return
         }
 
-        // Close offline model instance to force stop generation or just release RAM
-        if (com.google.ai.sample.GenerativeAiViewModelFactory.getCurrentModel() == ModelOption.GEMMA_3N_E4B_IT) {
-            closeOfflineModel()
+        // Aktive Generierung: nur stoppen, Modell NICHT direkt schließen
+        if (isLiveMode) {
+            liveApiManager?.close()
         }
 
-        // Rest of the existing onStopClicked code
-        _showStopNotificationFlow.value = false
         stopExecutionFlag.set(true)
         currentReasoningJob?.cancel()
         commandProcessingJob?.cancel()
@@ -1103,31 +1139,28 @@ class PhotoReasoningViewModel(
                 )
             )
         } else if (lastMessage != null && lastMessage.participant == PhotoParticipant.MODEL && !lastMessage.isPending) {
-             // If the last message was a successful model response, update it.
-            messages[messages.size - 1] = lastMessage.copy(text = lastMessage.text + "\n\n[Stopped by user]")
+            messages[messages.lastIndex] =
+                lastMessage.copy(text = lastMessage.text + "\n\n[Stopped by user]")
         } else {
-            // If no relevant model message, or last message was user/error, add a new model message
-             messages.add(
+            messages.add(
                 PhotoReasoningMessage(
                     text = statusMessage,
                     participant = PhotoParticipant.MODEL,
                     isPending = false
                 )
             )
         }
+
         _chatState.setAllMessages(messages)
         _chatMessagesFlow.value = _chatState.getAllMessages()
-
-
-        // _uiState.value = PhotoReasoningUiState.Stopped; // No longer setting this as the final state.
-        _commandExecutionStatus.value = "" // Set to empty string
+        _commandExecutionStatus.value = ""
         _detectedCommands.value = emptyList()
         Log.d(TAG, "Stop clicked, operations cancelled, command status cleared.")
 
-        // Set a success state to indicate the stop operation itself was successful
-        // and the UI can return to an idle/interactive state.
         _uiState.value = PhotoReasoningUiState.Success("Operation stopped.")
         Log.d(TAG, "UI updated to Success state after stop.")
+
+        refreshStopButtonState()
     }
 
     /**
@@ -1328,42 +1361,40 @@ class PhotoReasoningViewModel(
                 viewModelScope.launch(Dispatchers.Main) {
                     replaceAiMessageText("Expert found! Requesting screen capture permission...", isPending = true)
 
-                    // Request a fresh MediaProjection specifically for WebRTC
-                    // This does NOT start ScreenCaptureService - avoids token reuse crash
+                    // Request a fresh MediaProjection specifically for WebRTC.
+                    // MainActivity startet bereits ACTION_KEEP_ALIVE_FOR_WEBRTC BEVOR dieser Callback gerufen wird.
+                    // Kein weiterer startForegroundService()-Aufruf nötig - verhindert ForegroundServiceDidNotStartInTimeException.
                     val mainActivity = MainActivity.getInstance()
                     if (mainActivity != null) {
                         mainActivity.requestMediaProjectionForWebRTC { resultCode, resultData ->
-                            Log.d(TAG, "WebRTC MediaProjection granted. Starting foreground service first, then screen capture.")
+                            Log.d(TAG, "WebRTC MediaProjection granted. Service läuft bereits via KEEP_ALIVE. Starte Screen Capture.")
                             replaceAiMessageText("Establishing video connection...", isPending = true)
 
-                            // Task 1: Only start ScreenCaptureService if not already running
-                            // This prevents ForegroundServiceDidNotStartInTimeException
-                            if (!ScreenCaptureService.isRunning()) {
-                                val serviceIntent = Intent(mainActivity, ScreenCaptureService::class.java).apply {
-                                    action = ScreenCaptureService.ACTION_START_CAPTURE
-                                    putExtra(ScreenCaptureService.EXTRA_RESULT_CODE, resultCode)
-                                    putExtra(ScreenCaptureService.EXTRA_RESULT_DATA, resultData)
-                                    putExtra(ScreenCaptureService.EXTRA_TAKE_SCREENSHOT_ON_START, false)
-                                }
-                                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                                    mainActivity.startForegroundService(serviceIntent)
-                                } else {
-                                    mainActivity.startService(serviceIntent)
-                                }
-                            } else {
-                                Log.d(TAG, "ScreenCaptureService already running, skipping service start.")
-                            }
+                            // KEIN startForegroundService() hier - MainActivity hat bereits ACTION_KEEP_ALIVE_FOR_WEBRTC gesendet.
+                            // Das vermeidet doppelten Service-Start und ForegroundServiceDidNotStartInTimeException.
 
-                            // Delay to ensure foreground service is up before WebRTC capture
                             viewModelScope.launch {
-                                delay(500)
-                                // Start screen capture for WebRTC with fresh permission data
-                                webRTCSender?.startScreenCapture(resultData)
-                                webRTCSender?.createPeerConnection()
-                                
-                                // Create Offer
-                                webRTCSender?.createOffer { sdp ->
-                                    signalingClient?.sendOffer(sdp)
+                                // Kurze Verzögerung zur Stabilisierung des Foreground-Services
+                                delay(300)
+                                try {
+                                    // Start screen capture for WebRTC with fresh permission data
+                                    webRTCSender?.startScreenCapture(resultData)
+                                    webRTCSender?.createPeerConnection()
+                                    
+                                    // Create Offer
+                                    webRTCSender?.createOffer { sdp ->
+                                        signalingClient?.sendOffer(sdp)
+                                    }
+                                } catch (e: SecurityException) {
+                                    Log.e(TAG, "SecurityException beim WebRTC Screen Capture - MediaProjection Token ungültig?", e)
+                                    viewModelScope.launch(Dispatchers.Main) {
+                                        _uiState.value = PhotoReasoningUiState.Error("Screen capture permission expired. Please try again.")
+                                    }
+                                } catch (e: Exception) {
+                                    Log.e(TAG, "Fehler beim Starten des WebRTC Screen Capture", e)
+                                    viewModelScope.launch(Dispatchers.Main) {
+                                        _uiState.value = PhotoReasoningUiState.Error("Video connection failed: ${e.message}")
+                                    }
                                 }
                             }
                         }