docs: Android-Skills und Dev-Skript hinzufügen

Drei Copilot-Skills für den Android-Workflow:
- android-build: Gradle-Build, bekannte Issues (OneDrive, stderr)
- android-emulator: AVD-Verwaltung, Boot-Handling, S24Ultra_API35
- android-device: Physisches Gerät (Samsung S24 Ultra), USB/Wireless ADB

Zentrales PowerShell-Skript android-dev.ps1 mit 13 Aktionen:
build, clean, clean-build, emulator-start/stop, install-emulator/device,
launch, deploy-emulator/device, logcat, devices, screenshot.
Getestet: build, deploy-emulator, screenshot, emulator-stop.
This commit is contained in:
Jens Reinemann 2026-05-13 16:57:24 +02:00
parent 85f3084ffa
commit 6116a6c6ef
4 changed files with 771 additions and 0 deletions

107
.github/skills/android-build/SKILL.md vendored Normal file
View file

@ -0,0 +1,107 @@
---
name: android-build
description: "Android-App bauen (assembleDebug/Release), Gradle-Kommandos, häufige Build-Fehler beheben. Verwende diesen Skill für alles rund um Kompilierung, Gradle, Dependency-Management und Build-Konfiguration. Trigger-Phrasen: 'build', 'bauen', 'kompilieren', 'assembleDebug', 'Gradle', 'dependency', 'APK'."
---
# Skill: Android Build
Baut die Krisenvorrat-Android-App mit Gradle. Handhabt bekannte Fallstricke auf diesem Windows/OneDrive-Setup.
---
## Voraussetzungen
| Komponente | Pfad / Wert |
| -------------- | -------------------------------------------------------- |
| Android SDK | `C:\Users\JensR\AppData\Local\Android\Sdk` |
| ANDROID_HOME | User-Umgebungsvariable (persistent gesetzt) |
| local.properties | `sdk.dir=C\\:\\\\Users\\\\JensR\\\\AppData\\\\Local\\\\Android\\\\Sdk` |
| Java | OpenJDK 21 (im PATH) |
| Gradle | 8.11.1 (via Wrapper) |
| Kotlin | 2.1.10 |
| AGP | 8.7.3 |
---
## Build-Kommandos
Verwende **immer** das `android-dev.ps1`-Skript statt roher Gradle-Aufrufe:
```powershell
# Debug-Build (Standard)
& ".github/skills/android-build/android-dev.ps1" -Action build
# Clean + Build (bei OneDrive-Locks oder korruptem Cache)
& ".github/skills/android-build/android-dev.ps1" -Action clean-build
# Nur clean
& ".github/skills/android-build/android-dev.ps1" -Action clean
```
### Direkter Gradle-Aufruf (Fallback)
Falls das Skript nicht verfügbar ist:
```powershell
$env:ANDROID_HOME = "C:\Users\JensR\AppData\Local\Android\Sdk"
cd "c:\Users\JensR\OneDrive\Code\krisenvorrat"
.\gradlew.bat assembleDebug 2>&1 | Out-String
```
**Wichtig:** Niemals `.\gradlew.bat ... 2>&1` ohne `| Out-String` verwenden PowerShell interpretiert stderr-Warnungen sonst als Fehler und zeigt Exit-Code 1, obwohl Gradle `BUILD SUCCESSFUL` meldet.
---
## Bekannte Probleme
### 1. OneDrive sperrt Build-Dateien (`AccessDeniedException`)
OneDrive synchronisiert das `build/`-Verzeichnis und sperrt dabei Dateien.
**Lösung:**
```powershell
Remove-Item "app\build" -Recurse -Force -ErrorAction SilentlyContinue
Remove-Item "build" -Recurse -Force -ErrorAction SilentlyContinue
# Dann erneut bauen
```
Das `android-dev.ps1`-Skript macht dies automatisch bei `-Action clean-build`.
### 2. PowerShell zeigt Exit-Code 1 trotz BUILD SUCCESSFUL
Gradle gibt Deprecation-Warnungen auf stderr aus. PowerShell wertet das als Fehler.
**Lösung:** Prüfe den Gradle-Output auf `BUILD SUCCESSFUL`, nicht den Exit-Code.
### 3. `Batchvorgang abbrechen (J/N)?`
Tritt auf, wenn `gradlew.bat` ein Ctrl+C-Signal empfängt (z.B. durch Terminal-Timeout).
**Lösung:** Verwende `| Out-String` und ausreichend Timeout (600s+). Das `android-dev.ps1`-Skript umgeht dieses Problem.
### 4. `android.useAndroidX` fehlt
```
gradle.properties muss enthalten:
android.useAndroidX=true
```
---
## APK-Ausgabe
| Variante | Pfad |
| -------- | --------------------------------------------- |
| Debug | `app/build/outputs/apk/debug/app-debug.apk` |
| Release | `app/build/outputs/apk/release/app-release.apk` |
---
## Terminal-Aufruf-Konventionen
```powershell
# Immer so aufrufen:
run_in_terminal mode=sync timeout=600000
```
Gradle-Builds dauern beim ersten Mal 25 Minuten (Daemon-Start + Download). Folge-Builds: 1030 Sekunden.

View file

@ -0,0 +1,346 @@
<#
.SYNOPSIS
Zentrales Entwicklungsskript für die Krisenvorrat Android-App.
.DESCRIPTION
Handhabt Build, Deploy und Emulator-Operationen.
Behandelt bekannte Komplikationen (OneDrive-Locks, Boot-Delays, stderr-Warnungen).
.PARAMETER Action
Die auszuführende Aktion:
build - Debug-APK bauen
clean - Build-Verzeichnisse löschen
clean-build - Clean + Build in einem Schritt
emulator-start - Emulator starten und auf Boot warten
emulator-stop - Emulator beenden
install-emulator - APK auf Emulator installieren
install-device - APK auf physisches Gerät installieren
launch - App starten (auf dem aktiven Ziel)
deploy-emulator - Build + Install + Launch auf Emulator
deploy-device - Build + Install + Launch auf physisches Gerät
logcat - App-Logcat anzeigen (Ctrl+C zum Beenden)
devices - Verbundene Geräte auflisten
screenshot - Screenshot vom aktiven Gerät speichern
.PARAMETER Target
Zielgerät: 'emulator' (Standard) oder 'device'.
.EXAMPLE
& ".github/skills/android-build/android-dev.ps1" -Action build
& ".github/skills/android-build/android-dev.ps1" -Action deploy-emulator
& ".github/skills/android-build/android-dev.ps1" -Action logcat -Target device
#>
param(
[Parameter(Mandatory)]
[ValidateSet(
'build', 'clean', 'clean-build',
'emulator-start', 'emulator-stop',
'install-emulator', 'install-device',
'launch',
'deploy-emulator', 'deploy-device',
'logcat', 'devices', 'screenshot'
)]
[string]$Action,
[ValidateSet('emulator', 'device')]
[string]$Target = 'emulator'
)
$ErrorActionPreference = 'Stop'
# --- Konfiguration ---
$SDK_ROOT = "C:\Users\JensR\AppData\Local\Android\Sdk"
$ADB = "$SDK_ROOT\platform-tools\adb.exe"
$EMULATOR = "$SDK_ROOT\emulator\emulator.exe"
$PROJECT_DIR = $PSScriptRoot | Split-Path | Split-Path | Split-Path # .github/skills/android-build → repo root
$APK_PATH = "$PROJECT_DIR\app\build\outputs\apk\debug\app-debug.apk"
$AVD_NAME = "S24Ultra_API35"
$PACKAGE = "de.krisenvorrat.app"
$ACTIVITY = "$PACKAGE/.MainActivity"
$BOOT_TIMEOUT = 300 # Sekunden (erster Boot eines neuen AVD kann >2min dauern)
$INSTALL_RETRY = 3
$env:ANDROID_HOME = $SDK_ROOT
# --- Hilfsfunktionen ---
function Write-Step { param([string]$msg) Write-Host ">> $msg" -ForegroundColor Cyan }
function Write-Ok { param([string]$msg) Write-Host "OK $msg" -ForegroundColor Green }
function Write-Err { param([string]$msg) Write-Host "ERR $msg" -ForegroundColor Red }
function Write-Warn { param([string]$msg) Write-Host "WARN $msg" -ForegroundColor Yellow }
function Get-AdbTarget {
if ($Target -eq 'device') { return '-d' }
return '-e'
}
function Test-DeviceConnected {
param([string]$type)
$flag = if ($type -eq 'device') { '-d' } else { '-e' }
try {
$result = & $ADB $flag get-state 2>&1 | Out-String
return ($result.Trim() -eq 'device')
}
catch {
return $false
}
}
function Invoke-Gradle {
param([string[]]$Tasks)
Write-Step "Gradle: $($Tasks -join ' ')"
Push-Location $PROJECT_DIR
try {
$output = & .\gradlew.bat @Tasks 2>&1 | Out-String
$success = $output -match 'BUILD SUCCESSFUL'
$failed = $output -match 'BUILD FAILED'
if ($success) {
$duration = if ($output -match 'in (\d+[ms]\s?\d*\w*)') { $Matches[0] } else { '' }
Write-Ok "BUILD SUCCESSFUL $duration"
return $true
}
elseif ($failed) {
# Fehlerdetails extrahieren
$errorBlock = ($output -split "`n" | Select-String -Pattern "What went wrong|ERROR:|FAILURE:" -Context 0, 5) -join "`n"
Write-Err "BUILD FAILED"
Write-Host $errorBlock -ForegroundColor Red
return $false
}
else {
Write-Warn "Build-Status unklar. Output prüfen:"
Write-Host ($output | Select-Object -Last 20)
return $false
}
}
finally {
Pop-Location
}
}
function Remove-BuildDirs {
Write-Step "Build-Verzeichnisse löschen"
$dirs = @("$PROJECT_DIR\app\build", "$PROJECT_DIR\build")
foreach ($d in $dirs) {
if (Test-Path $d) {
Remove-Item $d -Recurse -Force -ErrorAction SilentlyContinue
if (Test-Path $d) {
Write-Warn "Konnte $d nicht vollständig löschen (OneDrive-Lock?). Versuche erneut..."
Start-Sleep -Seconds 2
Remove-Item $d -Recurse -Force -ErrorAction SilentlyContinue
}
}
}
Write-Ok "Build-Verzeichnisse bereinigt"
}
function Start-Emulator {
# Prüfe ob Emulator bereits läuft
if (Test-DeviceConnected 'emulator') {
Write-Ok "Emulator läuft bereits"
return $true
}
Write-Step "Emulator starten: $AVD_NAME"
Start-Process -FilePath $EMULATOR -ArgumentList "-avd $AVD_NAME -gpu auto" -WindowStyle Normal
Write-Step "Warte auf ADB-Verbindung..."
& $ADB wait-for-device
Write-Step "Warte auf Boot (max ${BOOT_TIMEOUT}s)..."
$elapsed = 0
do {
Start-Sleep -Seconds 5
$elapsed += 5
$boot = (& $ADB -e shell getprop sys.boot_completed 2>$null | Out-String).Trim()
if ($elapsed % 15 -eq 0) { Write-Host " ... ${elapsed}s" -ForegroundColor DarkGray }
} while ($boot -ne "1" -and $elapsed -lt $BOOT_TIMEOUT)
if ($boot -ne "1") {
Write-Err "Emulator-Boot Timeout nach ${BOOT_TIMEOUT}s"
return $false
}
# Extra-Pause für PackageManager-Initialisierung
Write-Step "Warte 5s auf PackageManager..."
Start-Sleep -Seconds 5
Write-Ok "Emulator gebootet nach ${elapsed} Sekunden"
return $true
}
function Install-Apk {
param([string]$targetType)
if (-not (Test-Path $APK_PATH)) {
Write-Err "APK nicht gefunden: $APK_PATH"
Write-Err "Bitte zuerst bauen: -Action build"
return $false
}
$flags = Get-AdbTarget
$apkSize = [math]::Round((Get-Item $APK_PATH).Length / 1MB, 1)
Write-Step "APK installieren ${apkSize} MB auf $targetType"
for ($attempt = 1; $attempt -le $INSTALL_RETRY; $attempt++) {
$result = & $ADB $flags install -r $APK_PATH 2>&1 | Out-String
if ($result -match 'Success') {
Write-Ok "APK installiert"
return $true
}
if ($attempt -lt $INSTALL_RETRY) {
Write-Warn "Install fehlgeschlagen (Versuch $attempt/$INSTALL_RETRY). Warte 5s..."
Start-Sleep -Seconds 5
}
}
Write-Err "APK-Installation fehlgeschlagen nach $INSTALL_RETRY Versuchen:"
Write-Host $result -ForegroundColor Red
return $false
}
function Start-App {
$flags = Get-AdbTarget
Write-Step "App starten: $ACTIVITY"
$result = & $ADB $flags shell am start -n $ACTIVITY 2>&1 | Out-String
if ($result -match 'Error|Exception') {
Write-Err "App-Start fehlgeschlagen:"
Write-Host $result -ForegroundColor Red
return $false
}
Write-Ok "App gestartet"
return $true
}
# --- Aktionen ---
switch ($Action) {
'build' {
$ok = Invoke-Gradle @('assembleDebug')
if ($ok -and (Test-Path $APK_PATH)) {
$size = [math]::Round((Get-Item $APK_PATH).Length / 1MB, 2)
Write-Ok "APK: $APK_PATH - ${size} MB"
}
exit ([int](-not $ok))
}
'clean' {
Remove-BuildDirs
exit 0
}
'clean-build' {
Remove-BuildDirs
$ok = Invoke-Gradle @('assembleDebug')
if ($ok -and (Test-Path $APK_PATH)) {
$size = [math]::Round((Get-Item $APK_PATH).Length / 1MB, 2)
Write-Ok "APK: $APK_PATH - ${size} MB"
}
exit ([int](-not $ok))
}
'emulator-start' {
$ok = Start-Emulator
exit ([int](-not $ok))
}
'emulator-stop' {
Write-Step "Emulator beenden"
& $ADB emu kill 2>$null
Write-Ok "Emulator gestoppt"
exit 0
}
'install-emulator' {
$Target = 'emulator'
if (-not (Test-DeviceConnected 'emulator')) {
Write-Err "Kein Emulator verbunden. Starte mit: -Action emulator-start"
exit 1
}
$ok = Install-Apk 'emulator'
exit ([int](-not $ok))
}
'install-device' {
$Target = 'device'
if (-not (Test-DeviceConnected 'device')) {
Write-Err "Kein physisches Gerät verbunden. USB-Debugging prüfen."
exit 1
}
$ok = Install-Apk 'device'
exit ([int](-not $ok))
}
'launch' {
$ok = Start-App
exit ([int](-not $ok))
}
'deploy-emulator' {
$Target = 'emulator'
$ok = Start-Emulator
if (-not $ok) { exit 1 }
$ok = Invoke-Gradle @('assembleDebug')
if (-not $ok) { exit 1 }
$ok = Install-Apk 'emulator'
if (-not $ok) { exit 1 }
$ok = Start-App
exit ([int](-not $ok))
}
'deploy-device' {
$Target = 'device'
if (-not (Test-DeviceConnected 'device')) {
Write-Err "Kein physisches Gerät verbunden."
exit 1
}
$ok = Invoke-Gradle @('assembleDebug')
if (-not $ok) { exit 1 }
$ok = Install-Apk 'device'
if (-not $ok) { exit 1 }
$ok = Start-App
exit ([int](-not $ok))
}
'logcat' {
$flags = Get-AdbTarget
Write-Step "Logcat für $PACKAGE (Ctrl+C zum Beenden)"
$pid = & $ADB $flags shell pidof $PACKAGE 2>$null
if ($pid) {
& $ADB $flags logcat --pid=$pid -v time
}
else {
Write-Warn "App läuft nicht. Zeige alle Logs mit Tag-Filter..."
& $ADB $flags logcat -v time *:W
}
}
'devices' {
Write-Step "Verbundene Geräte"
& $ADB devices -l
}
'screenshot' {
$flags = Get-AdbTarget
$timestamp = Get-Date -Format "yyyyMMdd-HHmmss"
$filename = "screenshot-$timestamp.png"
Write-Step "Screenshot: $filename"
$screenshotPath = "$PROJECT_DIR\$filename"
& $ADB $flags shell screencap -p "/sdcard/$filename"
$ErrorActionPreference = 'Continue'
$pullResult = & $ADB $flags pull "/sdcard/$filename" $screenshotPath 2>&1 | Out-String
& $ADB $flags shell rm "/sdcard/$filename" 2>&1 | Out-Null
$ErrorActionPreference = 'Stop'
if (Test-Path $screenshotPath) {
Write-Ok "Gespeichert: $filename"
}
else {
Write-Err "Screenshot fehlgeschlagen"
}
}
}

158
.github/skills/android-device/SKILL.md vendored Normal file
View file

@ -0,0 +1,158 @@
---
name: android-device
description: "App auf echtes Android-Handy (Samsung S24 Ultra) deployen, USB-Debugging, Wireless ADB, Logcat auf physischem Gerät. Trigger-Phrasen: 'echtes Handy', 'physisches Gerät', 'USB Debugging', 'Samsung', 'S24', 'auf dem Handy testen', 'Wireless ADB', 'Device'."
---
# Skill: Android Device (Samsung S24 Ultra)
Deployt die Krisenvorrat-App auf das physische Samsung Galaxy S24 Ultra.
---
## Gerätedaten
| Eigenschaft | Wert |
| --------------- | -------------------------------- |
| Modell | Samsung Galaxy S24 Ultra |
| Display | 6.8" QHD+ (3120 × 1440), 505 PPI |
| Android-Version | Android 14+ (API 34+) |
| SoC | Snapdragon 8 Gen 3 |
| RAM | 12 GB |
---
## Ersteinrichtung (einmalig)
### 1. USB-Debugging aktivieren
Auf dem Samsung S24 Ultra:
1. **Einstellungen → Über das Telefon → Softwareinformationen**
2. **Buildnummer** 7× tippen → Entwickleroptionen werden aktiviert
3. **Einstellungen → Entwickleroptionen**:
- **USB-Debugging** aktivieren
- **USB-Debugging-Autorisierungen widerrufen** (falls Probleme)
- Optional: **Bildschirm beim Laden aktiv lassen** aktivieren
### 2. USB-Verbindung
1. Samsung mit USB-C-Kabel an PC anschließen
2. Auf dem Handy: **USB-Debugging zulassen?****Immer von diesem Computer zulassen** → OK
3. Prüfen:
```powershell
C:\Users\JensR\AppData\Local\Android\Sdk\platform-tools\adb.exe devices -l
```
Erwartete Ausgabe:
```
XXXXXXXXXXXXXXXX device product:dm3q model:SM_S928B device:dm3q transport_id:N
```
### 3. Wireless ADB (optional, kabellos)
```powershell
$adb = "C:\Users\JensR\AppData\Local\Android\Sdk\platform-tools\adb.exe"
# Bei verbundenem USB: Wireless Pairing starten
& $adb tcpip 5555
# IP-Adresse des Handys finden (Einstellungen → Über das Telefon → Status → IP-Adresse)
& $adb connect 192.168.X.X:5555
# USB-Kabel kann jetzt entfernt werden
```
---
## Operationen via Skript
```powershell
# App bauen + auf Gerät installieren + starten
& ".github/skills/android-build/android-dev.ps1" -Action deploy-device
# Nur installieren (ohne Build)
& ".github/skills/android-build/android-dev.ps1" -Action install-device
# App starten
& ".github/skills/android-build/android-dev.ps1" -Action launch -Target device
# Logcat vom Gerät
& ".github/skills/android-build/android-dev.ps1" -Action logcat -Target device
```
---
## Manuelle Kommandos (Fallback)
### App installieren
```powershell
$adb = "C:\Users\JensR\AppData\Local\Android\Sdk\platform-tools\adb.exe"
& $adb -d install -r "app\build\outputs\apk\debug\app-debug.apk"
```
`-d` = nur physisches Gerät (nicht Emulator), `-r` = Reinstall.
### App starten
```powershell
& $adb -d shell am start -n de.krisenvorrat.app/.MainActivity
```
### Logcat (gefiltert)
```powershell
& $adb -d logcat --pid=$(& $adb -d shell pidof de.krisenvorrat.app) -v time
```
### Screenshot vom Gerät
```powershell
& $adb -d exec-out screencap -p > device-screenshot.png
```
### App deinstallieren
```powershell
& $adb -d uninstall de.krisenvorrat.app
```
---
## Bekannte Probleme
### 1. `unauthorized` in `adb devices`
Das Handy fragt nach USB-Debugging-Berechtigung, die noch nicht bestätigt wurde.
**Lösung:**
- Display entsperren
- Dialog **USB-Debugging zulassen?** bestätigen
- Falls kein Dialog: Entwickleroptionen → **USB-Debugging-Autorisierungen widerrufen** → USB neu anschließen
### 2. `no devices/emulators found`
**Checkliste:**
1. USB-Kabel prüfen (manche Kabel sind nur zum Laden)
2. USB-Debugging aktiviert?
3. ADB-Daemon neu starten: `& $adb kill-server; & $adb start-server`
4. Samsung-USB-Treiber installiert?
### 3. `INSTALL_FAILED_UPDATE_INCOMPATIBLE`
Die App ist mit einem anderen Signaturschlüssel installiert.
**Lösung:**
```powershell
& $adb -d uninstall de.krisenvorrat.app
& $adb -d install "app\build\outputs\apk\debug\app-debug.apk"
```
### 4. Samsung-spezifisch: App wird von Knox blockiert
Samsung Knox kann Debug-Apps blockieren. In **Entwickleroptionen → Apps über USB installieren** aktivieren.

160
.github/skills/android-emulator/SKILL.md vendored Normal file
View file

@ -0,0 +1,160 @@
---
name: android-emulator
description: "Android-Emulator starten, Apps installieren/starten, AVD verwalten, Logs lesen. Verwende diesen Skill für alles rund um den Android-Simulator: Starten, Stoppen, App-Deployment, Logcat, Screenshots. Trigger-Phrasen: 'Emulator', 'Simulator', 'AVD', 'virtuelles Gerät', 'Emulator starten', 'App im Simulator', 'logcat'."
---
# Skill: Android Emulator
Verwaltet den Android-Emulator für die Krisenvorrat-App. Das Standard-AVD simuliert ein Samsung S24 Ultra.
---
## Setup
| Komponente | Wert |
| -------------- | ----------------------------------------------------------- |
| Emulator | `C:\Users\JensR\AppData\Local\Android\Sdk\emulator\emulator.exe` |
| ADB | `C:\Users\JensR\AppData\Local\Android\Sdk\platform-tools\adb.exe` |
| AVD Manager | `C:\Users\JensR\AppData\Local\Android\Sdk\cmdline-tools\latest\bin\avdmanager.bat` |
| AVD Name | `S24Ultra_API35` |
| System Image | `system-images;android-35;google_apis;x86_64` |
| Basisprofil | `pixel_7_pro` (6.7" QHD+, nächstes Profil zu S24 Ultra) |
| Anpassungen | 3120×1440, 560dpi, 4096 MB RAM (Emulator-Limit) |
---
## Operationen via Skript (bevorzugt)
```powershell
# Emulator starten (wartet auf Boot)
& ".github/skills/android-build/android-dev.ps1" -Action emulator-start
# App bauen + auf Emulator installieren + starten
& ".github/skills/android-build/android-dev.ps1" -Action deploy-emulator
# Nur installieren (ohne Build)
& ".github/skills/android-build/android-dev.ps1" -Action install-emulator
# App starten (bereits installiert)
& ".github/skills/android-build/android-dev.ps1" -Action launch
# Emulator stoppen
& ".github/skills/android-build/android-dev.ps1" -Action emulator-stop
# Logcat (gefiltert auf App)
& ".github/skills/android-build/android-dev.ps1" -Action logcat
```
---
## Manuelle Kommandos (Fallback)
### Emulator starten
```powershell
$env:ANDROID_HOME = "C:\Users\JensR\AppData\Local\Android\Sdk"
Start-Process "$env:ANDROID_HOME\emulator\emulator.exe" -ArgumentList "-avd S24Ultra_API35 -gpu auto"
```
### Auf Boot warten
```powershell
$adb = "$env:ANDROID_HOME\platform-tools\adb.exe"
& $adb wait-for-device
do {
Start-Sleep -Seconds 5
$boot = & $adb shell getprop sys.boot_completed 2>$null
} while ($boot -ne "1")
```
**Hinweis:** Der Boot dauert 3090 Sekunden. `sys.boot_completed` gibt zunächst leeren String zurück.
### App installieren
```powershell
& $adb install -r "app\build\outputs\apk\debug\app-debug.apk"
```
`-r` = Replace (Reinstall ohne Datenverlust).
### App starten
```powershell
& $adb shell am start -n de.krisenvorrat.app/.MainActivity
```
### App stoppen
```powershell
& $adb shell am force-stop de.krisenvorrat.app
```
### Logcat (gefiltert)
```powershell
& $adb logcat --pid=$(& $adb shell pidof de.krisenvorrat.app) -v time
```
### Screenshot
```powershell
& $adb exec-out screencap -p > screenshot.png
```
### Emulator beenden
```powershell
& $adb emu kill
```
---
## Bekannte Probleme
### 1. `NullPointerException` bei Install direkt nach Boot
Der PackageManager ist noch nicht bereit, obwohl `sys.boot_completed` bereits 1 ist.
**Lösung:** 5 Sekunden nach `boot_completed=1` warten, dann installieren. Das Skript macht dies automatisch.
### 2. Emulator startet nicht (`HAXM` / Hypervisor-Fehler)
```
WHPX nicht verfügbar → Hyper-V muss aktiviert sein
```
Auf Windows: Hyper-V muss in Windows Features aktiviert sein. Der Emulator nutzt WHPX (Windows Hypervisor Platform).
### 3. Emulator-Fenster reagiert nicht
```powershell
# Hard-Kill und Neustart
& $adb emu kill
Start-Sleep -Seconds 5
# Erneut starten
```
---
## AVD-Verwaltung
### Vorhandene AVDs auflisten
```powershell
& "$env:ANDROID_HOME\cmdline-tools\latest\bin\avdmanager.bat" list avd
```
### AVD löschen
```powershell
& "$env:ANDROID_HOME\cmdline-tools\latest\bin\avdmanager.bat" delete avd -n "AVD_NAME"
```
### Neues AVD erstellen
```powershell
echo "no" | & "$env:ANDROID_HOME\cmdline-tools\latest\bin\avdmanager.bat" create avd `
-n "S24Ultra_API35" `
-k "system-images;android-35;google_apis;x86_64" `
-d "pixel_7_pro"
```