Spaces:
Build error
Build error
Download app.py from jumannendange/iphone-stream1: direct link, hf CLI and curl.
- Browser
- Download file 52 kB
-
https://huggingface.co/spaces/jumannendange/iphone-stream1/resolve/main/app.py
- Command line
-
hf download hf://spaces/jumannendange/iphone-stream1/app.py
-
curl -L -o app.py https://huggingface.co/spaces/jumannendange/iphone-stream1/resolve/main/app.py
52 kB
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'''<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
<uses-permission android:name="android.permission.INTERNET" />
<application
android:allowBackup="true"
android:label="{app_name}"
android:supportsRtl="true"
android:theme="@style/{re.sub(r'[^A-Za-z0-9]', '', app_name) or 'AppTheme'}"
android:usesCleartextTraffic="true">
<activity
android:name=".MainActivity"
android:exported="true"
android:screenOrientation="landscape"
android:configChanges="orientation|screenSize|keyboardHidden">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
'''
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'<resources>\n <string name="app_name">{app_name}</string>\n</resources>\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
'<resources>\n <color name="black">#FF000000</color>\n <color name="white">#FFFFFFFF</color>\n</resources>\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'''<resources>
<style name="{theme_name}" parent="android:Theme.Material.NoActionBar.Fullscreen">
</style>
</resources>
''')
# ββ 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)
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
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)}")