apkdev 2.0.0__py3-none-any.whl

apkdev/builder.py

@@ -0,0 +1,671 @@
+"""APK Builder — create projects, compile, sign."""
+
+import os
+import shutil
+import subprocess
+from pathlib import Path
+
+from .utils import check_tool, run, ensure_android_home, is_termux
+
+
+def create_project(name: str) -> Path:
+    """Scaffold a new Kotlin + Gradle APK project."""
+    proj_dir = Path.home() / name
+    src = proj_dir / "app" / "src" / "main"
+    java_dir = src / "java" / "com" / "example" / name.lower()
+    res_dir = src / "res"
+
+    java_dir.mkdir(parents=True, exist_ok=True)
+    (res_dir / "layout").mkdir(parents=True, exist_ok=True)
+    (res_dir / "values").mkdir(parents=True, exist_ok=True)
+
+    # settings.gradle.kts
+    (proj_dir / "settings.gradle.kts").write_text(
+        """pluginManagement {
+    repositories { google(); mavenCentral(); gradlePluginPortal() }
+}
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories { google(); mavenCentral() }
+}
+rootProject.name = "%s"
+include(":app")
+""" % name
+    )
+
+    # build.gradle.kts (root)
+    (proj_dir / "build.gradle.kts").write_text(
+        """plugins {
+    id("com.android.application") version "8.7.3" apply false
+    kotlin("android") version "2.0.21" apply false
+    id("org.jetbrains.kotlin.plugin.compose") version "2.0.21" apply false
+}
+"""
+    )
+
+    # app/build.gradle.kts
+    (proj_dir / "app" / "build.gradle.kts").write_text(
+        """plugins { id("com.android.application"); kotlin("android"); id("org.jetbrains.kotlin.plugin.compose") }
+android {
+    namespace = "com.example.%s"
+    compileSdk = 34
+    defaultConfig {
+        applicationId = "com.example.%s"
+        minSdk = 26; targetSdk = 34; versionCode = 1; versionName = "1.0"
+    }
+    buildFeatures { compose = true }
+    compileOptions { sourceCompatibility = JavaVersion.VERSION_17; targetCompatibility = JavaVersion.VERSION_17 }
+    kotlinOptions { jvmTarget = "17" }
+}
+dependencies {
+    val composeBom = platform("androidx.compose:compose-bom:2024.10.00")
+    implementation(composeBom)
+    implementation("androidx.compose.ui:ui")
+    implementation("androidx.compose.ui:ui-graphics")
+    implementation("androidx.compose.ui:ui-tooling-preview")
+    implementation("androidx.compose.material3:material3")
+    implementation("androidx.compose.material:material-icons-core")
+    implementation("androidx.activity:activity-compose:1.9.3")
+    implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.8.7")
+    implementation("androidx.core:core-ktx:1.13.1")
+    debugImplementation("androidx.compose.ui:ui-tooling")
+}
+""" % (name.lower(), name.lower())
+    )
+
+    # AndroidManifest.xml
+    manifest = (
+        '<?xml version="1.0" encoding="utf-8"?>\n'
+        '<manifest xmlns:android="http://schemas.android.com/apk/res/android">\n'
+        '    <application android:allowBackup="true" android:label="%s"\n'
+        '        android:supportsRtl="true"\n'
+        '        android:theme="@android:style/Theme.Material.Light.NoActionBar">\n'
+        '        <activity android:name=".MainActivity" android:exported="true"\n'
+        '            android:windowSoftInputMode="adjustResize">\n'
+        '            <intent-filter>\n'
+        '                <action android:name="android.intent.action.MAIN" />\n'
+        '                <category android:name="android.intent.category.LAUNCHER" />\n'
+        '            </intent-filter>\n'
+        '        </activity>\n'
+        '    </application>\n'
+        '</manifest>\n'
+    ) % name
+    (src / "AndroidManifest.xml").write_text(manifest)
+
+    # MainActivity.kt
+    (java_dir / "MainActivity.kt").write_text(
+        """package com.example.%s
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import com.example.%s.ui.theme.NotesTheme
+
+class MainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContent {
+            NotesTheme {
+                Surface(
+                    modifier = Modifier.fillMaxSize(),
+                    color = MaterialTheme.colorScheme.background
+                ) {
+                    NotesApp()
+                }
+            }
+        }
+    }
+}
+""" % (name.lower(), name.lower())
+    )
+
+    # Create directories for Compose UI files
+    ui_dir = java_dir / "ui" / "theme"
+    ui_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Theme.kt — Material 3 with dynamic colors
+    (ui_dir / "Theme.kt").write_text(
+        """package com.example.%s.ui.theme
+
+import android.app.Activity
+import android.os.Build
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.darkColorScheme
+import androidx.compose.material3.dynamicDarkColorScheme
+import androidx.compose.material3.dynamicLightColorScheme
+import androidx.compose.material3.lightColorScheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.SideEffect
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.toArgb
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalView
+import androidx.core.view.WindowCompat
+
+private val DarkColorScheme = darkColorScheme(
+    primary = Color(0xFF00D2FF),
+    onPrimary = Color(0xFF003544),
+    primaryContainer = Color(0xFF004D62),
+    onPrimaryContainer = Color(0xFFB3EBFF),
+    secondary = Color(0xFF4DD0E1),
+    tertiary = Color(0xFFB388FF),
+    background = Color(0xFF0D0D1A),
+    surface = Color(0xFF1A1A2E),
+    surfaceVariant = Color(0xFF16213E),
+    onBackground = Color(0xFFE6E1E5),
+    onSurface = Color(0xFFE6E1E5),
+    outline = Color(0xFF3A3A5C),
+)
+
+private val LightColorScheme = lightColorScheme(
+    primary = Color(0xFF006D82),
+    onPrimary = Color.White,
+    primaryContainer = Color(0xFFB3EBFF),
+    onPrimaryContainer = Color(0xFF001F28),
+    secondary = Color(0xFF008C9E),
+    tertiary = Color(0xFF7C52CC),
+    background = Color(0xFFFEFBFF),
+    surface = Color(0xFFFEFBFF),
+    surfaceVariant = Color(0xFFDCE5F0),
+    onBackground = Color(0xFF1B1B1F),
+    onSurface = Color(0xFF1B1B1F),
+)
+
+@Composable
+fun NotesTheme(
+    darkTheme: Boolean = isSystemInDarkTheme(),
+    dynamicColor: Boolean = true,
+    content: @Composable () -> Unit
+) {
+    val colorScheme = when {
+        dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
+            val context = LocalContext.current
+            if (darkTheme) dynamicDarkColorScheme(context)
+            else dynamicLightColorScheme(context)
+        }
+        darkTheme -> DarkColorScheme
+        else -> LightColorScheme
+    }
+    val view = LocalView.current
+    if (!view.isInEditMode) {
+        SideEffect {
+            val window = (view.context as Activity).window
+            window.statusBarColor = colorScheme.background.toArgb()
+            WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = !darkTheme
+        }
+    }
+    MaterialTheme(
+        colorScheme = colorScheme,
+        content = content
+    )
+}
+""" % name.lower()
+    )
+    
+    # Color.kt
+    (ui_dir / "Color.kt").write_text(
+        """package com.example.%s.ui.theme
+
+import androidx.compose.ui.graphics.Color
+
+val Purple80 = Color(0xFFD0BCFF)
+val PurpleGrey80 = Color(0xFFCCC2DC)
+val Pink80 = Color(0xFFEFB8C8)
+val Purple40 = Color(0xFF6650a4)
+val PurpleGrey40 = Color(0xFF625b71)
+val Pink40 = Color(0xFF7D5260)
+""" % name.lower()
+    )
+    
+    # Main composable: NotesApp.kt
+    (java_dir / "NotesApp.kt").write_text(
+        """package com.example.%s
+
+import android.content.Context
+import androidx.compose.animation.*
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material.icons.outlined.*
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextDecoration
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun NotesApp() {
+    var notes by remember { mutableStateOf(listOf<Note>()) }
+    var showDialog by remember { mutableStateOf(false) }
+    var editingNote by remember { mutableStateOf<Note?>(null) }
+    var searchQuery by remember { mutableStateOf("") }
+
+    val filteredNotes = remember(notes, searchQuery) {
+        if (searchQuery.isBlank()) notes
+        else notes.filter { it.title.contains(searchQuery, ignoreCase = true) || it.content.contains(searchQuery, ignoreCase = true) }
+    }
+
+    Scaffold(
+        topBar = {
+            TopAppBar(
+                title = { Text("Notes", fontWeight = FontWeight.Bold) },
+                colors = TopAppBarDefaults.topAppBarColors(
+                    containerColor = MaterialTheme.colorScheme.surface,
+                    titleContentColor = MaterialTheme.colorScheme.onSurface
+                ),
+                actions = {
+                    IconButton(onClick = { /* sort */ }) {
+                        Icon(Icons.Default.Menu, contentDescription = "Menu")
+                    }
+                }
+            )
+        },
+        floatingActionButton = {
+            ExtendedFloatingActionButton(
+                onClick = {
+                    editingNote = null
+                    showDialog = true
+                },
+                icon = { Icon(Icons.Default.Add, contentDescription = null) },
+                text = { Text("New Note") },
+                containerColor = MaterialTheme.colorScheme.primary,
+                contentColor = MaterialTheme.colorScheme.onPrimary
+            )
+        }
+    ) { padding ->
+        Column(modifier = Modifier.padding(padding)) {
+            // Search bar
+            OutlinedTextField(
+                value = searchQuery,
+                onValueChange = { searchQuery = it },
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = 16.dp, vertical = 8.dp),
+                placeholder = { Text("Search notes...") },
+                leadingIcon = { Icon(Icons.Default.Search, contentDescription = null) },
+                trailingIcon = {
+                    if (searchQuery.isNotEmpty()) {
+                        IconButton(onClick = { searchQuery = "" }) {
+                            Icon(Icons.Default.Close, contentDescription = "Clear")
+                        }
+                    }
+                },
+                singleLine = true,
+                shape = RoundedCornerShape(24.dp),
+                colors = OutlinedTextFieldDefaults.colors(
+                    focusedBorderColor = MaterialTheme.colorScheme.primary,
+                    unfocusedBorderColor = MaterialTheme.colorScheme.outline
+                )
+            )
+
+            if (filteredNotes.isEmpty()) {
+                // Empty state
+                Box(
+                    modifier = Modifier.fillMaxSize(),
+                    contentAlignment = Alignment.Center
+                ) {
+                    Column(horizontalAlignment = Alignment.CenterHorizontally) {
+                        Icon(
+                            Icons.Default.Create,
+                            contentDescription = null,
+                            modifier = Modifier.size(80.dp),
+                            tint = MaterialTheme.colorScheme.outline
+                        )
+                        Spacer(Modifier.height(16.dp))
+                        Text(
+                            "No notes yet",
+                            style = MaterialTheme.typography.titleLarge,
+                            color = MaterialTheme.colorScheme.outline
+                        )
+                        Text(
+                            "Tap + to create your first note",
+                            style = MaterialTheme.typography.bodyMedium,
+                            color = MaterialTheme.colorScheme.outline
+                        )
+                    }
+                }
+            } else {
+                LazyColumn(
+                    contentPadding = PaddingValues(16.dp),
+                    verticalArrangement = Arrangement.spacedBy(12.dp)
+                ) {
+                    items(filteredNotes, key = { it.id }) { note ->
+                        NoteCard(
+                            note = note,
+                            onToggle = {
+                                notes = notes.map { if (it.id == note.id) it.copy(done = !it.done) else it }
+                                saveNotes(notes)
+                            },
+                            onEdit = {
+                                editingNote = note
+                                showDialog = true
+                            },
+                            onDelete = {
+                                notes = notes.filter { it.id != note.id }
+                                saveNotes(notes)
+                            }
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    if (showDialog) {
+        NoteDialog(
+            note = editingNote,
+            onDismiss = { showDialog = false; editingNote = null },
+            onSave = { title, content ->
+                if (editingNote != null) {
+                    notes = notes.map { if (it.id == editingNote!!.id) it.copy(title = title, content = content) else it }
+                } else {
+                    notes = listOf(Note(title = title, content = content)) + notes
+                }
+                saveNotes(notes)
+                showDialog = false
+                editingNote = null
+            }
+        )
+    }
+}
+
+@Composable
+fun NoteCard(note: Note, onToggle: () -> Unit, onEdit: () -> Unit, onDelete: () -> Unit) {
+    val surfaceColor = MaterialTheme.colorScheme.surfaceVariant
+    Card(
+        onClick = onEdit,
+        modifier = Modifier.fillMaxWidth(),
+        shape = RoundedCornerShape(16.dp),
+        colors = CardDefaults.cardColors(containerColor = surfaceColor),
+        elevation = CardDefaults.cardElevation(defaultElevation = 2.dp)
+    ) {
+        Row(
+            modifier = Modifier.padding(16.dp),
+            verticalAlignment = Alignment.Top
+        ) {
+            Checkbox(
+                checked = note.done,
+                onCheckedChange = { onToggle() },
+                colors = CheckboxDefaults.colors(
+                    checkedColor = MaterialTheme.colorScheme.primary
+                )
+            )
+            Spacer(Modifier.width(12.dp))
+            Column(modifier = Modifier.weight(1f)) {
+                Text(
+                    text = note.title,
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.SemiBold,
+                    textDecoration = if (note.done) TextDecoration.LineThrough else TextDecoration.None,
+                    color = if (note.done) MaterialTheme.colorScheme.outline else MaterialTheme.colorScheme.onSurface,
+                    maxLines = 2,
+                    overflow = TextOverflow.Ellipsis
+                )
+                if (note.content.isNotBlank()) {
+                    Spacer(Modifier.height(4.dp))
+                    Text(
+                        text = note.content,
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        maxLines = 3,
+                        overflow = TextOverflow.Ellipsis
+                    )
+                }
+            }
+            Spacer(Modifier.width(8.dp))
+            Column {
+                IconButton(onClick = onEdit, modifier = Modifier.size(32.dp)) {
+                    Icon(Icons.Default.Edit, contentDescription = "Edit", tint = MaterialTheme.colorScheme.primary, modifier = Modifier.size(18.dp))
+                }
+                IconButton(onClick = onDelete, modifier = Modifier.size(32.dp)) {
+                    Icon(Icons.Default.Delete, contentDescription = "Delete", tint = MaterialTheme.colorScheme.error, modifier = Modifier.size(18.dp))
+                }
+            }
+        }
+    }
+}
+
+@Composable
+fun NoteDialog(note: Note?, onDismiss: () -> Unit, onSave: (String, String) -> Unit) {
+    var title by remember { mutableStateOf(note?.title ?: "") }
+    var content by remember { mutableStateOf(note?.content ?: "") }
+
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(if (note != null) "Edit Note" else "New Note", fontWeight = FontWeight.Bold) },
+        text = {
+            Column {
+                OutlinedTextField(
+                    value = title,
+                    onValueChange = { title = it },
+                    label = { Text("Title") },
+                    singleLine = true,
+                    modifier = Modifier.fillMaxWidth(),
+                    shape = RoundedCornerShape(12.dp)
+                )
+                Spacer(Modifier.height(12.dp))
+                OutlinedTextField(
+                    value = content,
+                    onValueChange = { content = it },
+                    label = { Text("Content") },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .heightIn(min = 120.dp),
+                    shape = RoundedCornerShape(12.dp),
+                    maxLines = 5
+                )
+            }
+        },
+        confirmButton = {
+            Button(
+                onClick = { onSave(title, content) },
+                enabled = title.isNotBlank()
+            ) {
+                Text("Save")
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) {
+                Text("Cancel")
+            }
+        },
+        containerColor = MaterialTheme.colorScheme.surface,
+        titleContentColor = MaterialTheme.colorScheme.onSurface,
+        textContentColor = MaterialTheme.colorScheme.onSurfaceVariant
+    )
+}
+
+data class Note(
+    val id: Long = System.currentTimeMillis(),
+    val title: String,
+    val content: String = "",
+    val done: Boolean = false
+)
+
+private fun saveNotes(notes: List<Note>) {
+    // Notes are persisted via context or ViewModel in a real app
+    // For this demo, they persist during app session
+}
+
+private fun loadNotes(): MutableList<Note> {
+    return mutableListOf()
+}
+""" % name.lower()
+    )
+    
+    # Remove XML layout (we use Compose)
+    layout_file = res_dir / "layout" / "activity_main.xml"
+
+
+    # strings.xml
+    app_name_str = "%s" % name
+    (res_dir / "values" / "strings.xml").write_text(
+        f"""<?xml version="1.0" encoding="utf-8"?>
+<resources><string name="app_name">{app_name_str}</string></resources>
+"""
+    )
+
+    # local.properties pointing to SDK
+    sdk_home = os.environ.get("ANDROID_HOME", str(Path.home() / "android-sdk"))
+    (proj_dir / "local.properties").write_text(f"sdk.dir={sdk_home}\n")
+
+    # gradle.properties with AndroidX
+    (proj_dir / "gradle.properties").write_text(
+        "org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8\n"
+        "android.useAndroidX=true\n"
+        "android.enableJetifier=true\n"
+    )
+
+    # Gradle wrapper (created manually — no Gradle install needed)
+    _create_gradle_wrapper(proj_dir)
+
+    return proj_dir
+
+
+def _create_gradle_wrapper(proj_dir: Path):
+    """Create Gradle wrapper files manually."""
+    wrapper_dir = proj_dir / "gradle" / "wrapper"
+    wrapper_dir.mkdir(parents=True, exist_ok=True)
+    
+    # gradle-wrapper.properties
+    (wrapper_dir / "gradle-wrapper.properties").write_text(
+        "distributionBase=GRADLE_USER_HOME\n"
+        "distributionPath=wrapper/dists\n"
+        "distributionUrl=https\\://services.gradle.org/distributions/gradle-8.9-bin.zip\n"
+        "networkTimeout=10000\n"
+        "validateDistributionUrl=true\n"
+        "zipStoreBase=GRADLE_USER_HOME\n"
+        "zipStorePath=wrapper/dists\n"
+    )
+    
+    # Download wrapper JAR if not present
+    jar_path = wrapper_dir / "gradle-wrapper.jar"
+    if not jar_path.exists() or jar_path.stat().st_size < 1000:
+        try:
+            import urllib.request
+            # Try Gradle's official wrapper JAR
+            urllib.request.urlretrieve(
+                "https://raw.githubusercontent.com/gradle/gradle/v8.9.0/gradle/wrapper/gradle-wrapper.jar",
+                str(jar_path)
+            )
+        except Exception:
+            pass
+    
+    # Create gradlew script (simplified but functional)
+    gradlew_path = proj_dir / "gradlew"
+    gradlew_path.write_text(
+        '#!/bin/sh\n'
+        'PRG="$0"\n'
+        'while [ -h "$PRG" ]; do ls=`ls -ld "$PRG"`; link=`expr "$ls" : \'.*-> \\(.*\\)$\'`; '
+        'if expr "$link" : \'/.*\' > /dev/null; then PRG="$link"; else PRG=`dirname "$PRG"`/"$link"; fi; done\n'
+        'SAVED="`pwd`"; cd "`dirname \"$PRG\"`/" >/dev/null; APP_HOME="`pwd -P`"; cd "$SAVED" >/dev/null\n'
+        'APP_NAME="Gradle"\n'
+        'APP_BASE_NAME=`basename "$0"`\n'
+        'MAX_FD="maximum"\n'
+        'DEFAULT_JVM_OPTS="-Xmx64m -Xms64m"\n'
+        'CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar\n'
+        'JAVACMD="java"\n'
+        'exec "$JAVACMD" $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS '
+        '"-Dorg.gradle.appname=$APP_BASE_NAME" -classpath "$CLASSPATH" '
+        'org.gradle.wrapper.GradleWrapperMain "$@"\n'
+    )
+    gradlew_path.chmod(0o755)
+
+
+def _patch_aapt2():
+    """Point AGP to the system aapt2 so it skips the bundled x86_64 one."""
+    if not is_termux():
+        return
+    
+    native = shutil.which("aapt2")
+    if not native:
+        return
+    
+    # Tell AGP to use our native aapt2 via gradle.properties
+    # This avoids the x86_64 vs aarch64 incompatibility entirely.
+    native_aapt2_prop = f"android.aapt2FromMavenOverride={native}\n"
+    
+    # Write to project gradle.properties (takes precedence)
+    cwd = Path(os.getcwd())
+    for props_path in [cwd / "gradle.properties", Path.home() / ".gradle" / "gradle.properties"]:
+        try:
+            if props_path.exists():
+                content = props_path.read_text()
+                if "android.aapt2FromMavenOverride" not in content:
+                    props_path.write_text(content + native_aapt2_prop)
+            else:
+                props_path.parent.mkdir(parents=True, exist_ok=True)
+                props_path.write_text(native_aapt2_prop)
+        except Exception:
+            pass
+    
+    # Also clean stale transforms
+    cache = Path.home() / ".gradle" / "caches"
+    for d in cache.rglob("transformed/aapt2-*linux"):
+        if d.is_dir():
+            shutil.rmtree(d, ignore_errors=True)
+
+
+def build_apk(directory: str | None = None) -> None:
+    """Run gradle assembleDebug."""
+    ensure_android_home()
+    cwd = directory or os.getcwd()
+    
+    # Patch AGP's bundled aapt2 before building (it ships x86_64 binary)
+    _patch_aapt2()
+    
+    gradlew = Path(cwd) / "gradlew"
+    if gradlew.exists():
+        gradlew.chmod(0o755)
+        run([str(gradlew), "assembleDebug"], cwd=cwd)
+    else:
+        gradle = check_tool("gradle")
+        run([gradle, "assembleDebug"], cwd=cwd)
+
+    # Print APK path
+    apk_dir = Path(cwd) / "app" / "build" / "outputs" / "apk" / "debug"
+    apks = list(apk_dir.glob("*.apk"))
+    if apks:
+        print(f"\n✅ APK: {apks[0]}")
+
+
+def sign_apk(apk_path: str) -> None:
+    """Sign an APK with debug keystore."""
+    keystore = Path.home() / ".android" / "debug.keystore"
+    if not keystore.exists():
+        # Create it
+        keystore.parent.mkdir(parents=True, exist_ok=True)
+        keytool = check_tool("keytool")
+        run([
+            keytool, "-genkey", "-v", "-keystore", str(keystore),
+            "-storepass", "android", "-alias", "androiddebugkey",
+            "-keypass", "android", "-keyalg", "RSA", "-keysize", "2048",
+            "-validity", "10000",
+            "-dname", "CN=Android Debug,O=Android,C=US",
+        ])
+
+    apksigner = check_tool("apksigner")
+    run([
+        apksigner, "sign", "--ks", str(keystore),
+        "--ks-key-alias", "androiddebugkey",
+        "--ks-pass", "pass:android",
+        "--key-pass", "pass:android",
+        apk_path,
+    ])
+    print(f"✅ Signed: {apk_path}")