Commit bb98deffa3c8

@@ -1,6 +1,25 @@
 # Build Workflow
 
-Build Android applications (APK/AAB) using Gradle build system.
+Build Android applications and Go libraries for Android, manage dependencies with Gradle, and publish to Google Play Store.
+
+## Quick Start
+
+```bash
+# Navigate to project
+cd /path/to/android-project
+
+# Build debug APK
+./gradlew assembleDebug
+
+# Build release APK
+./gradlew assembleRelease
+
+# Build release AAB (for Play Store)
+./gradlew bundleRelease
+
+# Install debug on device
+./gradlew installDebug
+```
 
 ## Build Types
 
@@ -16,53 +35,636 @@ Build Android applications (APK/AAB) using Gradle build system.
 - Cannot be directly installed
 - Use for: Play Store releases
 
-## Quick Start
+## Gradle Fundamentals
 
-```bash
-# Navigate to project
-cd /path/to/android-project
+### Project Structure
 
-# Build debug APK
-./gradlew assembleDebug
-
-# Build release APK
-./gradlew assembleRelease
-
-# Build release AAB
-./gradlew bundleRelease
-
-# Install debug on device
-./gradlew installDebug
+```
+myproject/
+├── gradle/
+│   ├── libs.versions.toml      # Version catalog (recommended)
+│   └── wrapper/
+│       ├── gradle-wrapper.jar
+│       └── gradle-wrapper.properties
+├── app/
+│   └── build.gradle.kts        # App module build file
+├── build.gradle.kts            # Root build file
+├── settings.gradle.kts         # Project settings
+├── gradle.properties           # Global Gradle properties
+└── local.properties            # Local config (not in git)
 ```
 
-## Build Variants
+### Version Catalogs (Modern Approach)
 
-Android projects typically have:
+**gradle/libs.versions.toml:**
+```toml
+[versions]
+agp = "8.3.0"
+kotlin = "1.9.22"
+compileSdk = "34"
+minSdk = "24"
+targetSdk = "34"
 
-| Variant | Use Case | Signed | Minified |
-|---------|----------|--------|----------|
-| Debug | Development | Auto | No |
-| Release | Production | Manual | Yes |
+androidx-core = "1.12.0"
+material = "1.11.0"
 
-### Debug Build
+[libraries]
+androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "androidx-core" }
+material = { group = "com.google.android.material", name = "material", version.ref = "material" }
+
+[plugins]
+android-application = { id = "com.android.application", version.ref = "agp" }
+kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
+```
+
+**Root build.gradle.kts:**
+```kotlin
+plugins {
+    alias(libs.plugins.android.application) apply false
+    alias(libs.plugins.kotlin.android) apply false
+}
+```
+
+**App build.gradle.kts:**
+```kotlin
+plugins {
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.kotlin.android)
+}
+
+android {
+    namespace = "com.example.myapp"
+    compileSdk = 34
+
+    defaultConfig {
+        applicationId = "com.example.myapp"
+        minSdk = 24
+        targetSdk = 34
+        versionCode = 1
+        versionName = "1.0"
+    }
+
+    buildTypes {
+        release {
+            isMinifyEnabled = true
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+}
+
+dependencies {
+    implementation(libs.androidx.core.ktx)
+    implementation(libs.material)
+
+    // Gomobile AAR
+    implementation(files("libs/mylib.aar"))
+}
+```
+
+### Managing Dependencies
+
+**Add dependency to version catalog:**
+```toml
+[versions]
+retrofit = "2.9.0"
+
+[libraries]
+retrofit = { group = "com.squareup.retrofit2", name = "retrofit", version.ref = "retrofit" }
+```
+
+**Use in build.gradle.kts:**
+```kotlin
+dependencies {
+    implementation(libs.retrofit)
+}
+```
+
+**Dependency scopes:**
+```kotlin
+dependencies {
+    implementation("...")           // Recommended: Not exposed to consumers
+    api("...")                      // Exposed to consumers
+    compileOnly("...")              // Compile only (not in APK)
+    runtimeOnly("...")              // Runtime only
+
+    testImplementation("...")       // Unit tests
+    androidTestImplementation("...")// Instrumentation tests
+
+    debugImplementation("...")      // Debug build only
+}
+```
+
+**Local AAR/JAR files:**
+```kotlin
+dependencies {
+    // Single AAR
+    implementation(files("libs/mylib.aar"))
+
+    // All AARs in libs directory
+    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.aar"))))
+}
+```
+
+### gradle.properties
+
+```properties
+# Performance
+org.gradle.jvmargs=-Xmx4096m -XX:MaxMetaspaceSize=1024m
+org.gradle.daemon=true
+org.gradle.parallel=true
+org.gradle.caching=true
+
+# AndroidX
+android.useAndroidX=true
+android.enableJetifier=true
+
+# Build
+android.nonTransitiveRClass=true
+```
+
+### Build Variants
+
+**Build types:**
+```kotlin
+android {
+    buildTypes {
+        debug {
+            applicationIdSuffix = ".debug"
+            isDebuggable = true
+        }
+
+        release {
+            isMinifyEnabled = true
+            isShrinkResources = true
+            proguardFiles(...)
+        }
+
+        create("staging") {
+            initWith(getByName("debug"))
+            applicationIdSuffix = ".staging"
+        }
+    }
+}
+```
+
+**Product flavors:**
+```kotlin
+android {
+    flavorDimensions += "version"
+
+    productFlavors {
+        create("free") {
+            dimension = "version"
+            applicationIdSuffix = ".free"
+        }
+
+        create("paid") {
+            dimension = "version"
+            applicationIdSuffix = ".paid"
+        }
+    }
+}
+```
+
+Build specific variant:
+```bash
+./gradlew assembleFreeDebug
+./gradlew assemblePaidRelease
+```
+
+### Common Gradle Tasks
 
 ```bash
-# Build
+# List all tasks
+./gradlew tasks
+
+# Clean build outputs
+./gradlew clean
+
+# Build all variants
+./gradlew build
+
+# Check dependencies
+./gradlew dependencies
+
+# Show dependency tree
+./gradlew app:dependencies --configuration debugRuntimeClasspath
+
+# Refresh dependencies
+./gradlew --refresh-dependencies
+```
+
+## Building Go Libraries (gomobile bind)
+
+Use gomobile bind to create Android AAR packages from Go code. This allows you to use Go libraries in Android apps written in Java/Kotlin.
+
+### When to Use
+
+- You have existing Go code (networking, crypto, business logic)
+- You want to integrate Go into an existing Android app
+- You need Go's concurrency or standard library in Android
+- You want to share code between backend and mobile
+
+### Prerequisites
+
+```bash
+# Install gomobile
+go install golang.org/x/mobile/cmd/gomobile@latest
+
+# Initialize (downloads Android toolchain)
+gomobile init
+
+# Verify
+gomobile version
+```
+
+### Go Code Requirements
+
+**What works in gomobile:**
+- ✅ Exported functions with basic types
+- ✅ Exported structs with exported fields
+- ✅ Methods on exported structs
+- ✅ Interfaces (for callbacks)
+- ✅ Error return values (become exceptions)
+- ✅ Slices of basic types (`[]byte`, `[]int`, `[]string`)
+
+**What doesn't work:**
+- ❌ Maps (use structs instead)
+- ❌ Channels (use callbacks via interfaces)
+- ❌ Generics
+- ❌ Unexported types in function signatures
+- ❌ Variadic functions
+
+**Example Go library:**
+```go
+// File: golib/network.go
+package network
+
+import (
+    "fmt"
+    "net/http"
+)
+
+// FetchURL fetches content from a URL
+func FetchURL(url string) (string, error) {
+    resp, err := http.Get(url)
+    if err != nil {
+        return "", err
+    }
+    defer resp.Body.Close()
+
+    // Implementation...
+    return "content", nil
+}
+
+// Config represents network configuration
+type Config struct {
+    Timeout int
+    BaseURL string
+}
+
+// NewConfig creates a new Config
+func NewConfig(timeout int, baseURL string) *Config {
+    return &Config{
+        Timeout: timeout,
+        BaseURL: baseURL,
+    }
+}
+
+// Callback interface for async operations
+type Callback interface {
+    OnSuccess(data string)
+    OnError(err error)
+}
+
+// FetchAsync fetches URL asynchronously
+func FetchAsync(url string, callback Callback) {
+    go func() {
+        result, err := FetchURL(url)
+        if err != nil {
+            callback.OnError(err)
+            return
+        }
+        callback.OnSuccess(result)
+    }()
+}
+```
+
+### Build AAR
+
+**Basic build (all architectures):**
+```bash
+gomobile bind -target=android -o mylib.aar ./golib
+```
+
+**Build specific architectures:**
+```bash
+# ARM64 only (most modern devices)
+gomobile bind -target=android/arm64 -o mylib.aar ./golib
+
+# ARM64 and ARM32
+gomobile bind -target=android/arm64,android/arm -o mylib.aar ./golib
+
+# All common architectures
+gomobile bind -target=android/arm64,android/arm,android/amd64,android/386 -o mylib.aar ./golib
+```
+
+**Architecture options:**
+- `android/arm64`: 64-bit ARM (arm64-v8a) - modern devices
+- `android/arm`: 32-bit ARM (armeabi-v7a) - older devices
+- `android/amd64`: 64-bit x86 (x86_64) - emulators
+- `android/386`: 32-bit x86 (x86) - old emulators
+
+### Integrate AAR into Android Project
+
+**Copy AAR:**
+```bash
+cp mylib.aar /path/to/android-project/app/libs/
+```
+
+**Add dependency in app/build.gradle.kts:**
+```kotlin
+dependencies {
+    implementation(files("libs/mylib.aar"))
+}
+```
+
+**Sync Gradle:**
+```bash
+./gradlew sync
+```
+
+### Use in Android Code
+
+**Kotlin example:**
+```kotlin
+import golib.Network
+
+class MainActivity : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        // Call Go function
+        try {
+            val result = Network.fetchURL("https://example.com")
+            println("Result: $result")
+        } catch (e: Exception) {
+            println("Error: ${e.message}")
+        }
+
+        // Use Go struct
+        val config = Network.newConfig(30, "https://api.example.com")
+        println("Timeout: ${config.timeout}")
+
+        // Async with callback
+        Network.fetchAsync("https://example.com", object : Network.Callback {
+            override fun onSuccess(data: String) {
+                println("Success: $data")
+            }
+
+            override fun onError(err: Exception) {
+                println("Error: ${err.message}")
+            }
+        })
+    }
+}
+```
+
+### Type Conversion Reference
+
+| Go Type | Java/Kotlin Type | Notes |
+|---------|------------------|-------|
+| `bool` | `boolean` / `Boolean` | |
+| `int`, `int32` | `int` / `Int` | 32-bit signed |
+| `int64` | `long` / `Long` | 64-bit signed |
+| `float64` | `double` / `Double` | |
+| `string` | `String` | UTF-8 encoded |
+| `[]byte` | `byte[]` / `ByteArray` | |
+| `error` | `Exception` | Go errors become Java exceptions |
+| `struct` | `class` | Exported fields become getters/setters |
+| `interface` | `interface` | Must have exported methods only |
+
+### Optimization Tips
+
+**Minimize boundary crossings:**
+
+Bad (many crossings):
+```go
+func ProcessItem(item string) string { ... }
+// Called 1000 times from Android = 1000 Go calls
+```
+
+Good (single crossing):
+```go
+func ProcessItems(items []string) []string { ... }
+// Called once from Android = 1 Go call
+```
+
+**Use appropriate architectures:**
+
+For development (faster builds):
+```bash
+gomobile bind -target=android/arm64 -o mylib.aar ./golib
+```
+
+For release (wider compatibility):
+```bash
+gomobile bind -target=android/arm64,android/arm -o mylib.aar ./golib
+```
+
+### Build Automation Script
+
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "Building AAR..."
+
+TARGETS=${ANDROID_TARGETS:-"android/arm64,android/arm"}
+OUTPUT=${AAR_OUTPUT:-"mylib.aar"}
+PACKAGE=${GO_PACKAGE:-"./golib"}
+
+gomobile bind \
+    -target="$TARGETS" \
+    -o "$OUTPUT" \
+    "$PACKAGE"
+
+echo "AAR built: $OUTPUT"
+
+# Copy to Android project if path is set
+if [ -n "${ANDROID_PROJECT:-}" ]; then
+    cp "$OUTPUT" "$ANDROID_PROJECT/app/libs/"
+    echo "Copied to Android project"
+fi
+```
+
+Usage:
+```bash
+# Build for ARM64 only
+ANDROID_TARGETS=android/arm64 ./build-aar.sh
+
+# Build and copy to Android project
+ANDROID_PROJECT=/path/to/android-app ./build-aar.sh
+```
+
+## Building Standalone Go Apps (gomobile build)
+
+Build standalone Android applications entirely in Go using `gomobile build`. Creates a complete APK with Go code as the main application logic.
+
+### When to Use vs gomobile bind
+
+| Feature | gomobile build | gomobile bind |
+|---------|----------------|---------------|
+| UI | OpenGL only | Full Android UI |
+| Android APIs | Limited | Full access |
+| Development speed | Fast | Medium |
+| Production apps | Demos/utilities | Production ready |
+| Learning curve | Low | Medium |
+
+**Use gomobile build when:**
+- You want to write the entire app in Go
+- You're building a simple utility or demo
+- You want to prototype quickly
+- You're comfortable with limited UI
+
+**Use gomobile bind when:**
+- You need complex native Android UI
+- You need full Android framework APIs
+- You're building a production app with rich UI
+
+### Basic App Example
+
+```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/gl"
+)
+
+func main() {
+    app.Main(func(a app.App) {
+        var glctx gl.Context
+
+        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)
+                    log.Println("App started")
+                case lifecycle.CrossOff:
+                    log.Println("App stopped")
+                    glctx = nil
+                }
+
+            case paint.Event:
+                if glctx == nil {
+                    continue
+                }
+                // Clear screen
+                glctx.ClearColor(0.2, 0.2, 0.3, 1.0)
+                glctx.Clear(gl.COLOR_BUFFER_BIT)
+                a.Publish()
+            }
+        }
+    })
+}
+```
+
+### Build APK
+
+**Basic build:**
+```bash
+gomobile build -target=android .
+```
+
+**Build with custom app ID:**
+```bash
+gomobile build -target=android -appid=com.example.myapp .
+```
+
+**Build for specific architectures:**
+```bash
+# ARM64 only
+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 .
+```
+
+### Install and Run
+
+```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
+```
+
+### Limitations
+
+**UI Limitations:**
+- ❌ No native Android UI widgets
+- ❌ No Material Design components
+- ❌ Limited text rendering
+- ✅ OpenGL ES 2.0 for custom graphics
+- ✅ Touch event handling
+
+**Platform Limitations:**
+- ❌ No direct access to Android framework APIs
+- ❌ Can't use Java/Kotlin libraries
+- ✅ Network access (HTTP, TCP, UDP)
+- ✅ File I/O
+- ✅ Concurrency with goroutines
+
+## Building Android Apps
+
+### Build Debug
+
+```bash
+# Build debug APK
 ./gradlew assembleDebug
 
 # Output location
 ls app/build/outputs/apk/debug/app-debug.apk
 
-# Install on connected device
+# Install on 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).
+### Build Release
 
 ```bash
 # Build signed release APK
@@ -78,151 +680,7 @@ ls app/build/outputs/apk/release/app-release.apk
 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
+### Build with Gomobile AAR
 
 If using gomobile bind:
 
@@ -258,59 +716,274 @@ cd ..
 echo "Done! APK: app/build/outputs/apk/debug/app-debug.apk"
 ```
 
-## Build Flavors
+### Build Optimization
 
-Create different versions of your app:
+**Enable build cache (gradle.properties):**
+```properties
+org.gradle.caching=true
+org.gradle.parallel=true
+org.gradle.daemon=true
+org.gradle.jvmargs=-Xmx4096m
+```
 
+**Optimize build time:**
 ```kotlin
-// app/build.gradle.kts
 android {
-    flavorDimensions += "version"
-
-    productFlavors {
-        create("free") {
-            dimension = "version"
-            applicationIdSuffix = ".free"
-            versionNameSuffix = "-free"
+    // Use only needed ABIs during development
+    splits {
+        abi {
+            isEnable = false
         }
+    }
 
-        create("paid") {
-            dimension = "version"
-            applicationIdSuffix = ".paid"
-            versionNameSuffix = "-paid"
+    // Disable PNG crunching in debug
+    buildTypes {
+        debug {
+            isCrunchPngs = false
         }
     }
 }
 ```
 
-Build specific flavor:
+**Incremental builds:**
 ```bash
-# Free debug
-./gradlew assembleFreeDebug
+# Good: Incremental build
+./gradlew assembleDebug
 
-# Paid release
-./gradlew assemblePaidRelease
-
-# All flavors and variants
-./gradlew assemble
+# Bad: Full rebuild (slower)
+./gradlew clean assembleDebug
 ```
 
-## Continuous Integration
+## Signing and Publishing
 
-### GitHub Actions Example
+### Create Signing Key
 
-`.github/workflows/android.yml`:
+Generate keystore:
+```bash
+keytool -genkey -v \
+    -keystore release.keystore \
+    -alias myapp-key \
+    -keyalg RSA \
+    -keysize 2048 \
+    -validity 10000
+```
+
+**Important:**
+- **NEVER commit keystore to git**
+- **Backup keystore securely**
+- **Remember passwords**
+
+View keystore details:
+```bash
+keytool -list -v -keystore release.keystore
+```
+
+### Configure Signing in Gradle
+
+**Using environment variables (recommended):**
+
+app/build.gradle.kts:
+```kotlin
+android {
+    signingConfigs {
+        create("release") {
+            storeFile = file("../release.keystore")
+            storePassword = System.getenv("KEYSTORE_PASSWORD")
+            keyAlias = "myapp-key"
+            keyPassword = System.getenv("KEY_PASSWORD")
+        }
+    }
+
+    buildTypes {
+        release {
+            signingConfig = signingConfigs.getByName("release")
+            isMinifyEnabled = true
+            isShrinkResources = true
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
+        }
+    }
+}
+```
+
+Build with environment variables:
+```bash
+export KEYSTORE_PASSWORD="your-keystore-password"
+export KEY_PASSWORD="your-key-password"
+./gradlew bundleRelease
+```
+
+### ProGuard / R8
+
+**Enable code shrinking:**
+```kotlin
+android {
+    buildTypes {
+        release {
+            isMinifyEnabled = true
+            isShrinkResources = true
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
+        }
+    }
+}
+```
+
+**proguard-rules.pro:**
+```proguard
+# Keep gomobile generated classes
+-keep class go.** { *; }
+-keep class mylib.** { *; }
+
+# Keep model classes
+-keep class com.example.myapp.models.** { *; }
+
+# Kotlin
+-keep class kotlin.** { *; }
+-keep class kotlin.Metadata { *; }
+```
+
+### Build Release AAB
+
+```bash
+./gradlew bundleRelease
+
+# Output location
+ls app/build/outputs/bundle/release/app-release.aab
+```
+
+### Verify Signature
+
+```bash
+# Check AAB signature
+jarsigner -verify -verbose app-release.aab
+
+# Check APK signature
+apksigner verify --verbose app-release.apk
+```
+
+### Test Release Build
+
+**Generate APKs from AAB (using bundletool):**
+```bash
+# Download bundletool from:
+# https://github.com/google/bundletool/releases
+
+# Generate APKs
+java -jar bundletool-all.jar build-apks \
+    --bundle=app-release.aab \
+    --output=app.apks \
+    --mode=universal
+
+# Extract universal APK
+unzip app.apks universal.apk
+
+# Install
+adb install universal.apk
+```
+
+**Test checklist:**
+- [ ] App installs successfully
+- [ ] App launches without crashes
+- [ ] All features work correctly
+- [ ] ProGuard hasn't broken anything
+- [ ] Gomobile integration works
+- [ ] Network requests succeed
+
+### Versioning
+
+**Version code (monotonically increasing):**
+```kotlin
+android {
+    defaultConfig {
+        versionCode = 1  // Increment for each release
+        versionName = "1.0"
+    }
+}
+```
+
+**Automated versioning from git:**
+```kotlin
+fun getVersionCode(): Int {
+    val process = Runtime.getRuntime().exec("git rev-list --count HEAD")
+    return process.inputStream.bufferedReader().readText().trim().toInt()
+}
+
+fun getVersionName(): String {
+    val process = Runtime.getRuntime().exec("git describe --tags --always")
+    return process.inputStream.bufferedReader().readText().trim()
+}
+
+android {
+    defaultConfig {
+        versionCode = getVersionCode()
+        versionName = getVersionName()
+    }
+}
+```
+
+### Upload to Play Console
+
+**Prerequisites:**
+1. Google Play Developer account ($25 one-time)
+2. App created in Play Console
+3. Store listing completed
+
+**Upload AAB:**
+1. Go to [Play Console](https://play.google.com/console)
+2. Select your app
+3. Production → Releases
+4. Create new release
+5. Upload AAB file
+6. Fill release notes
+7. Review and rollout
+
+**Release tracks:**
+| Track | Purpose | Audience |
+|-------|---------|----------|
+| Internal testing | Quick testing | Up to 100 testers |
+| Closed testing | Alpha/beta | Invited testers |
+| Open testing | Public beta | Anyone can join |
+| Production | Public release | All users |
+
+**Staged rollout (recommended):**
+1. Start with 5-10%
+2. Monitor crashes/issues
+3. Increase to 25%, 50%, 100%
+
+### Store Listing Requirements
+
+**Required assets:**
+- Screenshots: Minimum 2, recommended 4-8
+- Icon: 512x512 PNG
+- Feature graphic: 1024x500 PNG
+
+**Required information:**
+- App name
+- Short description (80 characters)
+- Full description (4000 characters)
+- Category
+- Content rating
+- Privacy policy URL (if app collects data)
+- Contact email
+
+### CI/CD Publishing Example
+
+**.github/workflows/release.yml:**
 ```yaml
-name: Android CI
+name: Release
 
 on:
   push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
+    tags:
+      - 'v*'
 
 jobs:
-  build:
+  release:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
@@ -321,55 +994,54 @@ jobs:
           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
+      - name: Build gomobile AAR
         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: Build Release AAB
+        env:
+          KEYSTORE_PASSWORD: ${{ secrets.KEYSTORE_PASSWORD }}
+          KEY_PASSWORD: ${{ secrets.KEY_PASSWORD }}
+        run: |
+          echo "${{ secrets.KEYSTORE_BASE64 }}" | base64 -d > release.keystore
+          ./gradlew bundleRelease
 
-      - name: Upload APK
-        uses: actions/upload-artifact@v4
+      - name: Upload to Play Store
+        uses: r0adkll/upload-google-play@v1
         with:
-          name: app-debug
-          path: app/build/outputs/apk/debug/app-debug.apk
+          serviceAccountJsonPlainText: ${{ secrets.SERVICE_ACCOUNT_JSON }}
+          packageName: com.example.myapp
+          releaseFiles: app/build/outputs/bundle/release/app-release.aab
+          track: production
 ```
 
 ## Troubleshooting
 
-### Build fails with "SDK not found"
+### Build Issues
 
+**SDK not found:**
 ```bash
 # Create local.properties
 echo "sdk.dir=$ANDROID_HOME" > local.properties
 ```
 
-### OutOfMemoryError during build
-
-Increase Gradle memory in `gradle.properties`:
+**OutOfMemoryError during build:**
 ```properties
+# Increase Gradle memory in gradle.properties
 org.gradle.jvmargs=-Xmx8192m -XX:MaxMetaspaceSize=2048m
 ```
 
-### Duplicate class errors
-
+**Duplicate class errors:**
 ```kotlin
-// Use packagingOptions to exclude duplicates
 android {
     packagingOptions {
         resources {
@@ -379,55 +1051,112 @@ android {
 }
 ```
 
-### AAR not found
+### Gomobile Issues
 
-```kotlin
-// Ensure AAR is in libs directory
+**"gomobile: command not found":**
+```bash
+# Ensure Go bin is in PATH
+export PATH=$PATH:$(go env GOPATH)/bin
+
+# Reinstall gomobile
+go install golang.org/x/mobile/cmd/gomobile@latest
+```
+
+**"NDK not found":**
+```bash
+# Set ANDROID_HOME
+export ANDROID_HOME=$HOME/Android/Sdk
+
+# Install NDK
+sdkmanager "ndk;26.1.10909125"
+
+# Reinitialize gomobile
+gomobile init
+```
+
+**"Cannot use map in function signature":**
+```go
+// Bad - maps don't bind
+func BadFunc(data map[string]string) error { ... }
+
+// Good - use struct instead
+type KeyValue struct {
+    Key   string
+    Value string
+}
+func GoodFunc(data []KeyValue) error { ... }
+```
+
+**AAR is very large:**
+```bash
+# Build only needed architectures
+gomobile bind -target=android/arm64 -o mylib.aar ./golib
+```
+
+### Dependency Issues
+
+**Dependency conflicts:**
+```bash
+# View conflict resolution
+./gradlew app:dependencies
+
+# Force specific version
 dependencies {
-    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.aar"))))
-    // Or
-    implementation(files("libs/mylib.aar"))
+    implementation("com.example:library:1.0") {
+        force = true
+    }
+}
+
+# Exclude transitive dependency
+dependencies {
+    implementation("com.example:library:1.0") {
+        exclude(group = "com.unwanted", module = "module")
+    }
 }
 ```
 
-## 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
-
+**Sync issues:**
 ```bash
-# Extract APK
-unzip app-debug.apk -d extracted
+# Refresh dependencies
+./gradlew --refresh-dependencies
 
-# View manifest
-aapt dump badging app-debug.apk
-
-# View method count
-# Install dex-method-counts first
-dex-method-counts app-debug.apk
+# Clear cache
+./gradlew clean cleanBuildCache
 ```
 
+### Signing Issues
+
+**"App not signed" error:**
+```bash
+# Check signing configuration
+./gradlew :app:signingReport
+
+# Verify keystore exists and credentials are correct
+```
+
+**ProGuard breaks app:**
+```proguard
+# Add keep rules in proguard-rules.pro
+-keep class com.your.package.** { *; }
+```
+
+**Upload rejected by Play Console:**
+- Version code not incremented
+- Signature mismatch
+- Missing required permissions
+- Policy violations
+
 ## Next Steps
 
-- **Install and test** - Use the **Debug** workflow
-- **Sign and publish** - Use the **Publish** workflow
-- **Run tests** - Use the **Test** workflow
+- **Debug and test** - Use the **Debug** workflow
+- **Monitor app performance** - Play Console metrics
+- **Respond to user feedback** - Reviews and ratings
+- **Plan updates** - New features and bug fixes
 
 ## 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)
+- [Gomobile Documentation](https://pkg.go.dev/golang.org/x/mobile/cmd/gomobile)
+- [Publish Your App](https://developer.android.com/studio/publish)
+- [Play Console](https://play.google.com/console)
+- [App Signing](https://developer.android.com/studio/publish/app-signing)

@@ -1,6 +1,6 @@
 # Debug Workflow
 
-Debug Android applications using adb, logcat, and Android debugging tools.
+Debug, test, and profile Android applications using adb, emulator, logcat, and testing frameworks.
 
 ## ADB (Android Debug Bridge)
 
@@ -13,6 +13,12 @@ adb devices
 # Connect to specific device (if multiple)
 adb -s <device-id> <command>
 
+# Target emulator specifically
+adb -e <command>
+
+# Target physical device specifically
+adb -d <command>
+
 # Check device info
 adb shell getprop ro.product.model
 adb shell getprop ro.build.version.release
@@ -57,6 +63,81 @@ adb shell am force-stop com.example.myapp
 adb shell am kill com.example.myapp
 ```
 
+### 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
+```
+
 ## Logcat
 
 ### View Logs
@@ -151,6 +232,575 @@ adb logcat | grep "panic:"
 adb logcat | grep "GoLog"
 ```
 
+## Emulator
+
+### 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 |
+
+**Install System Images:**
+
+```bash
+# List available system images
+sdkmanager --list | grep system-images
+
+# 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)
+sdkmanager "system-images;android-34;google_apis;arm64-v8a"
+
+# Android 13 (API 33)
+sdkmanager "system-images;android-33;google_apis;x86_64"
+```
+
+**Choose architecture:**
+- Intel/AMD processors: `x86_64`
+- Apple Silicon (M1/M2/M3): `arm64-v8a`
+
+### Create AVD
+
+```bash
+# Quick start
+avdmanager create avd \
+    -n Pixel7 \
+    -k "system-images;android-34;google_apis;x86_64" \
+    -d "pixel_7"
+
+# List available device definitions
+avdmanager list device
+
+# Common devices: pixel_7, pixel_7_pro, pixel_6, pixel_5, pixel_tablet
+```
+
+**Examples:**
+
+```bash
+# 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
+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
+```
+
+### Manage AVDs
+
+```bash
+# List all AVDs
+avdmanager list avd
+
+# List with paths
+avdmanager list avd -c
+
+# Delete AVD
+avdmanager delete avd -n Pixel7
+```
+
+### Start Emulator
+
+**Basic:**
+
+```bash
+# Start AVD
+emulator -avd Pixel7
+
+# Start in background
+emulator -avd Pixel7 &
+
+# Start with GPU acceleration
+emulator -avd Pixel7 -gpu host
+```
+
+**Common Options:**
+
+```bash
+# Wipe data (factory reset)
+emulator -avd Pixel7 -wipe-data
+
+# Read-only system
+emulator -avd Pixel7 -read-only
+
+# Increase RAM
+emulator -avd Pixel7 -memory 4096
+
+# Cold boot (ignore snapshot)
+emulator -avd Pixel7 -no-snapshot-load
+
+# No audio
+emulator -avd Pixel7 -no-audio
+
+# Maximum performance
+emulator -avd Pixel7 \
+    -gpu host \
+    -memory 4096 \
+    -cores 4 \
+    -no-boot-anim \
+    -no-snapshot
+```
+
+**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
+
+**Via Telnet:**
+
+```bash
+# Connect to emulator console
+telnet localhost 5554  # Port 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
+```
+
+**Via ADB:**
+
+```bash
+# 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
+```
+
+### Multiple Emulators
+
+```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 5554, adb 5555
+- Second emulator: console 5556, adb 5557
+
+## Testing
+
+### Test Types
+
+| Type | Runs On | Speed | Use For |
+|------|---------|-------|---------|
+| Unit Tests | JVM | Fast | Business logic, utilities |
+| Instrumentation Tests | Android device/emulator | Slow | Android APIs, database |
+| UI Tests | Android device/emulator | Slowest | User interface, interactions |
+
+### Unit Tests (Local Tests)
+
+**Location:** `app/src/test/java/com/example/myapp/`
+
+**Dependencies:**
+
+```kotlin
+dependencies {
+    testImplementation("junit:junit:4.13.2")
+    testImplementation("org.mockito:mockito-core:5.7.0")
+    testImplementation("org.mockito.kotlin:mockito-kotlin:5.2.1")
+}
+```
+
+**Example:**
+
+```kotlin
+package com.example.myapp
+
+import org.junit.Test
+import org.junit.Assert.*
+
+class CalculatorTest {
+
+    @Test
+    fun addition_isCorrect() {
+        val calculator = Calculator()
+        val result = calculator.add(2, 3)
+        assertEquals(5, result)
+    }
+
+    @Test
+    fun division_byZero_throwsException() {
+        val calculator = Calculator()
+        assertThrows(ArithmeticException::class.java) {
+            calculator.divide(10, 0)
+        }
+    }
+}
+```
+
+**Run Unit Tests:**
+
+```bash
+# All unit tests
+./gradlew test
+
+# Specific variant
+./gradlew testDebug
+
+# Specific test class
+./gradlew test --tests CalculatorTest
+
+# With coverage report
+./gradlew testDebugUnitTest jacocoTestReport
+```
+
+**View Results:**
+
+```bash
+# HTML report
+open app/build/reports/tests/testDebugUnitTest/index.html
+
+# Coverage report
+open app/build/reports/jacoco/jacocoTestReport/html/index.html
+```
+
+### Instrumentation Tests
+
+**Location:** `app/src/androidTest/java/com/example/myapp/`
+
+**Dependencies:**
+
+```kotlin
+android {
+    defaultConfig {
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+    }
+}
+
+dependencies {
+    androidTestImplementation("androidx.test.ext:junit:1.1.5")
+    androidTestImplementation("androidx.test:runner:1.5.2")
+    androidTestImplementation("androidx.test:rules:1.5.0")
+    androidTestImplementation("androidx.test.espresso:espresso-core:3.5.1")
+}
+```
+
+**Example:**
+
+```kotlin
+package com.example.myapp
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.Assert.*
+
+@RunWith(AndroidJUnit4::class)
+class DatabaseTest {
+
+    @Test
+    fun useAppContext() {
+        val appContext = InstrumentationRegistry.getInstrumentation().targetContext
+        assertEquals("com.example.myapp", appContext.packageName)
+    }
+}
+```
+
+**Run Instrumentation Tests:**
+
+```bash
+# Connect device/emulator first
+adb devices
+
+# All instrumentation tests
+./gradlew connectedAndroidTest
+
+# Specific variant
+./gradlew connectedDebugAndroidTest
+
+# Specific test
+./gradlew connectedAndroidTest -Pandroid.testInstrumentationRunnerArguments.class=com.example.myapp.DatabaseTest
+```
+
+### UI Tests (Espresso)
+
+**Dependencies:**
+
+```kotlin
+dependencies {
+    androidTestImplementation("androidx.test.espresso:espresso-core:3.5.1")
+    androidTestImplementation("androidx.test.espresso:espresso-intents:3.5.1")
+    androidTestImplementation("androidx.test.espresso:espresso-contrib:3.5.1")
+}
+```
+
+**Example:**
+
+```kotlin
+package com.example.myapp
+
+import androidx.test.ext.junit.rules.ActivityScenarioRule
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.espresso.Espresso.onView
+import androidx.test.espresso.action.ViewActions.*
+import androidx.test.espresso.assertion.ViewAssertions.matches
+import androidx.test.espresso.matcher.ViewMatchers.*
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class MainActivityTest {
+
+    @get:Rule
+    val activityRule = ActivityScenarioRule(MainActivity::class.java)
+
+    @Test
+    fun button_click_showsText() {
+        // Type text in EditText
+        onView(withId(R.id.editText))
+            .perform(typeText("Hello"), closeSoftKeyboard())
+
+        // Click button
+        onView(withId(R.id.button))
+            .perform(click())
+
+        // Verify text is displayed
+        onView(withId(R.id.textView))
+            .check(matches(withText("Hello")))
+    }
+}
+```
+
+**Common Espresso Operations:**
+
+```kotlin
+// Find views
+onView(withId(R.id.viewId))
+onView(withText("text"))
+onView(withContentDescription("description"))
+
+// Actions
+perform(click())
+perform(typeText("text"))
+perform(replaceText("new text"))
+perform(clearText())
+perform(closeSoftKeyboard())
+perform(swipeLeft())
+perform(swipeRight())
+perform(scrollTo())
+
+// Assertions
+check(matches(isDisplayed()))
+check(matches(withText("expected")))
+check(matches(isEnabled()))
+check(matches(isChecked()))
+check(doesNotExist())
+```
+
+### Testing Gomobile Integration
+
+**Unit Test Go Code (Before binding):**
+
+```bash
+cd golib
+go test ./...
+go test -v ./...
+go test -cover ./...
+```
+
+**Test AAR Integration:**
+
+```kotlin
+package com.example.myapp
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import mylib.Mylib  // Import gomobile generated package
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.Assert.*
+
+@RunWith(AndroidJUnit4::class)
+class GomobileTest {
+
+    @Test
+    fun goFunction_returnsExpectedResult() {
+        val result = Mylib.fetchURL("https://example.com")
+        assertNotNull(result)
+        assertTrue(result.isNotEmpty())
+    }
+
+    @Test
+    fun goFunction_handlesError() {
+        try {
+            Mylib.fetchURL("invalid-url")
+            fail("Should have thrown exception")
+        } catch (e: Exception) {
+            assertTrue(e.message?.contains("error") == true)
+        }
+    }
+}
+```
+
+### Code Coverage (JaCoCo)
+
+**Configure:**
+
+```kotlin
+plugins {
+    id("jacoco")
+}
+
+android {
+    buildTypes {
+        debug {
+            enableAndroidTestCoverage = true
+            enableUnitTestCoverage = true
+        }
+    }
+}
+
+tasks.register<JacocoReport>("jacocoTestReport") {
+    dependsOn("testDebugUnitTest", "createDebugCoverageReport")
+
+    reports {
+        xml.required.set(true)
+        html.required.set(true)
+    }
+
+    val fileFilter = listOf(
+        "**/R.class",
+        "**/R$*.class",
+        "**/BuildConfig.*",
+        "**/Manifest*.*"
+    )
+
+    val debugTree = fileTree("${project.buildDir}/intermediates/javac/debug") {
+        exclude(fileFilter)
+    }
+
+    val mainSrc = "${project.projectDir}/src/main/java"
+
+    sourceDirectories.setFrom(files(mainSrc))
+    classDirectories.setFrom(files(debugTree))
+    executionData.setFrom(fileTree(project.buildDir) {
+        include("jacoco/testDebugUnitTest.exec", "outputs/code_coverage/debugAndroidTest/connected/**/*.ec")
+    })
+}
+```
+
+**Run Coverage:**
+
+```bash
+./gradlew jacocoTestReport
+open app/build/reports/jacoco/jacocoTestReport/html/index.html
+```
+
+### Test Best Practices
+
+**1. Follow AAA Pattern:**
+
+```kotlin
+@Test
+fun testName() {
+    // Arrange - Set up test data
+    val calculator = Calculator()
+
+    // Act - Execute the function
+    val result = calculator.add(2, 3)
+
+    // Assert - Verify the result
+    assertEquals(5, result)
+}
+```
+
+**2. Use Descriptive Names:**
+
+```kotlin
+// Good
+@Test
+fun addition_withPositiveNumbers_returnsSum() { }
+
+@Test
+fun division_withZeroDivisor_throwsException() { }
+
+// Bad
+@Test
+fun test1() { }
+```
+
+**3. Test One Thing:**
+
+```kotlin
+// Good - separate tests
+@Test
+fun add_returnsCorrectSum() { }
+
+@Test
+fun add_handlesNegativeNumbers() { }
+```
+
+**4. Mock External Dependencies:**
+
+```kotlin
+import org.mockito.Mock
+import org.mockito.Mockito.*
+
+class UserRepositoryTest {
+
+    @Mock
+    lateinit var api: ApiService
+
+    @Test
+    fun getUser_callsApi() {
+        val userId = "123"
+        `when`(api.fetchUser(userId)).thenReturn(User("John"))
+
+        val repository = UserRepository(api)
+        val user = repository.getUser(userId)
+
+        verify(api).fetchUser(userId)
+        assertEquals("John", user.name)
+    }
+}
+```
+
 ## Debugging from Code
 
 ### Android (Kotlin/Java)
@@ -183,7 +833,8 @@ class MainActivity : AppCompatActivity() {
 }
 ```
 
-View in logcat:
+**View in logcat:**
+
 ```bash
 adb logcat -s MainActivity
 ```
@@ -198,7 +849,6 @@ 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 {
@@ -211,87 +861,35 @@ func FetchData(url string) (string, error) {
 }
 ```
 
-View in logcat:
+**View in logcat:**
+
 ```bash
 adb logcat | grep GoLog
 ```
 
-## Device/Emulator Commands
+### Interactive Debugging
 
-### File Operations
+**Enable Debug Mode:**
 
-```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
+```kotlin
+// app/build.gradle.kts
+android {
+    buildTypes {
+        debug {
+            isDebuggable = true
+        }
+    }
+}
 ```
 
-### Screenshots and Screen Recording
+**Using Android Studio Debugger:**
 
-```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
-```
+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
 
 ## Performance Profiling
 
@@ -363,7 +961,8 @@ java.lang.NullPointerException: Attempt to invoke virtual method '...' on a null
 
 ### 4. Common Crash Types
 
-**NullPointerException**:
+**NullPointerException:**
+
 ```kotlin
 // Bad
 val user = getUser()  // Returns null
@@ -374,7 +973,8 @@ val user = getUser()
 val name = user?.name ?: "Unknown"
 ```
 
-**ClassCastException**:
+**ClassCastException:**
+
 ```kotlin
 // Bad
 val text = view as TextView  // Crash if not TextView!
@@ -383,7 +983,8 @@ val text = view as TextView  // Crash if not TextView!
 val text = view as? TextView
 ```
 
-**ActivityNotFoundException**:
+**ActivityNotFoundException:**
+
 ```kotlin
 // Check if intent can be handled
 if (intent.resolveActivity(packageManager) != null) {
@@ -391,43 +992,6 @@ if (intent.resolveActivity(packageManager) != null) {
 }
 ```
 
-## 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
@@ -446,9 +1010,11 @@ adb reverse tcp:8888 tcp:8888
 adb shell dumpsys netstats
 ```
 
-## Common Issues
+## Troubleshooting
 
-### "adb: device offline"
+### ADB Issues
+
+**"adb: device offline":**
 
 ```bash
 adb kill-server
@@ -456,7 +1022,7 @@ adb start-server
 # Reconnect device
 ```
 
-### "adb: device unauthorized"
+**"adb: device unauthorized":**
 
 - Check device screen for authorization prompt
 - Accept "Always allow from this computer"
@@ -467,7 +1033,7 @@ adb start-server
   adb start-server
   ```
 
-### "Logcat shows nothing"
+**"Logcat shows nothing":**
 
 ```bash
 # Clear buffer
@@ -480,21 +1046,92 @@ adb logcat -g
 adb logcat -G 16M
 ```
 
-### App not showing in process list
+### Emulator Issues
+
+**Emulator won't start:**
 
 ```bash
-# Check if app is running
-adb shell "ps -A | grep com.example.myapp"
+# Check emulator location
+which emulator
 
-# Start app if not running
-adb shell am start -n com.example.myapp/.MainActivity
+# Run with verbose logging
+emulator -avd Pixel7 -verbose
+
+# Check for errors
+emulator -avd Pixel7 -debug init
 ```
 
-## Debug Helpers
+**Slow emulator - Enable hardware acceleration:**
 
-### Monitor script
+**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:** Automatically uses Hypervisor Framework
+
+**Windows (HAXM):**
+
+```bash
+sdkmanager "extras;intel;Hardware_Accelerated_Execution_Manager"
+```
+
+**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
+```
+
+### Test Issues
+
+**Tests fail on CI but pass locally:**
+
+- Check Android API level compatibility
+- Verify emulator configuration
+- Check for timing issues (add timeouts)
+- Ensure deterministic test data
+
+**Instrumentation tests hang:**
+
+```bash
+# Clear app data between tests
+adb shell pm clear com.example.myapp
+
+# Restart adb
+adb kill-server
+adb start-server
+```
+
+**Espresso can't find view:**
+
+```kotlin
+// Use idling resources for async operations
+import androidx.test.espresso.IdlingRegistry
+import androidx.test.espresso.IdlingResource
+```
+
+## Helper Scripts
+
+### Monitor App Script
 
 Create `monitor-app.sh`:
+
 ```bash
 #!/usr/bin/env bash
 set -euo pipefail
@@ -509,9 +1146,10 @@ adb logcat -c
 adb logcat | grep --color=always -E "$APP_PACKAGE|$LOG_TAG|FATAL|ERROR"
 ```
 
-### Install and monitor script
+### Install and Monitor Script
 
 Create `debug-install.sh`:
+
 ```bash
 #!/usr/bin/env bash
 set -euo pipefail
@@ -531,14 +1169,120 @@ adb logcat -c
 adb logcat | grep "$PACKAGE"
 ```
 
+### Start Emulator and Wait
+
+Create `start-emulator.sh`:
+
+```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!"
+```
+
+## CI/CD Testing
+
+### GitHub Actions Example
+
+`.github/workflows/test.yml`:
+
+```yaml
+name: Android CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    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 Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.22'
+
+      - name: Test Go code
+        run: |
+          cd golib
+          go test -v ./...
+
+      - name: Build gomobile AAR
+        run: |
+          go install golang.org/x/mobile/cmd/gomobile@latest
+          gomobile init
+          cd golib
+          gomobile bind -target=android -o mylib.aar .
+          cp mylib.aar ../app/libs/
+
+      - name: Run unit tests
+        run: ./gradlew test
+
+      - name: Run instrumented tests
+        uses: reactivecircus/android-emulator-runner@v2
+        with:
+          api-level: 34
+          target: google_apis
+          arch: x86_64
+          script: ./gradlew connectedCheck
+
+      - name: Upload test results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: test-results
+          path: app/build/reports/tests/
+
+      - name: Upload coverage
+        uses: codecov/codecov-action@v3
+        with:
+          files: app/build/reports/jacoco/jacocoTestReport/jacocoTestReport.xml
+```
+
 ## Next Steps
 
-- **Run tests** - Use the **Test** workflow
-- **Profile performance** - Advanced profiling techniques
-- **Publish app** - Use the **Publish** workflow
+- **Build and publish** - Use the **Build** workflow for release builds
+- **Increase coverage** - Aim for >80% test coverage
+- **Profile performance** - Identify and fix bottlenecks
+- **Monitor crashes** - Set up crash reporting (Firebase Crashlytics)
 
 ## 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)
+- [Android Testing](https://developer.android.com/training/testing)
+- [Espresso Documentation](https://developer.android.com/training/testing/espresso)
+- [Emulator Documentation](https://developer.android.com/studio/run/emulator)