import gradio as gr import subprocess import zipfile import os import re import hashlib import tempfile import time import shutil import threading import glob from pathlib import Path # ── ZeroGPU ──────────────────────────────────────────────────── # ZeroGPU inadai angalau function moja yenye @spaces.GPU wakati wa kuanza, vinginevyo # Space inaanguka na "No @spaces.GPU function detected during startup". # Builder hii inatumia CPU tu (Gradle/Electron), kwa hiyo function hii ni ya kimya: # haiitwi kamwe na haitumii quota ya GPU. Kwenye "CPU basic" kipande hiki hakina athari. try: import spaces @spaces.GPU def _gpu_placeholder(): return None except Exception: pass VERSION = "5.1.0-builder-apk-exe" AUTHOR = "JAYNES MAX" # Spaces za ZeroGPU hazitumii root: /opt haiandikiki. Tumia /opt ikiwa inaandikika, # vinginevyo folda ya /tmp (zana zinapakuliwa upya Space ikianza upya). TOOLS = "/opt" if os.access("/opt", os.W_OK) else "/tmp/jm_tools" os.makedirs(TOOLS, exist_ok=True) IS_ROOT = hasattr(os, "geteuid") and os.geteuid() == 0 # ══════════════════════════════════════════════════════════════ # CORE UTILITIES # ══════════════════════════════════════════════════════════════ def run(cmd, timeout=60): try: r = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=timeout) return (r.stdout + r.stderr).strip() except subprocess.TimeoutExpired: return "⏱ [TIMEOUT] Command exceeded time limit." except Exception as e: return f"❌ [ERROR] {e}" def sha256_file(path): h = hashlib.sha256() with open(path, "rb") as f: for chunk in iter(lambda: f.read(65536), b""): h.update(chunk) return h.hexdigest() def human_size(n: int) -> str: for unit in ["B", "KB", "MB", "GB"]: if n < 1024: return f"{n:.1f} {unit}" n /= 1024 return f"{n:.1f} TB" # ── Paths ───────────────────────────────────────────────────── ANDROID_SDK = f"{TOOLS}/android-sdk" CMDLINE_TOOLS = f"{ANDROID_SDK}/cmdline-tools/latest/bin" BUILD_TOOLS = f"{ANDROID_SDK}/build-tools/34.0.0" PLATFORM = f"{ANDROID_SDK}/platforms/android-34" APK_OUT_DIR = "/tmp/apk_builds" os.makedirs(APK_OUT_DIR, exist_ok=True) TEXT_EXTS = { ".kt", ".java", ".gradle", ".xml", ".json", ".yaml", ".yml", ".properties", ".txt", ".md", ".pro", ".toml", ".bat", ".sh", ".kts", ".cfg", ".ini", } # ══════════════════════════════════════════════════════════════ # ZIP PROJECT EXTRACTOR # ══════════════════════════════════════════════════════════════ def extract_zip_project(zip_path: str, logs: list) -> tuple: """ Extract an Android project ZIP safely. - Sanitizes paths: strips leading dirs, skips paths with '{' or '..' - Returns (text_files, binary_dir) where: text_files = list of (relative_path, content_str) for text files binary_dir = path to temp dir containing extracted binary files """ text_files = [] tmp_dir = tempfile.mkdtemp(prefix="zipproj_") logs.append(f"📦 Inabomoa ZIP: {os.path.basename(zip_path)}") try: with zipfile.ZipFile(zip_path, "r") as z: all_names = z.namelist() logs.append(f" Faili zote kwenye ZIP: {len(all_names)}") # Detect common root prefix to strip (e.g. "myproject/") root_prefix = "" non_dir = [n for n in all_names if not n.endswith("/")] if non_dir: parts0 = non_dir[0].split("/") if len(parts0) > 1: candidate = parts0[0] + "/" if all(n.startswith(candidate) or n == candidate for n in all_names): root_prefix = candidate if root_prefix: logs.append(f" Root prefix kuondolewa: '{root_prefix}'") skipped = 0 extracted_text = 0 extracted_bin = 0 for member in all_names: rel = member[len(root_prefix):] if root_prefix and member.startswith(root_prefix) else member if not rel or rel.endswith("/"): continue if "{" in rel or "}" in rel or ".." in rel: logs.append(f" ⚠️ Skipped (unsafe path): {member}") skipped += 1 continue ext = Path(rel).suffix.lower() dest_path = os.path.join(tmp_dir, rel) os.makedirs(os.path.dirname(dest_path), exist_ok=True) try: data = z.read(member) except Exception as e: logs.append(f" ⚠️ Soma error: {rel} — {e}") skipped += 1 continue if ext in TEXT_EXTS: try: content = data.decode("utf-8", errors="ignore") text_files.append((rel, content)) extracted_text += 1 except Exception: skipped += 1 else: try: with open(dest_path, "wb") as f: f.write(data) extracted_bin += 1 except Exception as e: logs.append(f" ⚠️ Binary write error: {rel} — {e}") skipped += 1 logs.append(f" ✅ Text: {extracted_text} | Binary: {extracted_bin} | Skipped: {skipped}") except zipfile.BadZipFile as e: logs.append(f" ❌ ZIP corrupted: {e}") except Exception as e: logs.append(f" ❌ ZIP error: {e}") return text_files, tmp_dir # ══════════════════════════════════════════════════════════════ # SDK BOOTSTRAP (runs once, background) # ══════════════════════════════════════════════════════════════ _sdk_lock = threading.Lock() _sdk_ready = False _sdk_log = [] def _log(msg): _sdk_log.append(msg) def _find_java() -> str: for candidate in [ "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", "/usr/lib/jvm/java-17-openjdk/bin/java", "/usr/lib/jvm/temurin-17/bin/java", "/usr/local/lib/jvm/java-17/bin/java", f"{TOOLS}/jdk17/bin/java", ]: if os.path.exists(candidate): return candidate out = run("which java 2>/dev/null || command -v java 2>/dev/null", timeout=5) if out and "not found" not in out and os.path.exists(out.strip()): return out.strip() return "" def _bootstrap_sdk(): global _sdk_ready with _sdk_lock: if _sdk_ready: return _log("📦 Checking Android SDK...") java_bin = _find_java() if not java_bin and IS_ROOT: _log("⬇️ Installing OpenJDK 17...") apt_out = run( "apt-get update -qq 2>&1 | tail -2 && " "apt-get install -y openjdk-17-jdk-headless 2>&1 | tail -5", timeout=300 ) _log(f" apt: {apt_out[-200:] if apt_out else 'no output'}") java_bin = _find_java() if not java_bin: _log("⬇️ apt failed — Downloading Temurin JDK 17...") jdk_url = ( "https://github.com/adoptium/temurin17-binaries/releases/download/" "jdk-17.0.11%2B9/OpenJDK17U-jdk_x64_linux_hotspot_17.0.11_9.tar.gz" ) run(f"mkdir -p {TOOLS}/jdk17", timeout=5) dl = run(f"wget -q -O /tmp/jdk17.tar.gz '{jdk_url}'", timeout=300) _log(f" JDK download: {dl[:80] if dl else 'ok'}") run(f"tar -xzf /tmp/jdk17.tar.gz -C {TOOLS}/jdk17 --strip-components=1", timeout=120) java_bin = f"{TOOLS}/jdk17/bin/java" if not java_bin or not os.path.exists(java_bin): _log("❌ Java haikuinstall. Build itashindwa. Restart Space na ujaribu tena.") _sdk_ready = True return _log(f" ✅ Java: {run(f'{java_bin} -version 2>&1 | head -1', timeout=10)}") java_home = str(Path(java_bin).parent.parent) os.environ["JAVA_HOME"] = java_home os.environ["PATH"] = f"{java_home}/bin:" + os.environ.get("PATH", "") if not os.path.isdir(CMDLINE_TOOLS): _log("⬇️ Downloading Android command-line tools...") cmdtools_url = "https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip" run(f"mkdir -p {ANDROID_SDK}/cmdline-tools", timeout=10) dl = run(f"wget -q -O /tmp/cmdtools.zip '{cmdtools_url}'", timeout=180) _log(f" Download: {dl[:80] if dl else 'ok'}") run(f"unzip -q /tmp/cmdtools.zip -d /tmp/cmdtools_extract", timeout=60) run(f"mv /tmp/cmdtools_extract/cmdline-tools {ANDROID_SDK}/cmdline-tools/latest", timeout=10) _log(" cmdline-tools installed.") else: _log(" cmdline-tools: already present.") _log("📋 Accepting SDK licenses...") run(f"yes | {CMDLINE_TOOLS}/sdkmanager --sdk_root={ANDROID_SDK} --licenses 2>&1 | tail -3", timeout=60) if not os.path.isdir(PLATFORM): _log("⬇️ Installing android-34 platform...") run(f"{CMDLINE_TOOLS}/sdkmanager --sdk_root={ANDROID_SDK} 'platforms;android-34' 'build-tools;34.0.0' 2>&1 | tail -5", timeout=300) else: _log(" android-34 platform: already present.") local_gradle_zip = "/tmp/gradle-8.7-bin.zip" gradle_bin = f"{TOOLS}/gradle/bin/gradle" if not os.path.exists(gradle_bin): _log("⬇️ Downloading Gradle 8.7...") run(f"mkdir -p {TOOLS}/gradle_extract", timeout=5) dl = run(f"wget -q -O {local_gradle_zip} " "https://services.gradle.org/distributions/gradle-8.7-bin.zip 2>&1 | tail -2", timeout=300) _log(f" Download: {dl[:100] if dl else 'ok'}") run(f"unzip -q {local_gradle_zip} -d {TOOLS}/gradle_extract", timeout=120) run(f"mv {TOOLS}/gradle_extract/gradle-8.7 {TOOLS}/gradle", timeout=10) else: _log(" Gradle 8.7: already installed.") local_jar = "/tmp/gradle-wrapper.jar" if not os.path.exists(local_jar) or os.path.getsize(local_jar) < 1000: _log("⬇️ Downloading gradle-wrapper.jar...") jar_url = "https://raw.githubusercontent.com/gradle/gradle/v8.7.0/gradle/wrapper/gradle-wrapper.jar" run(f"wget -q -O {local_jar} '{jar_url}'", timeout=60) _log(" gradle-wrapper.jar: ready.") _sdk_ready = True _log("✅ Android SDK ready!") _thread = threading.Thread(target=_bootstrap_sdk, daemon=True) _thread.start() def sdk_status() -> str: status = "\n".join(_sdk_log[-20:]) if _sdk_log else "⏳ Bado inaanza..." if _sdk_ready: return f"✅ SDK tayari!\n\n{status}" return f"⏳ Inainstall SDK...\n\n{status}" # ══════════════════════════════════════════════════════════════ # PROJECT SCAFFOLD # ══════════════════════════════════════════════════════════════ def _write_project(build_dir: str, app_name: str, pkg: str, stream_url: str, uploaded_files: list) -> dict: """ Write a minimal Android project to build_dir. uploaded_files: list of (filename, content_str) from user uploads. Returns dict {rel_path: char_count} of files written. """ pkg_path = pkg.replace(".", "/") written = {} _XML_ATTR_FIXES = [ (r'\bandroid:hintTextColor\b', 'android:textColorHint'), (r'\bapp:hintTextColor\b', 'android:textColorHint'), ] def w(rel_path, content): if rel_path.endswith(".xml"): for pattern, replacement in _XML_ATTR_FIXES: content = re.sub(pattern, replacement, content) full = os.path.join(build_dir, rel_path) os.makedirs(os.path.dirname(full), exist_ok=True) with open(full, "w", encoding="utf-8") as f: f.write(content) written[rel_path] = len(content) uploaded_map = {} for fname, content in (uploaded_files or []): key_full = fname.lower().replace("\\", "/") key_base = os.path.basename(fname).lower() uploaded_map[key_full] = (fname, content) if key_base not in uploaded_map: uploaded_map[key_base] = (fname, content) # ── settings.gradle ────────────────────────────────────── settings_content = uploaded_map.get("settings.gradle", (None, None))[1] if not settings_content: settings_content = f'''pluginManagement {{ repositories {{ google() mavenCentral() gradlePluginPortal() }} }} dependencyResolutionManagement {{ repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS) repositories {{ google() mavenCentral() }} }} rootProject.name = "{app_name}" include ':app' ''' w("settings.gradle", settings_content) # ── root build.gradle ───────────────────────────────────── root_gradle = uploaded_map.get("build.gradle", (None, None))[1] if not root_gradle: root_gradle = '''// Top-level build.gradle plugins { id 'com.android.application' version '8.3.2' apply false id 'org.jetbrains.kotlin.android' version '1.9.23' apply false } ''' w("build.gradle", root_gradle) # ── gradle.properties ───────────────────────────────────── w("gradle.properties", f'''android.useAndroidX=true android.enableJetifier=true kotlin.code.style=official org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8 ''') # ── local.properties ────────────────────────────────────── w("local.properties", f"sdk.dir={ANDROID_SDK}\n") # ── gradle wrapper ───────────────────────────────────────── local_gradle_zip = "/tmp/gradle-8.7-bin.zip" if os.path.exists(local_gradle_zip): dist_url = f"file://{local_gradle_zip}" else: dist_url = "https://services.gradle.org/distributions/gradle-8.7-bin.zip" w("gradle/wrapper/gradle-wrapper.properties", f'''distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists distributionUrl={dist_url} zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists ''') gradlew_script = r'''#!/usr/bin/env sh set -e JAVA_OPTS="${JAVA_OPTS:-}" GRADLE_OPTS="${GRADLE_OPTS:-}" APP_HOME="$(cd "$(dirname "$0")" && pwd)" CLASSPATH="$APP_HOME/gradle/wrapper/gradle-wrapper.jar" if [ -z "$JAVA_HOME" ]; then JAVA_CMD="java" else JAVA_CMD="$JAVA_HOME/bin/java" fi exec "$JAVA_CMD" $JAVA_OPTS \ -classpath "$CLASSPATH" \ org.gradle.wrapper.GradleWrapperMain "$@" ''' gradlew_dest = os.path.join(build_dir, "gradlew") with open(gradlew_dest, "w") as f: f.write(gradlew_script) os.chmod(gradlew_dest, 0o755) jar_dest = os.path.join(build_dir, "gradle/wrapper/gradle-wrapper.jar") os.makedirs(os.path.dirname(jar_dest), exist_ok=True) wrapper_jar_url = "https://raw.githubusercontent.com/gradle/gradle/v8.7.0/gradle/wrapper/gradle-wrapper.jar" local_jar = "/tmp/gradle-wrapper.jar" if not os.path.exists(local_jar): run(f"wget -q -O {local_jar} '{wrapper_jar_url}'", timeout=60) if os.path.exists(local_jar) and os.path.getsize(local_jar) > 1000: shutil.copy(local_jar, jar_dest) # ── app/build.gradle ────────────────────────────────────── app_gradle = None for k in uploaded_map: if "app" in k and "build.gradle" in k: app_gradle = uploaded_map[k][1] break if not app_gradle: app_gradle = f'''plugins {{ id 'com.android.application' id 'org.jetbrains.kotlin.android' }} android {{ namespace '{pkg}' compileSdk 34 defaultConfig {{ applicationId "{pkg}" minSdk 21 targetSdk 34 versionCode 1 versionName "1.0" }} buildTypes {{ debug {{ minifyEnabled false }} release {{ minifyEnabled false proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro' }} }} compileOptions {{ sourceCompatibility JavaVersion.VERSION_17 targetCompatibility JavaVersion.VERSION_17 }} kotlinOptions {{ jvmTarget = '17' }} }} dependencies {{ implementation 'androidx.core:core-ktx:1.13.1' }} ''' w("app/build.gradle", app_gradle) # ── proguard-rules.pro ──────────────────────────────────── w("app/proguard-rules.pro", "# Add project specific ProGuard rules here.\n") # ── AndroidManifest.xml ─────────────────────────────────── manifest = None for k in uploaded_map: if "androidmanifest" in k: manifest = uploaded_map[k][1] break if not manifest: manifest = f''' ''' w(f"app/src/main/AndroidManifest.xml", manifest) # ── MainActivity.kt ─────────────────────────────────────── main_kt = None for k in uploaded_map: if "mainactivity" in k and k.endswith(".kt"): main_kt = uploaded_map[k][1] break if not main_kt: main_kt = f'''package {pkg} import android.app.Activity import android.os.Bundle import android.widget.TextView class MainActivity : Activity() {{ override fun onCreate(savedInstanceState: Bundle?) {{ super.onCreate(savedInstanceState) val tv = TextView(this) tv.text = "{app_name}" setContentView(tv) }} }} ''' w(f"app/src/main/java/{pkg_path}/MainActivity.kt", main_kt) # ── colors.xml, strings.xml, themes.xml ────────────────── strings_content = ( uploaded_map.get("strings.xml") or uploaded_map.get("app/src/main/res/values/strings.xml") ) w("app/src/main/res/values/strings.xml", strings_content[1] if strings_content else f'\n {app_name}\n\n') colors_content = ( uploaded_map.get("colors.xml") or uploaded_map.get("app/src/main/res/values/colors.xml") ) w("app/src/main/res/values/colors.xml", colors_content[1] if colors_content else '\n #FF000000\n #FFFFFFFF\n\n') theme_name = None for k, (_, v) in uploaded_map.items(): if "androidmanifest" in k: tm = re.search(r'android:theme="@style/([^"]+)"', v) if tm: theme_name = tm.group(1) break if not theme_name: theme_name = re.sub(r'[^A-Za-z0-9]', '', app_name) or "AppTheme" themes_content = ( uploaded_map.get("themes.xml") or uploaded_map.get("app/src/main/res/values/themes.xml") ) w("app/src/main/res/values/themes.xml", themes_content[1] if themes_content else f''' ''') # ── Write ALL remaining uploaded text files ─────────────── SCAFFOLD_FILES = { "settings.gradle", "build.gradle", "gradle.properties", "local.properties", "gradle-wrapper.properties", "proguard-rules.pro", "androidmanifest.xml", "mainactivity.kt", "strings.xml", "colors.xml", "themes.xml", } for key, (rel_path, content) in uploaded_map.items(): if "/" not in key: continue basename = os.path.basename(key).lower() if basename in SCAFFOLD_FILES: continue dest_rel = rel_path if not rel_path.startswith("/") else rel_path.lstrip("/") if dest_rel.startswith("src/") or dest_rel.startswith("res/"): dest_rel = "app/" + dest_rel w(dest_rel, content) return written # ══════════════════════════════════════════════════════════════ # PREVIEW SYSTEM — onyesha kila faili litakavyokuwa KABLA ya build # ══════════════════════════════════════════════════════════════ # Hifadhi ya muda: jina la faili (rel path) → maudhui yake, # kati ya "Preview" na "Build APK", ili user aweze kuchagua na kubofya faili. _preview_cache = {} def parse_uploaded_files(uploaded_files): """ Inageuza Gradio File objects kuwa list ya (rel_path, content) text tuples, pamoja na list ya binary dirs (kutoka ZIP), bila kuandika project bado. Returns (parsed_uploads, logs) """ logs = [] parsed_uploads = [] if uploaded_files: for fobj in uploaded_files: if fobj is None: continue try: fname = os.path.basename(fobj.name) ext = Path(fname).suffix.lower() if ext == ".zip": logs.append(f"📦 ZIP ilionekana: {fname}") zip_text, zip_bin_dir = extract_zip_project(fobj.name, logs) parsed_uploads.extend(zip_text) parsed_uploads.append(("__binary_dir__", zip_bin_dir)) continue if ext in TEXT_EXTS: with open(fobj.name, "r", errors="ignore") as f: content = f.read() parsed_uploads.append((fname, content)) logs.append(f"📎 Uploaded: {fname} ({len(content)} chars)") else: logs.append(f"⚠️ Skipped (unsupported ext): {fname}") except Exception as e: logs.append(f"⚠️ File error ({fobj.name}): {e}") return parsed_uploads, logs def build_file_tree_text(written: dict) -> str: """Tengeneza muonekano wa tree (indentation kwa folder) kutoka kwenye dict ya faili.""" paths = sorted(written.keys()) lines = [] prev_parts = [] for p in paths: parts = p.split("/") depth = len(parts) - 1 indent = " " * depth fname = parts[-1] size = written[p] lines.append(f"{indent}├─ {fname} ({size} chars)") total_chars = sum(written.values()) header = f"📂 JUMLA: {len(written)} faili · {total_chars} chars\n" + ("─" * 50) return header + "\n" + "\n".join(lines) def preview_files(app_name, pkg, build_type, uploaded_files): """ Inajenga project (kwenye temp build_dir) BILA kufanya gradle build, kisha inarudisha: (tree_text, dropdown_choices, status_message, syntax_report) """ global _preview_cache _preview_cache = {} app_name = (app_name or "MyApp").strip() pkg = (pkg or "com.example.myapp").strip() parsed_uploads, logs = parse_uploaded_files(uploaded_files) # binary dirs hazihitajiki kwa preview ya text — tunaziacha kwa build halisi text_uploads = [(k, v) for k, v in parsed_uploads if k != "__binary_dir__"] # Tumia temp dir ya muda kuandika project (haitumiki kwa build halisi) preview_dir = tempfile.mkdtemp(prefix="preview_") try: written = _write_project(preview_dir, app_name, pkg, "", text_uploads) except Exception as e: # Rekebisho: lazima irudishe thamani 4 (sawa na outputs za UI), si 3 return f"❌ Preview imeshindwa: {e}", gr.update(choices=[], value=None), "\n".join(logs), "" # Soma maudhui yote kwenye cache, ili dropdown iweze kuyaonyesha papo hapo for rel_path in written: full = os.path.join(preview_dir, rel_path) try: with open(full, "r", encoding="utf-8", errors="ignore") as f: _preview_cache[rel_path] = f.read() except Exception as e: _preview_cache[rel_path] = f"[Imeshindwa kusoma: {e}]" shutil.rmtree(preview_dir, ignore_errors=True) tree_text = build_file_tree_text(written) choices = sorted(written.keys()) status = "\n".join(logs) if logs else "✅ Hakuna faili zilizopakiwa — itatumia defaults zote." syntax_report = quick_syntax_check(written, _preview_cache, pkg) return ( tree_text, gr.update(choices=choices, value=choices[0] if choices else None), status, syntax_report, ) def show_file_content(selected_path): """Inarudisha maudhui ya faili moja kutoka _preview_cache, kwa kuchagua kwenye dropdown.""" if not selected_path: return "Chagua faili kwenye orodha hapo juu kuona maudhui yake." content = _preview_cache.get(selected_path) if content is None: return f"⚠️ Faili '{selected_path}' haipo tena kwenye preview cache. Bonyeza 'Preview Files' tena." return content # ══════════════════════════════════════════════════════════════ # QUICK SYNTAX CHECK — makosa ya wazi KABLA ya Gradle (sekunde, sio dakika) # ══════════════════════════════════════════════════════════════ def _check_kotlin_braces(rel_path: str, content: str) -> list: """Inaangalia braces { } na parens ( ) zisizolingana - kosa la kawaida sana.""" issues = [] brace_count = content.count("{") - content.count("}") paren_count = content.count("(") - content.count(")") if brace_count != 0: issues.append(f"⚠️ {rel_path}: braces {{ }} hazilingani (diff: {brace_count:+d})") if paren_count != 0: issues.append(f"⚠️ {rel_path}: parentheses ( ) hazilingani (diff: {paren_count:+d})") return issues def _check_kotlin_package(rel_path: str, content: str, expected_pkg: str) -> list: """Inaangalia kama 'package x.y.z' line ipo na inalingana na folder ilipo.""" issues = [] m = re.search(r'^\s*package\s+([\w.]+)', content, re.MULTILINE) if not m: issues.append(f"⚠️ {rel_path}: haina 'package' declaration") return issues declared_pkg = m.group(1) # Angalia kama folder path inalingana na package iliyotajwa if "java/" in rel_path: folder_part = rel_path.split("java/", 1)[1] folder_pkg = "/".join(folder_part.split("/")[:-1]).replace("/", ".") if folder_pkg and folder_pkg != declared_pkg: issues.append( f"⚠️ {rel_path}: package '{declared_pkg}' haifanani na folder '{folder_pkg}'" ) return issues def _check_xml_wellformed(rel_path: str, content: str) -> list: """Inaangalia XML tags zinazofunguliwa/kufungwa sahihi (rahisi, sio full XML parser).""" import xml.etree.ElementTree as ET issues = [] try: ET.fromstring(content) except ET.ParseError as e: issues.append(f"❌ {rel_path}: XML SI SAHIHI — {e}") except Exception: pass # binary au tatizo lingine, si jukumu la check hii return issues def _check_manifest_theme_ref(file_contents: dict) -> list: """Inaangalia kama AndroidManifest android:theme inarejea style ambayo IPO kwenye themes.xml.""" issues = [] manifest = file_contents.get("app/src/main/AndroidManifest.xml") themes = file_contents.get("app/src/main/res/values/themes.xml") if not manifest or not themes: return issues m = re.search(r'android:theme="@style/([^"]+)"', manifest) if m: theme_ref = m.group(1) if f'name="{theme_ref}"' not in themes: issues.append( f"❌ AndroidManifest inarejea theme '{theme_ref}' ambayo haipo kwenye themes.xml — " f"hii ndiyo sababu ya kawaida ya 'resource style not found' error." ) return issues def quick_syntax_check(written: dict, file_contents: dict, pkg: str) -> str: """ Inafanya checks za haraka (sekunde) kabla ya Gradle build (dakika). written: dict ya {rel_path: char_count} file_contents: dict ya {rel_path: content} Returns: muhtasari wa text (✅ kama hakuna tatizo, au orodha ya ⚠️/❌) """ all_issues = [] for rel_path in written: content = file_contents.get(rel_path, "") ext = Path(rel_path).suffix.lower() if ext == ".kt": all_issues.extend(_check_kotlin_braces(rel_path, content)) all_issues.extend(_check_kotlin_package(rel_path, content, pkg)) elif ext == ".xml": all_issues.extend(_check_xml_wellformed(rel_path, content)) all_issues.extend(_check_manifest_theme_ref(file_contents)) if not all_issues: return "✅ Quick check: hakuna tatizo la wazi lililogundulika (braces, XML, theme refs)." header = f"⚠️ Quick check imegundua matatizo {len(all_issues)}:\n" + ("─" * 50) return header + "\n" + "\n".join(all_issues) # ══════════════════════════════════════════════════════════════ # BUILD APK (halisi) # ══════════════════════════════════════════════════════════════ def build_android_apk(app_name, pkg, uploaded_files, build_type="debug"): """ Generator: inayield (log_text, apk_path) mara kadhaa wakati build inaendelea, ili Gradio ionyeshe maendeleo papo hapo (live) badala ya kusubiri mwisho. Hatua ya mwisho ina apk_path halisi (au None ikiwa imeshindwa). """ logs = [] # Summary tracker — ✅/❌/⏳ kwa kila hatua kuu, inaonekana JUU ya logi zote summary = { "SDK": "⏳", "Scaffold": "⏳", "Java": "⏳", "Gradle": "⏳", "APK": "⏳", } def render(): summary_lines = [f"{v} {k}" for k, v in summary.items()] return " ".join(summary_lines) + "\n" + ("═" * 60) + "\n" + "\n".join(logs) logs.append(f"🏗️ {AUTHOR} — Android APK Builder") logs.append(f" App : {app_name}") logs.append(f" Package : {pkg}") logs.append(f" Type : {build_type}") logs.append("─" * 60) yield render(), None if not _sdk_ready: logs.append("⏳ Inasubiri SDK imauke... (max 10 min)") yield render(), None for i in range(120): time.sleep(5) if _sdk_ready: break if i % 6 == 0: logs.append(f" ... {(i+1)*5}s — {_sdk_log[-1] if _sdk_log else ''}") yield render(), None if not _sdk_ready: summary["SDK"] = "❌" logs.append("❌ SDK haikumalizika kuinstall. Jaribu tena.") yield render(), None return summary["SDK"] = "✅" logs.append("✅ SDK iko tayari.") yield render(), None parsed_uploads, upload_logs = parse_uploaded_files(uploaded_files) logs.extend(upload_logs) yield render(), None build_id = hashlib.md5(f"{app_name}{pkg}{time.time()}".encode()).hexdigest()[:8] build_dir = os.path.join(APK_OUT_DIR, f"build_{build_id}") os.makedirs(build_dir, exist_ok=True) logs.append(f"\n📁 Build dir: {build_dir}") # Copy binary assets from ZIP into build_dir binary_dirs = [v for k, v in parsed_uploads if k == "__binary_dir__"] non_binary_uploads = [(k, v) for k, v in parsed_uploads if k != "__binary_dir__"] for bin_dir in binary_dirs: if os.path.isdir(bin_dir): copied = 0 skipped_text = 0 for root, dirs, files in os.walk(bin_dir): for bfile in files: ext = Path(bfile).suffix.lower() if ext in TEXT_EXTS: skipped_text += 1 continue src = os.path.join(root, bfile) rel = os.path.relpath(src, bin_dir) dst = os.path.join(build_dir, rel) os.makedirs(os.path.dirname(dst), exist_ok=True) shutil.copy2(src, dst) copied += 1 logs.append(f" 📁 Binary assets copied: {copied} files (text skipped: {skipped_text})") try: written = _write_project(build_dir, app_name, pkg, "", non_binary_uploads) logs.append(f"\n📝 Project files ({len(written)}):") for rel, sz in written.items(): logs.append(f" {rel} ({sz} chars)") except Exception as e: summary["Scaffold"] = "❌" logs.append(f"\n❌ Project scaffold failed: {e}") yield render(), None return # Quick syntax check papo hapo (sekunde) kabla ya Gradle (dakika) file_contents = {} for rel_path in written: full = os.path.join(build_dir, rel_path) try: with open(full, "r", encoding="utf-8", errors="ignore") as f: file_contents[rel_path] = f.read() except Exception: pass syntax_report = quick_syntax_check(written, file_contents, pkg) logs.append(f"\n{syntax_report}") summary["Scaffold"] = "✅" if syntax_report.startswith("✅") else "⚠️" yield render(), None java_home = os.environ.get("JAVA_HOME", "") if not java_home or not os.path.exists(f"{java_home}/bin/java"): java_bin = _find_java() if java_bin: java_home = str(Path(java_bin).parent.parent) if not java_home: summary["Java"] = "❌" logs.append("❌ Java haipatikani. Angalia SDK Status.") yield render(), None return summary["Java"] = "✅" logs.append(f" ☕ JAVA_HOME: {java_home}") yield render(), None env_export = ( f"export JAVA_HOME={java_home} " f"ANDROID_HOME={ANDROID_SDK} ANDROID_SDK_ROOT={ANDROID_SDK} " f"PATH={java_home}/bin:{CMDLINE_TOOLS}:{BUILD_TOOLS}:{TOOLS}/gradle/bin:$PATH;" ) gradle_task = "assembleDebug" if build_type == "debug" else "assembleRelease" jar_in_build = os.path.join(build_dir, "gradle/wrapper/gradle-wrapper.jar") if not os.path.exists(jar_in_build) or os.path.getsize(jar_in_build) < 1000: local_jar = "/tmp/gradle-wrapper.jar" if os.path.exists(local_jar) and os.path.getsize(local_jar) > 1000: os.makedirs(os.path.dirname(jar_in_build), exist_ok=True) shutil.copy(local_jar, jar_in_build) logs.append(" ✅ gradle-wrapper.jar iliwekwa.") gradle_bin = f"{TOOLS}/gradle/bin/gradle" if os.path.exists(jar_in_build) and os.path.getsize(jar_in_build) > 1000: run_gradle = f"cd '{build_dir}' && chmod +x gradlew && ./gradlew" elif os.path.exists(gradle_bin): run_gradle = f"cd '{build_dir}' && {gradle_bin}" logs.append(" ℹ️ Inatumia gradle binary moja kwa moja (wrapper jar haipo)") else: summary["Gradle"] = "❌" logs.append("❌ Gradle haipatikani kabisa. Angalia SDK Status.") yield render(), None return logs.append(f"\n⚡ Running: gradle {gradle_task} ...") logs.append("─" * 60) yield render(), None gradle_cmd = ( f"{env_export} " f"GRADLE_USER_HOME=/tmp/gradle_home " f"{run_gradle} {gradle_task} " f"--no-daemon --stacktrace --info 2>&1" ) # Tekeleza Gradle kwa subprocess.Popen ili tuweze kusoma output LIVE # (badala ya kusubiri mwisho wa command nzima kama 'run()' ya kawaida) gradle_lines = [] try: proc = subprocess.Popen( gradle_cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1 ) last_yield = time.time() for line in proc.stdout: gradle_lines.append(line.rstrip()) # Usiyield kila line (gradle ina maelfu) — yield kila ~2s au kwa lines muhimu is_important = any(x in line for x in ["error", "FAILED", "BUILD SUCCESSFUL", "> Task"]) if time.time() - last_yield > 2 or is_important: preview_tail = "\n".join(gradle_lines[-15:]) yield render() + f"\n\n[Gradle live output — mistari 15 ya mwisho]\n{preview_tail}", None last_yield = time.time() proc.wait(timeout=600) except Exception as e: gradle_lines.append(f"❌ [ERROR running gradle] {e}") gradle_out = "\n".join(gradle_lines) kt_errors = [l for l in gradle_out.splitlines() if any(x in l for x in ["error:", "warning:", ".kt:", "unresolved", "None of the following", "Overload resolution"])] if kt_errors: logs.append("🔴 Kotlin errors:\n" + "\n".join(kt_errors[:60])) logs.append("") logs.append(gradle_out[-4000:] if len(gradle_out) > 4000 else gradle_out) logs.append("─" * 60) yield render(), None apk_pattern = os.path.join(build_dir, f"app/build/outputs/apk/{build_type}/*.apk") apk_files = glob.glob(apk_pattern) if apk_files: apk_src = apk_files[0] apk_name = f"{re.sub(r'[^a-z0-9]', '_', app_name.lower())}_{build_type}_{build_id}.apk" apk_dest = os.path.join(APK_OUT_DIR, apk_name) shutil.copy(apk_src, apk_dest) summary["Gradle"] = "✅" summary["APK"] = "✅" logs.append(f"\n🎉 APK IMEJENGWA!") logs.append(f" 📦 {apk_name}") logs.append(f" 📏 {human_size(os.path.getsize(apk_dest))}") logs.append(f" 🔑 SHA-256: {sha256_file(apk_dest)}") logs.append("\n✅ Download APK hapo juu kisha install kwenye simu yako!") yield render(), apk_dest else: summary["Gradle"] = "❌" summary["APK"] = "❌" logs.append("\n❌ APK haikupatikana. Angalia makosa hapo juu.") if "SDK location not found" in gradle_out: logs.append(" 💡 Tatizo: ANDROID_HOME haijawekwa") elif "Could not resolve" in gradle_out: logs.append(" 💡 Tatizo: Mtandao — haiwezi kupakua dependencies") elif "error:" in gradle_out.lower(): err_lines = [l for l in gradle_out.splitlines() if "error:" in l.lower()] for el in err_lines[:10]: logs.append(f" ❗ {el.strip()}") yield render(), None # ══════════════════════════════════════════════════════════════ # GRADIO UI # ══════════════════════════════════════════════════════════════ css = """ @import url('https://fonts.googleapis.com/css2?family=Share+Tech+Mono&family=Exo+2:wght@300;600;800&family=Orbitron:wght@400;700;900&display=swap'); * { box-sizing: border-box; } body, .gradio-container { background: #060810 !important; color: #c8ffd4 !important; font-family: 'Share Tech Mono', monospace !important; } .gradio-container { max-width: 1500px !important; margin: 0 auto !important; } #header-md p, #header-md h1, #header-md h3 { text-align: center; font-family: 'Orbitron', sans-serif !important; margin: 0; } #header-md h1 { font-size: 2.8em; font-weight: 900; background: linear-gradient(90deg, #00ff88, #00cfff, #7b2fff, #ff2d55); -webkit-background-clip: text; -webkit-text-fill-color: transparent; letter-spacing: 8px; margin-bottom: 4px; animation: glow 3s ease-in-out infinite alternate; } @keyframes glow { from { filter: drop-shadow(0 0 8px #00ff8888); } to { filter: drop-shadow(0 0 20px #00cfffaa); } } #header-md h3 { color: #5af !important; font-weight: 300; letter-spacing: 3px; font-family: 'Exo 2', sans-serif !important; } #header-md p { color: #666 !important; font-size: 0.8em; font-family: 'Exo 2', sans-serif !important; } .gr-panel, .gr-box, .gr-form { background: #0d1117 !important; border: 1px solid #1e3a4a !important; border-radius: 8px !important; } textarea, input[type="text"] { background: #090d12 !important; color: #00ff88 !important; border: 1px solid #1e4a3a !important; font-family: 'Share Tech Mono', monospace !important; font-size: 0.88em !important; border-radius: 6px !important; caret-color: #00ff88; } textarea:focus, input:focus { border-color: #00ff88 !important; box-shadow: 0 0 8px #00ff8844 !important; outline: none !important; } label span { color: #5af !important; font-family: 'Exo 2', sans-serif !important; font-size: 0.82em !important; letter-spacing: 1px; text-transform: uppercase; } #output-box textarea { background: #040710 !important; color: #b8ffcc !important; font-size: 0.82em !important; line-height: 1.5 !important; border: 1px solid #00ff8833 !important; font-family: 'Share Tech Mono', monospace !important; } #tree-box textarea { background: #040710 !important; color: #5af !important; font-size: 0.8em !important; line-height: 1.4 !important; border: 1px solid #5af33 !important; } #content-box textarea { background: #02050a !important; color: #ffd866 !important; font-size: 0.8em !important; line-height: 1.5 !important; border: 1px solid #ffd86633 !important; } #syntax-box textarea { background: #0a0408 !important; color: #ff8866 !important; font-size: 0.82em !important; line-height: 1.5 !important; border: 1px solid #ff886633 !important; } .gr-button { font-family: 'Exo 2', sans-serif !important; font-weight: 700 !important; letter-spacing: 2px !important; border-radius: 6px !important; transition: all 0.2s !important; text-transform: uppercase !important; } button.primary, .gr-button-primary { background: linear-gradient(135deg, #00cc66, #0099ff) !important; color: #000 !important; border: none !important; padding: 12px 28px !important; } button.primary:hover { transform: translateY(-1px); box-shadow: 0 4px 20px #00ff8855 !important; } button.secondary { background: transparent !important; color: #5af !important; border: 1px solid #1e3a4a !important; } button.secondary:hover { border-color: #5af !important; } .upload-button, .file-preview { background: #0d1117 !important; border: 2px dashed #1e4a3a !important; border-radius: 8px !important; color: #5af !important; } .upload-button:hover { border-color: #00ff88 !important; background: #00ff8811 !important; } #footer-md p { color: #222 !important; font-size: 0.72em; text-align:center; } footer { display: none !important; } ::-webkit-scrollbar { width: 6px; height: 6px; } ::-webkit-scrollbar-track { background: #0d1117; } ::-webkit-scrollbar-thumb { background: #1e4a3a; border-radius: 3px; } ::-webkit-scrollbar-thumb:hover { background: #00ff88; } """ with gr.Blocks(title="RE-MAX | App Builder", css=css) as demo: gr.Markdown(""" # ◈ RE-MAX ### ANDROID APK + WINDOWS EXE BUILDER + VIDEO ADS *Preview kila faili kabla ya build · Real Gradle build · EXE kutoka URL* """, elem_id="header-md") gr.Markdown(""" Weka App Name, Package Name, na (hiari) pakia ZIP/files zako za project. **Bonyeza "Preview Files" kwanza** kuona kila faili litakavyokuwa — kisha bonyeza **"BUILD APK"**. Kwa Windows, tumia sehemu ya **WINDOWS EXE BUILDER** chini ya ukurasa. """) with gr.Row(): # ── Left: Config + Upload ───────────────────────────── with gr.Column(scale=1, min_width=340): gr.Markdown("#### ⚙️ App Details") b_app_name = gr.Textbox(label="App Name", value="My App", lines=1) b_pkg = gr.Textbox(label="Package Name", value="com.example.myapp", lines=1) b_type = gr.Radio(choices=["debug", "release"], value="debug", label="Build Type") gr.Markdown("#### 📎 Upload Files Zako (optional)") gr.Markdown( "_ZIP ya project yote (recommended) au files moja moja: " "`MainActivity.kt`, `build.gradle`, `AndroidManifest.xml`, nk. " "Files zinazokosekana zitatengezwa kiotomatiki._" ) b_files = gr.File( label="Upload ZIP au Files za Android", file_types=[".zip", ".kt", ".java", ".gradle", ".kts", ".xml", ".json", ".properties", ".pro", ".txt", ".md", ".toml"], file_count="multiple" ) gr.Markdown("---") b_sdk_btn = gr.Button("📊 SDK Status", variant="secondary") b_preview_btn = gr.Button("👁️ PREVIEW FILES", variant="secondary") b_build_btn = gr.Button("⚡ BUILD APK", variant="primary") b_apk_file = gr.File(label="📥 Download APK", interactive=False) # ── Right: Preview + Log ────────────────────────────── with gr.Column(scale=2): gr.Markdown("#### 📂 File Tree (preview kabla ya build)") b_tree = gr.Textbox( label="", lines=14, max_lines=40, placeholder="Bonyeza 'PREVIEW FILES' kuona muundo kamili wa project...", elem_id="tree-box" ) gr.Markdown("#### 📄 Maudhui ya Faili (chagua kwenye orodha)") b_file_select = gr.Dropdown(label="Chagua faili", choices=[], interactive=True) b_file_content = gr.Textbox( label="", lines=16, max_lines=200, placeholder="Chagua faili hapo juu kuona maudhui yake kamili...", elem_id="content-box" ) gr.Markdown("#### 🔍 Quick Syntax Check (sekunde, kabla ya Gradle)") b_syntax = gr.Textbox( label="", lines=6, max_lines=40, placeholder="Bonyeza 'PREVIEW FILES' kuona makosa ya wazi (braces, XML, theme refs)...", elem_id="syntax-box" ) gr.Markdown("#### 📋 Build Log (live)") b_log = gr.Textbox( label="", lines=20, max_lines=300, placeholder=( "1️⃣ Weka App Name, Package Name\n" "2️⃣ (Hiari) Upload ZIP au files za Android\n" "3️⃣ Bonyeza PREVIEW FILES kuona kila faili litakavyokuwa + quick syntax check\n" "4️⃣ Bonyeza BUILD APK — utaona maendeleo papo hapo (live)\n" "5️⃣ Subiri build imalize (1-5 min)\n" "6️⃣ Download APK → install kwenye simu!" ), elem_id="output-box" ) def do_preview(app_name, pkg, build_type, files): tree, dropdown_update, status, syntax_report = preview_files(app_name, pkg, build_type, files) return tree, dropdown_update, status, syntax_report def do_build(app_name, pkg, build_type, files): # build_android_apk ni generator — Gradio inasapoti generator kwa .click() # ili UI ionyeshe progress LIVE badala ya kusubiri matokeo ya mwisho tu. for log, apk_path in build_android_apk( app_name=(app_name or "MyApp").strip(), pkg=(pkg or "com.example.myapp").strip(), uploaded_files=files if files else [], build_type=build_type or "debug", ): yield log, apk_path b_sdk_btn.click(fn=sdk_status, inputs=[], outputs=[b_log]) b_preview_btn.click( fn=do_preview, inputs=[b_app_name, b_pkg, b_type, b_files], outputs=[b_tree, b_file_select, b_log, b_syntax] ) b_file_select.change( fn=show_file_content, inputs=[b_file_select], outputs=[b_file_content] ) b_build_btn.click( fn=do_build, inputs=[b_app_name, b_pkg, b_type, b_files], outputs=[b_log, b_apk_file] ) gr.Markdown(""" --- **Jinsi inavyofanya kazi:** | Hatua | Maelezo | |-------|---------| | 1 | Weka App Name + Package Name, pakia ZIP/files (hiari) | | 2 | **PREVIEW FILES** — inajenga project structure (bila build), inaonyesha tree + maudhui ya kila faili | | 3 | Chagua faili lolote kwenye dropdown kuona maudhui yake kamili kabla ya kuthibitisha | | 4 | **BUILD APK** — Android SDK + Gradle build halisi | | 5 | APK inakuja moja kwa moja — download na install! | **💡 Tip:** Debug APK inafanya kazi bila signing. Release APK inahitaji keystore. """) # ── WINDOWS EXE BUILDER (inatoka kwenye exe_builder.py, kando ya app.py) ── try: import exe_builder exe_builder.render() except Exception as _exe_err: gr.Markdown(f"⚠️ EXE Builder haipatikani: `{_exe_err}` — hakikisha `exe_builder.py` ipo kando ya `app.py`.") # ── VIDEO AD GENERATOR (inatoka kwenye video_ad.py, kando ya app.py) ── try: import video_ad video_ad.render() except Exception as _vid_err: gr.Markdown(f"⚠️ Video Generator haipatikani: `{_vid_err}` — hakikisha `video_ad.py` ipo kando ya `app.py`.") gr.Markdown(f"*RE-MAX v{VERSION} — {AUTHOR}*", elem_id="footer-md") if __name__ == "__main__": demo.launch(css=css)