Commit 057cb55018c1

@@ -0,0 +1,433 @@
+# Build Workflow
+
+Build Android applications (APK/AAB) using Gradle build system.
+
+## Build Types
+
+### APK (Android Package)
+- Direct install on devices
+- Can be shared and sideloaded
+- Larger file size (contains all ABIs)
+- Use for: Development, testing, direct distribution
+
+### AAB (Android App Bundle)
+- Play Store distribution format
+- Smaller download size (dynamic delivery)
+- Cannot be directly installed
+- Use for: Play Store releases
+
+## Quick Start
+
+```bash
+# Navigate to project
+cd /path/to/android-project
+
+# Build debug APK
+./gradlew assembleDebug
+
+# Build release APK
+./gradlew assembleRelease
+
+# Build release AAB
+./gradlew bundleRelease
+
+# Install debug on device
+./gradlew installDebug
+```
+
+## Build Variants
+
+Android projects typically have:
+
+| Variant | Use Case | Signed | Minified |
+|---------|----------|--------|----------|
+| Debug | Development | Auto | No |
+| Release | Production | Manual | Yes |
+
+### Debug Build
+
+```bash
+# Build
+./gradlew assembleDebug
+
+# Output location
+ls app/build/outputs/apk/debug/app-debug.apk
+
+# Install on connected device
+adb install app/build/outputs/apk/debug/app-debug.apk
+
+# Or use Gradle install task
+./gradlew installDebug
+```
+
+### Release Build
+
+Requires signing configuration (see **Publish** workflow).
+
+```bash
+# Build signed release APK
+./gradlew assembleRelease
+
+# Output
+ls app/build/outputs/apk/release/app-release.apk
+
+# Build AAB for Play Store
+./gradlew bundleRelease
+
+# Output
+ls app/build/outputs/bundle/release/app-release.aab
+```
+
+## Build Configuration
+
+### Gradle Wrapper
+
+Always use the wrapper (./gradlew) for consistent builds:
+
+```bash
+# Linux/Mac
+./gradlew <task>
+
+# Windows
+gradlew.bat <task>
+
+# Update wrapper
+./gradlew wrapper --gradle-version=8.6
+```
+
+### Common Gradle Tasks
+
+```bash
+# List all tasks
+./gradlew tasks
+
+# Clean build outputs
+./gradlew clean
+
+# Build all variants
+./gradlew build
+
+# Build and run tests
+./gradlew build test
+
+# Check dependencies
+./gradlew dependencies
+
+# Show project structure
+./gradlew projects
+```
+
+## Build Optimization
+
+### Enable Build Cache
+
+`gradle.properties`:
+```properties
+org.gradle.caching=true
+org.gradle.parallel=true
+org.gradle.daemon=true
+org.gradle.jvmargs=-Xmx4096m -XX:MaxMetaspaceSize=1024m
+```
+
+### Optimize Build Time
+
+```kotlin
+// app/build.gradle.kts
+android {
+    // Use only needed ABIs during development
+    splits {
+        abi {
+            isEnable = false
+        }
+    }
+
+    // Disable PNG crunching in debug
+    buildTypes {
+        debug {
+            isCrunchPngs = false
+        }
+    }
+}
+```
+
+### Incremental Builds
+
+Gradle automatically handles incremental builds. Avoid `clean` unless necessary.
+
+```bash
+# Good: Incremental build
+./gradlew assembleDebug
+
+# Bad: Full rebuild (slower)
+./gradlew clean assembleDebug
+```
+
+## Multi-Module Projects
+
+For projects with multiple modules:
+
+```bash
+# Build specific module
+./gradlew :app:assembleDebug
+./gradlew :library:build
+
+# Build all modules
+./gradlew build
+```
+
+## Build with Different ABIs
+
+### Split APKs by ABI
+
+Reduces APK size by creating separate APKs per architecture.
+
+```kotlin
+// app/build.gradle.kts
+android {
+    splits {
+        abi {
+            isEnable = true
+            reset()
+            include("arm64-v8a", "armeabi-v7a", "x86_64", "x86")
+            isUniversalApk = false  // Set true to also create universal APK
+        }
+    }
+}
+```
+
+Build output:
+```
+app/build/outputs/apk/release/
+├── app-arm64-v8a-release.apk
+├── app-armeabi-v7a-release.apk
+├── app-x86_64-release.apk
+└── app-x86-release.apk
+```
+
+### Filter ABIs (Development)
+
+Include only needed ABIs for faster builds:
+
+```kotlin
+android {
+    defaultConfig {
+        ndk {
+            // Only build for emulator during development
+            abiFilters.addAll(listOf("x86_64"))
+
+            // Or for physical device
+            // abiFilters.addAll(listOf("arm64-v8a"))
+        }
+    }
+}
+```
+
+## Build with Gomobile AAR
+
+If using gomobile bind:
+
+```bash
+# 1. Build AAR from Go code
+cd golib
+gomobile bind -target=android -o mylib.aar .
+
+# 2. Copy to Android project
+cp mylib.aar /path/to/android-project/app/libs/
+
+# 3. Build Android app
+cd /path/to/android-project
+./gradlew assembleDebug
+```
+
+Automate in script:
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "Building Go library..."
+cd golib
+gomobile bind -target=android -o mylib.aar .
+
+echo "Copying AAR to Android project..."
+cp mylib.aar ../app/libs/
+
+echo "Building Android app..."
+cd ..
+./gradlew assembleDebug
+
+echo "Done! APK: app/build/outputs/apk/debug/app-debug.apk"
+```
+
+## Build Flavors
+
+Create different versions of your app:
+
+```kotlin
+// app/build.gradle.kts
+android {
+    flavorDimensions += "version"
+
+    productFlavors {
+        create("free") {
+            dimension = "version"
+            applicationIdSuffix = ".free"
+            versionNameSuffix = "-free"
+        }
+
+        create("paid") {
+            dimension = "version"
+            applicationIdSuffix = ".paid"
+            versionNameSuffix = "-paid"
+        }
+    }
+}
+```
+
+Build specific flavor:
+```bash
+# Free debug
+./gradlew assembleFreeDebug
+
+# Paid release
+./gradlew assemblePaidRelease
+
+# All flavors and variants
+./gradlew assemble
+```
+
+## Continuous Integration
+
+### GitHub Actions Example
+
+`.github/workflows/android.yml`:
+```yaml
+name: Android CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Android SDK
+        uses: android-actions/setup-android@v3
+
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.22'
+
+      - name: Install gomobile
+        run: |
+          go install golang.org/x/mobile/cmd/gomobile@latest
+          gomobile init
+
+      - name: Build Go library
+        run: |
+          cd golib
+          gomobile bind -target=android -o mylib.aar .
+          cp mylib.aar ../app/libs/
+
+      - name: Build with Gradle
+        run: ./gradlew assembleDebug
+
+      - name: Upload APK
+        uses: actions/upload-artifact@v4
+        with:
+          name: app-debug
+          path: app/build/outputs/apk/debug/app-debug.apk
+```
+
+## Troubleshooting
+
+### Build fails with "SDK not found"
+
+```bash
+# Create local.properties
+echo "sdk.dir=$ANDROID_HOME" > local.properties
+```
+
+### OutOfMemoryError during build
+
+Increase Gradle memory in `gradle.properties`:
+```properties
+org.gradle.jvmargs=-Xmx8192m -XX:MaxMetaspaceSize=2048m
+```
+
+### Duplicate class errors
+
+```kotlin
+// Use packagingOptions to exclude duplicates
+android {
+    packagingOptions {
+        resources {
+            excludes += "META-INF/*.kotlin_module"
+        }
+    }
+}
+```
+
+### AAR not found
+
+```kotlin
+// Ensure AAR is in libs directory
+dependencies {
+    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.aar"))))
+    // Or
+    implementation(files("libs/mylib.aar"))
+}
+```
+
+## Build Output
+
+### APK Structure
+
+```
+app-debug.apk
+├── AndroidManifest.xml
+├── classes.dex           # Compiled Kotlin/Java code
+├── lib/                  # Native libraries
+│   ├── arm64-v8a/
+│   ├── armeabi-v7a/
+│   └── x86_64/
+├── res/                  # Resources
+└── resources.arsc        # Compiled resources
+```
+
+### Inspect APK
+
+```bash
+# Extract APK
+unzip app-debug.apk -d extracted
+
+# View manifest
+aapt dump badging app-debug.apk
+
+# View method count
+# Install dex-method-counts first
+dex-method-counts app-debug.apk
+```
+
+## Next Steps
+
+- **Install and test** - Use the **Debug** workflow
+- **Sign and publish** - Use the **Publish** workflow
+- **Run tests** - Use the **Test** workflow
+
+## Resources
+
+- [Gradle Build Documentation](https://developer.android.com/studio/build)
+- [Configure Build Variants](https://developer.android.com/studio/build/build-variants)
+- [Shrink, Obfuscate, and Optimize](https://developer.android.com/studio/build/shrink-code)

@@ -0,0 +1,544 @@
+# Debug Workflow
+
+Debug Android applications using adb, logcat, and Android debugging tools.
+
+## ADB (Android Debug Bridge)
+
+### Basic Commands
+
+```bash
+# List connected devices
+adb devices
+
+# Connect to specific device (if multiple)
+adb -s <device-id> <command>
+
+# Check device info
+adb shell getprop ro.product.model
+adb shell getprop ro.build.version.release
+```
+
+### App Management
+
+```bash
+# Install APK
+adb install app-debug.apk
+
+# Reinstall (keep data)
+adb install -r app-debug.apk
+
+# Uninstall app
+adb uninstall com.example.myapp
+
+# Clear app data
+adb shell pm clear com.example.myapp
+
+# List installed packages
+adb shell pm list packages
+adb shell pm list packages | grep myapp
+
+# Get app info
+adb shell dumpsys package com.example.myapp
+```
+
+### Start/Stop App
+
+```bash
+# Start app activity
+adb shell am start -n com.example.myapp/.MainActivity
+
+# Start with intent data
+adb shell am start -n com.example.myapp/.MainActivity -d "https://example.com"
+
+# Stop (force close) app
+adb shell am force-stop com.example.myapp
+
+# Kill app process
+adb shell am kill com.example.myapp
+```
+
+## Logcat
+
+### View Logs
+
+```bash
+# All logs (verbose)
+adb logcat
+
+# Clear logs first, then follow
+adb logcat -c && adb logcat
+
+# Filter by app package
+adb logcat | grep "com.example.myapp"
+
+# Filter by tag
+adb logcat -s MyTag
+
+# Filter by priority (V=Verbose, D=Debug, I=Info, W=Warn, E=Error, F=Fatal)
+adb logcat *:E  # Only errors
+
+# Multiple filters
+adb logcat MyTag:D *:E  # MyTag at Debug level, everything else at Error
+```
+
+### Log Priorities
+
+```
+V - Verbose (lowest priority)
+D - Debug
+I - Info
+W - Warning
+E - Error
+F - Fatal
+S - Silent (highest priority, nothing printed)
+```
+
+### Format Options
+
+```bash
+# Brief format (default)
+adb logcat -v brief
+
+# Time format (with timestamps)
+adb logcat -v time
+
+# Threadtime (time + PID + TID)
+adb logcat -v threadtime
+
+# Long format (all metadata)
+adb logcat -v long
+```
+
+### Save Logs to File
+
+```bash
+# Save all logs
+adb logcat > logs.txt
+
+# Save with timestamp in filename
+adb logcat > "logs-$(date +%Y%m%d-%H%M%S).txt"
+
+# Save for 10 seconds then stop
+timeout 10s adb logcat > logs.txt
+```
+
+### Filter Crash Logs
+
+```bash
+# Show only fatal errors
+adb logcat *:F
+
+# Show crashes and errors
+adb logcat *:E
+
+# Find specific crash
+adb logcat | grep -A 50 "FATAL EXCEPTION"
+
+# Show stack traces
+adb logcat | grep -E "(at |Caused by)"
+```
+
+### Gomobile / Go-specific Logs
+
+```bash
+# Go runtime logs
+adb logcat | grep GoLog
+
+# Go panic messages
+adb logcat | grep "panic:"
+
+# Your Go log.Printf output
+adb logcat | grep "GoLog"
+```
+
+## Debugging from Code
+
+### Android (Kotlin/Java)
+
+```kotlin
+import android.util.Log
+
+class MainActivity : AppCompatActivity() {
+    companion object {
+        private const val TAG = "MainActivity"
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        // Log levels
+        Log.v(TAG, "Verbose message")
+        Log.d(TAG, "Debug message")
+        Log.i(TAG, "Info message")
+        Log.w(TAG, "Warning message")
+        Log.e(TAG, "Error message")
+
+        // With exception
+        try {
+            // Code that might throw
+        } catch (e: Exception) {
+            Log.e(TAG, "Error occurred", e)
+        }
+    }
+}
+```
+
+View in logcat:
+```bash
+adb logcat -s MainActivity
+```
+
+### Go Code (Gomobile)
+
+```go
+package mylib
+
+import "log"
+
+func FetchData(url string) (string, error) {
+    log.Printf("Fetching URL: %s", url)  // Appears in logcat with GoLog tag
+
+    // Your code
+    result, err := doFetch(url)
+
+    if err != nil {
+        log.Printf("Error fetching: %v", err)
+        return "", err
+    }
+
+    log.Printf("Fetch successful, got %d bytes", len(result))
+    return result, nil
+}
+```
+
+View in logcat:
+```bash
+adb logcat | grep GoLog
+```
+
+## Device/Emulator Commands
+
+### File Operations
+
+```bash
+# Push file to device
+adb push local-file.txt /sdcard/
+
+# Pull file from device
+adb pull /sdcard/file.txt ./
+
+# List files
+adb shell ls /sdcard/
+
+# View file content
+adb shell cat /sdcard/file.txt
+
+# Remove file
+adb shell rm /sdcard/file.txt
+```
+
+### Screenshots and Screen Recording
+
+```bash
+# Take screenshot
+adb shell screencap /sdcard/screen.png
+adb pull /sdcard/screen.png
+adb shell rm /sdcard/screen.png
+
+# Or in one command
+adb exec-out screencap -p > screen.png
+
+# Record screen (max 3 minutes)
+adb shell screenrecord /sdcard/demo.mp4
+# Press Ctrl+C to stop
+adb pull /sdcard/demo.mp4
+adb shell rm /sdcard/demo.mp4
+```
+
+### System Information
+
+```bash
+# CPU info
+adb shell cat /proc/cpuinfo
+
+# Memory info
+adb shell cat /proc/meminfo
+
+# Battery status
+adb shell dumpsys battery
+
+# Display info
+adb shell dumpsys display
+
+# Running processes
+adb shell ps
+
+# App processes
+adb shell ps | grep com.example.myapp
+```
+
+### Network
+
+```bash
+# Check network connectivity
+adb shell ping -c 4 google.com
+
+# View network interfaces
+adb shell ip addr
+
+# Port forwarding (device port to local port)
+adb forward tcp:8080 tcp:8080
+
+# Reverse port forwarding (local port to device)
+adb reverse tcp:9000 tcp:9000
+```
+
+## Performance Profiling
+
+### CPU Profiling
+
+```bash
+# Start profiling
+adb shell am profile start com.example.myapp /sdcard/profile.trace
+
+# Stop profiling
+adb shell am profile stop com.example.myapp
+
+# Pull trace file
+adb pull /sdcard/profile.trace
+
+# Analyze with Android Studio or Perfetto
+```
+
+### Memory Profiling
+
+```bash
+# Get memory info for app
+adb shell dumpsys meminfo com.example.myapp
+
+# Heap dump
+adb shell am dumpheap com.example.myapp /sdcard/heap.hprof
+adb pull /sdcard/heap.hprof
+
+# Analyze with Android Studio Memory Profiler
+```
+
+### Monitor App Performance
+
+```bash
+# CPU usage
+adb shell top | grep com.example.myapp
+
+# Memory usage over time
+adb shell dumpsys meminfo com.example.myapp | grep TOTAL
+```
+
+## Debugging Crashes
+
+### 1. View Crash Logs
+
+```bash
+adb logcat -c  # Clear old logs
+# Reproduce crash
+adb logcat *:E  # View errors
+```
+
+### 2. Find Stack Trace
+
+Look for:
+```
+FATAL EXCEPTION: main
+Process: com.example.myapp, PID: 12345
+java.lang.NullPointerException: Attempt to invoke virtual method '...' on a null object reference
+    at com.example.myapp.MainActivity.onCreate(MainActivity.kt:25)
+    at android.app.Activity.performCreate(Activity.java:...)
+```
+
+### 3. Analyze Stack Trace
+
+- **Line number**: `MainActivity.kt:25` - exact location
+- **Exception type**: `NullPointerException` - what went wrong
+- **Message**: Details about the error
+- **Call stack**: How we got there
+
+### 4. Common Crash Types
+
+**NullPointerException**:
+```kotlin
+// Bad
+val user = getUser()  // Returns null
+val name = user.name  // Crash!
+
+// Good
+val user = getUser()
+val name = user?.name ?: "Unknown"
+```
+
+**ClassCastException**:
+```kotlin
+// Bad
+val text = view as TextView  // Crash if not TextView!
+
+// Good
+val text = view as? TextView
+```
+
+**ActivityNotFoundException**:
+```kotlin
+// Check if intent can be handled
+if (intent.resolveActivity(packageManager) != null) {
+    startActivity(intent)
+}
+```
+
+## Interactive Debugging
+
+### Enable Debug Mode in App
+
+```kotlin
+// app/build.gradle.kts
+android {
+    buildTypes {
+        debug {
+            isDebuggable = true
+        }
+    }
+}
+```
+
+### Using Android Studio Debugger
+
+1. Build debug APK: `./gradlew assembleDebug`
+2. Install on device: `adb install app-debug.apk`
+3. In Android Studio: Run → Attach Debugger to Android Process
+4. Select your app
+5. Set breakpoints in code
+6. Trigger the code path
+
+### Command-line Debugging (jdb)
+
+```bash
+# Find app process
+adb shell ps | grep com.example.myapp
+
+# Forward debug port
+adb forward tcp:8000 jdwp:<pid>
+
+# Attach jdb
+jdb -attach localhost:8000
+```
+
+## Network Debugging
+
+### HTTP Traffic Inspection
+
+```bash
+# Use adb reverse to connect app to local proxy
+adb reverse tcp:8888 tcp:8888
+
+# App should connect to localhost:8888
+# Proxy (mitmproxy, Charles, Burp Suite) runs on port 8888
+```
+
+### View Network Stats
+
+```bash
+adb shell dumpsys netstats
+```
+
+## Common Issues
+
+### "adb: device offline"
+
+```bash
+adb kill-server
+adb start-server
+# Reconnect device
+```
+
+### "adb: device unauthorized"
+
+- Check device screen for authorization prompt
+- Accept "Always allow from this computer"
+- If no prompt:
+  ```bash
+  adb kill-server
+  rm ~/.android/adbkey*
+  adb start-server
+  ```
+
+### "Logcat shows nothing"
+
+```bash
+# Clear buffer
+adb logcat -c
+
+# Check buffer size
+adb logcat -g
+
+# Increase buffer size
+adb logcat -G 16M
+```
+
+### App not showing in process list
+
+```bash
+# Check if app is running
+adb shell "ps -A | grep com.example.myapp"
+
+# Start app if not running
+adb shell am start -n com.example.myapp/.MainActivity
+```
+
+## Debug Helpers
+
+### Monitor script
+
+Create `monitor-app.sh`:
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+APP_PACKAGE="com.example.myapp"
+LOG_TAG="MyApp"
+
+# Clear logs
+adb logcat -c
+
+# Monitor logs with color
+adb logcat | grep --color=always -E "$APP_PACKAGE|$LOG_TAG|FATAL|ERROR"
+```
+
+### Install and monitor script
+
+Create `debug-install.sh`:
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+APK="app/build/outputs/apk/debug/app-debug.apk"
+PACKAGE="com.example.myapp"
+ACTIVITY=".MainActivity"
+
+echo "Installing $APK..."
+adb install -r "$APK"
+
+echo "Starting app..."
+adb shell am start -n "$PACKAGE/$ACTIVITY"
+
+echo "Monitoring logs (Ctrl+C to stop)..."
+adb logcat -c
+adb logcat | grep "$PACKAGE"
+```
+
+## Next Steps
+
+- **Run tests** - Use the **Test** workflow
+- **Profile performance** - Advanced profiling techniques
+- **Publish app** - Use the **Publish** workflow
+
+## Resources
+
+- [ADB Documentation](https://developer.android.com/studio/command-line/adb)
+- [Logcat Command-line Tool](https://developer.android.com/studio/command-line/logcat)
+- [Debug Your App](https://developer.android.com/studio/debug)

@@ -0,0 +1,471 @@
+# Emulator Workflow
+
+Create, configure, and manage Android Virtual Devices (AVDs) for testing apps without physical devices.
+
+## Quick Start
+
+```bash
+# List available system images
+sdkmanager --list | grep system-images
+
+# Install system image (API 34, x86_64, Google APIs)
+sdkmanager "system-images;android-34;google_apis;x86_64"
+
+# Create AVD
+avdmanager create avd \
+    -n Pixel7 \
+    -k "system-images;android-34;google_apis;x86_64" \
+    -d "pixel_7"
+
+# List AVDs
+avdmanager list avd
+
+# Start emulator
+emulator -avd Pixel7
+```
+
+## System Images
+
+### Image Types
+
+| Type | Google Apps | Play Store | Use Case |
+|------|-------------|------------|----------|
+| `default` | ❌ | ❌ | AOSP, minimal |
+| `google_apis` | ✅ | ❌ | Google Maps, etc. |
+| `google_apis_playstore` | ✅ | ✅ | Full Play Services |
+
+### Common System Images
+
+```bash
+# Android 14 (API 34) - x86_64 (for Intel/AMD)
+sdkmanager "system-images;android-34;google_apis;x86_64"
+
+# Android 14 (API 34) - ARM64 (for Apple Silicon with Android Emulator for M1)
+sdkmanager "system-images;android-34;google_apis;arm64-v8a"
+
+# Android 13 (API 33)
+sdkmanager "system-images;android-33;google_apis;x86_64"
+
+# Android 12 (API 31)
+sdkmanager "system-images;android-31;google_apis;x86_64"
+```
+
+**Choose architecture based on your CPU:**
+- Intel/AMD processors: `x86_64`
+- Apple Silicon (M1/M2/M3): `arm64-v8a` (requires Android Emulator for M1+)
+
+## Create AVD
+
+### Interactive (using avdmanager)
+
+```bash
+avdmanager create avd \
+    -n <name> \
+    -k <system-image> \
+    -d <device-definition>
+```
+
+**Examples:**
+
+```bash
+# Pixel 7 with Android 14
+avdmanager create avd \
+    -n Pixel7 \
+    -k "system-images;android-34;google_apis;x86_64" \
+    -d "pixel_7"
+
+# Pixel 6 with Android 13
+avdmanager create avd \
+    -n Pixel6 \
+    -k "system-images;android-33;google_apis;x86_64" \
+    -d "pixel_6"
+
+# Tablet (Pixel Tablet)
+avdmanager create avd \
+    -n PixelTablet \
+    -k "system-images;android-34;google_apis;x86_64" \
+    -d "pixel_tablet"
+```
+
+### Custom Configuration
+
+```bash
+# Custom resolution and RAM
+avdmanager create avd \
+    -n CustomPhone \
+    -k "system-images;android-34;google_apis;x86_64" \
+    -d "pixel_7" \
+    -c 512M \  # SD card size
+    --force    # Overwrite if exists
+```
+
+### List Device Definitions
+
+```bash
+avdmanager list device
+```
+
+Common devices:
+- `pixel_7`, `pixel_7_pro`
+- `pixel_6`, `pixel_6_pro`
+- `pixel_5`
+- `pixel_tablet`
+
+## Manage AVDs
+
+### List AVDs
+
+```bash
+# List all AVDs
+avdmanager list avd
+
+# List with paths
+avdmanager list avd -c
+```
+
+### Delete AVD
+
+```bash
+avdmanager delete avd -n <name>
+
+# Example
+avdmanager delete avd -n Pixel7
+```
+
+### Move AVD
+
+AVDs are stored in `~/.android/avd/`. To move:
+
+```bash
+# Move AVD directory
+mv ~/.android/avd/Pixel7.avd /new/location/
+
+# Update .ini file
+echo "path=/new/location/Pixel7.avd" > ~/.android/avd/Pixel7.ini
+```
+
+## Start Emulator
+
+### Basic Start
+
+```bash
+# Start AVD
+emulator -avd Pixel7
+
+# Start in background
+emulator -avd Pixel7 &
+
+# Start with GPU acceleration
+emulator -avd Pixel7 -gpu host
+```
+
+### Start Options
+
+```bash
+# Wipe data (factory reset)
+emulator -avd Pixel7 -wipe-data
+
+# Read-only system
+emulator -avd Pixel7 -read-only
+
+# Specific resolution
+emulator -avd Pixel7 -skin 1080x1920
+
+# Increase RAM
+emulator -avd Pixel7 -memory 4096
+
+# Cold boot (ignore snapshot)
+emulator -avd Pixel7 -no-snapshot-load
+
+# No audio
+emulator -avd Pixel7 -no-audio
+```
+
+### Performance Options
+
+```bash
+# Maximum performance
+emulator -avd Pixel7 \
+    -gpu host \
+    -memory 4096 \
+    -cores 4 \
+    -no-boot-anim \
+    -no-snapshot
+
+# Quick boot (use snapshot)
+emulator -avd Pixel7 -no-snapshot-save
+```
+
+### Network Options
+
+```bash
+# Use specific DNS
+emulator -avd Pixel7 -dns-server 8.8.8.8
+
+# Network latency simulation
+emulator -avd Pixel7 -netdelay gprs  # or edge, umts, none
+
+# Network speed simulation
+emulator -avd Pixel7 -netspeed full  # or gsm, hscsd, gprs, edge, umts, hsdpa
+
+# Proxy
+emulator -avd Pixel7 -http-proxy http://localhost:8888
+```
+
+## Emulator Control
+
+### From Command Line
+
+While emulator is running:
+
+```bash
+# Connect to emulator console
+telnet localhost 5554  # Port is shown when emulator starts
+
+# In telnet session:
+# auth <token>  # Token is in ~/.emulator_console_auth_token
+# help
+# sms send 1234567890 "Test message"
+# geo fix -122.084 37.422  # Set GPS location
+# quit
+```
+
+### Using ADB
+
+```bash
+# List running emulators
+adb devices
+
+# Install app
+adb -e install app-debug.apk  # -e targets emulator
+
+# Rotate screen
+adb shell settings put system accelerometer_rotation 0
+adb shell settings put system user_rotation 1  # 0=0°, 1=90°, 2=180°, 3=270°
+
+# Simulate low battery
+adb shell dumpsys battery set level 10
+
+# Reset battery
+adb shell dumpsys battery reset
+```
+
+## Configuration Files
+
+### config.ini
+
+Located at `~/.android/avd/<name>.avd/config.ini`
+
+**Common settings:**
+```ini
+# RAM
+hw.ramSize=4096
+
+# Storage
+disk.dataPartition.size=8G
+
+# GPU
+hw.gpu.enabled=yes
+hw.gpu.mode=host
+
+# Camera
+hw.camera.back=emulated
+hw.camera.front=emulated
+
+# Keyboard
+hw.keyboard=yes
+
+# Network
+hw.net.speed=full
+hw.net.delay=none
+```
+
+## Snapshots
+
+### Quick Boot (Snapshots)
+
+Emulator saves state for faster startup.
+
+```bash
+# Start without loading snapshot (cold boot)
+emulator -avd Pixel7 -no-snapshot-load
+
+# Start without saving snapshot (testing)
+emulator -avd Pixel7 -no-snapshot-save
+
+# Disable snapshots completely
+emulator -avd Pixel7 -no-snapshot
+```
+
+### Manage Snapshots
+
+```bash
+# List snapshots
+emulator -avd Pixel7 -list-snapshots
+
+# Load specific snapshot
+emulator -avd Pixel7 -snapshot <name>
+```
+
+## Troubleshooting
+
+### Emulator won't start
+
+```bash
+# Check emulator location
+which emulator
+
+# Run with verbose logging
+emulator -avd Pixel7 -verbose
+
+# Check for errors
+emulator -avd Pixel7 -debug init
+```
+
+### Slow emulator
+
+**Enable hardware acceleration:**
+
+**Linux (KVM):**
+```bash
+# Check KVM support
+egrep -c '(vmx|svm)' /proc/cpuinfo  # Should be > 0
+
+# Check KVM device
+ls -l /dev/kvm
+
+# Add user to kvm group
+sudo usermod -a -G kvm $USER
+# Log out and back in
+
+# Verify
+emulator -accel-check
+```
+
+**macOS (Hypervisor Framework):**
+Automatically used on modern macOS.
+
+**Windows (HAXM):**
+Install Intel HAXM:
+```bash
+sdkmanager "extras;intel;Hardware_Accelerated_Execution_Manager"
+```
+
+### "PANIC: Cannot find AVD system path"
+
+```bash
+# Check ANDROID_AVD_HOME
+echo $ANDROID_AVD_HOME
+
+# Set if needed
+export ANDROID_AVD_HOME=$HOME/.android/avd
+```
+
+### Graphics issues
+
+```bash
+# Try different GPU modes
+emulator -avd Pixel7 -gpu auto
+emulator -avd Pixel7 -gpu host
+emulator -avd Pixel7 -gpu swiftshader_indirect
+emulator -avd Pixel7 -gpu angle_indirect
+```
+
+## Multiple Emulators
+
+### Run Multiple Instances
+
+```bash
+# Start first emulator
+emulator -avd Pixel7 &
+
+# Start second emulator (different AVD)
+emulator -avd Pixel6 &
+
+# Install on specific emulator
+adb -s emulator-5554 install app-debug.apk
+adb -s emulator-5556 install app-debug.apk
+```
+
+### Emulator Ports
+
+- First emulator: console port 5554, adb port 5555
+- Second emulator: console port 5556, adb port 5557
+- And so on...
+
+## Automation Scripts
+
+### Start emulator and wait for boot
+
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+AVD_NAME="Pixel7"
+
+echo "Starting emulator: $AVD_NAME"
+emulator -avd "$AVD_NAME" -no-snapshot-save &
+
+# Wait for device to boot
+echo "Waiting for device to boot..."
+adb wait-for-device
+
+# Wait for boot animation to finish
+while [ "$(adb shell getprop init.svc.bootanim | tr -d '\r')" = "running" ]; do
+    sleep 1
+done
+
+echo "Emulator ready!"
+
+# Optional: Install app
+if [ -f "app-debug.apk" ]; then
+    echo "Installing app..."
+    adb install -r app-debug.apk
+fi
+
+echo "Done!"
+```
+
+### Create standard test emulator
+
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+AVD_NAME="TestDevice"
+SYSTEM_IMAGE="system-images;android-34;google_apis;x86_64"
+
+# Install system image if not already installed
+sdkmanager "$SYSTEM_IMAGE"
+
+# Create AVD (force overwrite if exists)
+avdmanager create avd \
+    -n "$AVD_NAME" \
+    -k "$SYSTEM_IMAGE" \
+    -d "pixel_7" \
+    --force
+
+echo "AVD '$AVD_NAME' created successfully"
+echo "Start with: emulator -avd $AVD_NAME"
+```
+
+## Best Practices
+
+1. **Use hardware acceleration**: Essential for acceptable performance
+2. **Limit RAM**: Don't exceed 50% of your system RAM
+3. **Close when not in use**: Emulators consume significant resources
+4. **Use snapshots**: Enable quick boot for faster startup
+5. **Match target devices**: Create AVDs matching your target devices
+6. **Test on real devices**: Emulators don't perfectly match real hardware
+7. **Use x86_64 images**: Faster than ARM on x86 computers (except Apple Silicon)
+
+## Next Steps
+
+- **Install and test app** - Use the **Build** and **Debug** workflows
+- **Run automated tests** - Use the **Test** workflow
+
+## Resources
+
+- [AVD Manager Documentation](https://developer.android.com/studio/command-line/avdmanager)
+- [Emulator Documentation](https://developer.android.com/studio/run/emulator)
+- [Configure Hardware Acceleration](https://developer.android.com/studio/run/emulator-acceleration)

@@ -0,0 +1,670 @@
+# GomobileApp Workflow
+
+Build standalone Android applications entirely in Go using `gomobile build`. This creates a complete APK with Go code as the main application logic.
+
+## When to Use
+
+- You want to write the entire app in Go
+- You're building a simple utility or demo app
+- You want to prototype quickly without Java/Kotlin
+- You're comfortable with limited UI capabilities
+- You want to share code between CLI and mobile versions
+
+## When NOT to Use
+
+- You need complex native Android UI (use GomobileBind + Kotlin instead)
+- You need full access to Android framework APIs
+- You're building a production app with rich UI
+- You need Material Design components
+
+## Prerequisites
+
+- Go installed (`go version`)
+- Android SDK and NDK installed
+- `ANDROID_HOME` environment variable set
+- Gomobile installed (`gomobile version`)
+
+## Steps
+
+### 1. Install and Initialize Gomobile
+
+```bash
+# Install gomobile
+go install golang.org/x/mobile/cmd/gomobile@latest
+
+# Initialize (downloads Android toolchain)
+gomobile init
+
+# Verify
+gomobile version
+```
+
+### 2. Create Go Mobile App
+
+**Project structure:**
+```
+myapp/
+├── main.go
+├── go.mod
+└── assets/         # Optional: app resources
+    └── icon.png
+```
+
+**Basic app (`main.go`):**
+```go
+package main
+
+import (
+    "log"
+
+    "golang.org/x/mobile/app"
+    "golang.org/x/mobile/event/lifecycle"
+    "golang.org/x/mobile/event/paint"
+    "golang.org/x/mobile/event/size"
+    "golang.org/x/mobile/event/touch"
+    "golang.org/x/mobile/gl"
+)
+
+func main() {
+    app.Main(func(a app.App) {
+        var glctx gl.Context
+        var sz size.Event
+
+        for e := range a.Events() {
+            switch e := a.Filter(e).(type) {
+            case lifecycle.Event:
+                switch e.Crosses(lifecycle.StageVisible) {
+                case lifecycle.CrossOn:
+                    glctx, _ = e.DrawContext.(gl.Context)
+                    onStart(glctx)
+                case lifecycle.CrossOff:
+                    onStop(glctx)
+                    glctx = nil
+                }
+
+            case size.Event:
+                sz = e
+
+            case paint.Event:
+                if glctx == nil || e.External {
+                    continue
+                }
+                onPaint(glctx, sz)
+                a.Publish()
+                a.Send(paint.Event{}) // Keep animating
+
+            case touch.Event:
+                // Handle touch events
+                log.Printf("Touch: %v", e)
+            }
+        }
+    })
+}
+
+func onStart(glctx gl.Context) {
+    log.Println("App started")
+    // Initialize OpenGL resources
+}
+
+func onStop(glctx gl.Context) {
+    log.Println("App stopped")
+    // Clean up resources
+}
+
+func onPaint(glctx gl.Context, sz size.Event) {
+    // Clear screen
+    glctx.ClearColor(0.2, 0.2, 0.3, 1.0)
+    glctx.Clear(gl.COLOR_BUFFER_BIT)
+
+    // Draw your content here
+}
+```
+
+**Simple text-based app (no OpenGL):**
+```go
+package main
+
+import (
+    "fmt"
+    "log"
+
+    "golang.org/x/mobile/app"
+    "golang.org/x/mobile/event/lifecycle"
+    "golang.org/x/mobile/event/touch"
+)
+
+func main() {
+    app.Main(func(a app.App) {
+        for e := range a.Events() {
+            switch e := a.Filter(e).(type) {
+            case lifecycle.Event:
+                switch e.Crosses(lifecycle.StageAlive) {
+                case lifecycle.CrossOn:
+                    log.Println("App is alive")
+                    // Do work here
+                    processData()
+                case lifecycle.CrossOff:
+                    log.Println("App is closing")
+                }
+
+            case touch.Event:
+                if e.Type == touch.TypeBegin {
+                    log.Printf("Touch at: %v, %v", e.X, e.Y)
+                }
+            }
+        }
+    })
+}
+
+func processData() {
+    // Your app logic
+    fmt.Println("Processing...")
+}
+```
+
+**Practical example: Network utility**
+```go
+package main
+
+import (
+    "fmt"
+    "io"
+    "log"
+    "net/http"
+    "time"
+
+    "golang.org/x/mobile/app"
+    "golang.org/x/mobile/event/lifecycle"
+)
+
+func main() {
+    app.Main(func(a app.App) {
+        for e := range a.Events() {
+            switch e := a.Filter(e).(type) {
+            case lifecycle.Event:
+                if e.Crosses(lifecycle.StageAlive) == lifecycle.CrossOn {
+                    go runNetworkCheck()
+                }
+            }
+        }
+    })
+}
+
+func runNetworkCheck() {
+    ticker := time.NewTicker(5 * time.Second)
+    defer ticker.Stop()
+
+    for range ticker.C {
+        resp, err := http.Get("https://www.google.com")
+        if err != nil {
+            log.Printf("Network check failed: %v", err)
+            continue
+        }
+        io.Copy(io.Discard, resp.Body)
+        resp.Body.Close()
+
+        log.Printf("Network OK: %s", resp.Status)
+    }
+}
+```
+
+### 3. Create go.mod
+
+```bash
+go mod init example.com/myapp
+go get golang.org/x/mobile/app
+go get golang.org/x/mobile/event/lifecycle
+go mod tidy
+```
+
+### 4. Build APK
+
+**Basic build:**
+```bash
+gomobile build -target=android .
+```
+
+This creates `myapp.apk` in the current directory.
+
+**Build with custom app ID:**
+```bash
+gomobile build -target=android -appid=com.example.myapp .
+```
+
+**Build for specific architectures:**
+```bash
+# ARM64 only (smaller APK)
+gomobile build -target=android/arm64 -appid=com.example.myapp .
+
+# ARM64 and ARM32
+gomobile build -target=android/arm64,android/arm -appid=com.example.myapp .
+```
+
+**Build with custom icon:**
+```bash
+# Place icon at assets/icon.png
+gomobile build -target=android -icon=assets/icon.png .
+```
+
+**Build with version:**
+```bash
+gomobile build \
+    -target=android \
+    -appid=com.example.myapp \
+    -ldflags="-X main.version=1.0.0" \
+    .
+```
+
+### 5. Install and Run
+
+**Install on connected device:**
+```bash
+# Build and install
+gomobile install -target=android -appid=com.example.myapp .
+
+# Or build then install separately
+gomobile build -target=android -appid=com.example.myapp .
+adb install -r myapp.apk
+```
+
+**View logs:**
+```bash
+adb logcat | grep GoLog
+```
+
+### 6. Test the App
+
+**List installed apps:**
+```bash
+adb shell pm list packages | grep myapp
+```
+
+**Launch app:**
+```bash
+adb shell am start -n com.example.myapp/.MainActivity
+```
+
+**Stop app:**
+```bash
+adb shell am force-stop com.example.myapp
+```
+
+**Uninstall:**
+```bash
+adb uninstall com.example.myapp
+```
+
+## App Package Structure
+
+The gomobile app package provides:
+
+### Event Types
+
+```go
+import "golang.org/x/mobile/event"
+
+// Lifecycle events
+lifecycle.Event    // App start, stop, pause, resume
+
+// Touch events
+touch.Event        // Touch screen interactions
+touch.TypeBegin    // Finger down
+touch.TypeMove     // Finger dragging
+touch.TypeEnd      // Finger up
+
+// Paint events
+paint.Event        // Redraw requests
+
+// Size events
+size.Event         // Screen size, orientation changes
+
+// Key events
+key.Event          // Keyboard input
+```
+
+### GL Context
+
+```go
+import "golang.org/x/mobile/gl"
+
+// OpenGL ES 2.0 context
+glctx gl.Context
+
+// Common operations
+glctx.ClearColor(r, g, b, a float32)
+glctx.Clear(gl.COLOR_BUFFER_BIT)
+glctx.Enable(gl.BLEND)
+```
+
+## Advanced Examples
+
+### HTTP Server App
+
+```go
+package main
+
+import (
+    "fmt"
+    "log"
+    "net/http"
+
+    "golang.org/x/mobile/app"
+    "golang.org/x/mobile/event/lifecycle"
+)
+
+func main() {
+    app.Main(func(a app.App) {
+        var server *http.Server
+
+        for e := range a.Events() {
+            switch e := a.Filter(e).(type) {
+            case lifecycle.Event:
+                switch e.Crosses(lifecycle.StageAlive) {
+                case lifecycle.CrossOn:
+                    server = startServer()
+                case lifecycle.CrossOff:
+                    if server != nil {
+                        server.Close()
+                    }
+                }
+            }
+        }
+    })
+}
+
+func startServer() *http.Server {
+    mux := http.NewServeMux()
+    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+        fmt.Fprintf(w, "Hello from Go on Android!")
+    })
+
+    server := &http.Server{
+        Addr:    ":8080",
+        Handler: mux,
+    }
+
+    go func() {
+        log.Println("Starting server on :8080")
+        if err := server.ListenAndServe(); err != http.ErrServerClosed {
+            log.Printf("Server error: %v", err)
+        }
+    }()
+
+    return server
+}
+```
+
+### File Operations
+
+```go
+package main
+
+import (
+    "log"
+    "os"
+    "path/filepath"
+
+    "golang.org/x/mobile/app"
+    "golang.org/x/mobile/event/lifecycle"
+)
+
+func main() {
+    app.Main(func(a app.App) {
+        for e := range a.Events() {
+            switch e := a.Filter(e).(type) {
+            case lifecycle.Event:
+                if e.Crosses(lifecycle.StageAlive) == lifecycle.CrossOn {
+                    workWithFiles()
+                }
+            }
+        }
+    })
+}
+
+func workWithFiles() {
+    // Get app data directory
+    dataDir, err := os.UserConfigDir()
+    if err != nil {
+        log.Printf("Error getting data dir: %v", err)
+        return
+    }
+
+    // Create file
+    filePath := filepath.Join(dataDir, "mydata.txt")
+    err = os.WriteFile(filePath, []byte("Hello, Android!"), 0644)
+    if err != nil {
+        log.Printf("Error writing file: %v", err)
+        return
+    }
+
+    // Read file
+    data, err := os.ReadFile(filePath)
+    if err != nil {
+        log.Printf("Error reading file: %v", err)
+        return
+    }
+
+    log.Printf("File content: %s", string(data))
+}
+```
+
+## Customization
+
+### AndroidManifest.xml
+
+Gomobile generates AndroidManifest.xml automatically. To customize:
+
+1. **Build APK first:**
+   ```bash
+   gomobile build -target=android -appid=com.example.myapp .
+   ```
+
+2. **Extract APK:**
+   ```bash
+   unzip myapp.apk -d myapp-extracted
+   ```
+
+3. **View manifest:**
+   ```bash
+   cat myapp-extracted/AndroidManifest.xml
+   ```
+
+4. **For advanced customization**, use gomobile bind instead and create a full Android project.
+
+### Permissions
+
+Gomobile apps have minimal permissions by default. For additional permissions, you'll need to:
+
+1. Use gomobile bind to create AAR
+2. Create full Android project
+3. Add permissions in AndroidManifest.xml
+
+## Limitations
+
+### UI Limitations
+
+- ❌ No native Android UI widgets (Button, TextView, etc.)
+- ❌ No Material Design components
+- ❌ Limited text rendering capabilities
+- ✅ OpenGL ES 2.0 for custom graphics
+- ✅ Touch event handling
+- ✅ Basic drawing and animations
+
+### Platform Limitations
+
+- ❌ No direct access to Android framework APIs
+- ❌ Can't use Java/Kotlin libraries
+- ❌ No system services (Camera, GPS, etc.)
+- ✅ Network access (HTTP, TCP, UDP)
+- ✅ File I/O
+- ✅ Concurrency with goroutines
+
+### When to Use gomobile build vs gomobile bind
+
+| Feature | gomobile build | gomobile bind |
+|---------|----------------|---------------|
+| UI | OpenGL only | Full Android UI |
+| Android APIs | Limited | Full access |
+| Development speed | Fast | Medium |
+| Code sharing | Easy | Moderate |
+| Production apps | Demos/utilities | Production ready |
+| Learning curve | Low | Medium |
+
+## Build Automation
+
+**build.sh script:**
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+APP_ID="com.example.myapp"
+VERSION="1.0.0"
+TARGET="android/arm64,android/arm"
+
+echo "Building Android app..."
+
+# Build APK
+gomobile build \
+    -target="$TARGET" \
+    -appid="$APP_ID" \
+    -ldflags="-X main.version=$VERSION" \
+    .
+
+echo "APK built: myapp.apk"
+
+# Optional: Install on device
+if adb devices | grep -q "device$"; then
+    echo "Installing on device..."
+    adb install -r myapp.apk
+    echo "Launch with: adb shell am start -n $APP_ID/.MainActivity"
+else
+    echo "No device connected. Install with: adb install myapp.apk"
+fi
+```
+
+## Debugging
+
+### View Logs
+
+```bash
+# All logs
+adb logcat
+
+# Go logs only
+adb logcat | grep GoLog
+
+# Your app logs
+adb logcat | grep "com.example.myapp"
+
+# Clear logs first
+adb logcat -c && adb logcat
+```
+
+### Add Debug Logging
+
+```go
+import "log"
+
+func main() {
+    log.SetPrefix("[MyApp] ")
+    log.Println("App starting...")
+
+    // Your code
+}
+```
+
+### Check App Status
+
+```bash
+# Check if app is running
+adb shell ps | grep myapp
+
+# Check app info
+adb shell dumpsys package com.example.myapp
+```
+
+## Performance Tips
+
+1. **Use goroutines wisely**: They're not free, even in Go
+2. **Minimize allocations**: GC pauses affect frame rate
+3. **Use buffered channels**: Reduce goroutine blocking
+4. **Profile your code**: Use pprof before deploying
+5. **Test on real devices**: Emulators don't show real performance
+
+## Common Issues
+
+### Issue: "No Android devices detected"
+
+```bash
+# Check connected devices
+adb devices
+
+# Restart adb if needed
+adb kill-server
+adb start-server
+adb devices
+```
+
+### Issue: "Installation failed"
+
+```bash
+# Uninstall old version first
+adb uninstall com.example.myapp
+
+# Reinstall
+adb install myapp.apk
+```
+
+### Issue: "App crashes immediately"
+
+```bash
+# View crash logs
+adb logcat | grep FATAL
+
+# Check for panic
+adb logcat | grep "panic:"
+```
+
+## Migration Path
+
+### From gomobile build to gomobile bind
+
+When your app outgrows gomobile build:
+
+1. **Extract core logic to library:**
+   ```go
+   // In mylib/network.go
+   package mylib
+
+   func FetchData(url string) (string, error) {
+       // Your logic
+   }
+   ```
+
+2. **Build AAR:**
+   ```bash
+   gomobile bind -target=android -o mylib.aar ./mylib
+   ```
+
+3. **Create Android project** (see **Build** workflow)
+
+4. **Use AAR from Kotlin:**
+   ```kotlin
+   import mylib.Mylib
+
+   val data = Mylib.fetchData("https://example.com")
+   ```
+
+## Next Steps
+
+- **Debug your app** - Use the **Debug** workflow
+- **Test on emulator** - Use the **Emulator** workflow
+- **Build production APK** - Use the **Build** and **Publish** workflows
+- **Add richer UI** - Consider migrating to gomobile bind + Android project
+
+## Resources
+
+- [Gomobile Documentation](https://pkg.go.dev/golang.org/x/mobile)
+- [Mobile App Package](https://pkg.go.dev/golang.org/x/mobile/app)
+- [Mobile GL Package](https://pkg.go.dev/golang.org/x/mobile/gl)
+- [Gomobile Examples](https://github.com/golang/mobile/tree/master/example)