py2apk-compiler 0.1.0__py3-none-any.whl

Py2APK/classfile.py

@@ -0,0 +1,191 @@
+"""Parse JVM class files into the members the Jasmin compiler needs.
+
+The reader uses only ``struct``. It walks the constant pool and member tables
+and skips attributes by length, so method bodies are never decoded.
+"""
+
+from __future__ import annotations
+
+import struct
+from dataclasses import dataclass
+
+
+ACC_PUBLIC = 0x0001
+ACC_PRIVATE = 0x0002
+ACC_PROTECTED = 0x0004
+ACC_STATIC = 0x0008
+ACC_INTERFACE = 0x0200
+ACC_SYNTHETIC = 0x1000
+
+
+@dataclass(frozen=True)
+class ClassMember:
+    owner: str
+    name: str
+    descriptor: str
+    is_static: bool
+    opcode: str = ""
+
+
+@dataclass(frozen=True)
+class ParsedClass:
+    internal: str
+    super_internal: str | None
+    is_interface: bool
+    interfaces: tuple[str, ...]
+    methods: tuple[ClassMember, ...]
+    fields: tuple[ClassMember, ...]
+
+
+class ClassFileError(ValueError):
+    """Raised when a class file is not readable."""
+
+
+class _Reader:
+    def __init__(self, data: bytes) -> None:
+        self.data = data
+        self.offset = 0
+
+    def u1(self) -> int:
+        value = self.data[self.offset]
+        self.offset += 1
+        return value
+
+    def u2(self) -> int:
+        value = struct.unpack_from(">H", self.data, self.offset)[0]
+        self.offset += 2
+        return value
+
+    def u4(self) -> int:
+        value = struct.unpack_from(">I", self.data, self.offset)[0]
+        self.offset += 4
+        return value
+
+    def skip(self, count: int) -> None:
+        self.offset += count
+
+    def bytes(self, count: int) -> bytes:
+        chunk = self.data[self.offset : self.offset + count]
+        self.offset += count
+        return chunk
+
+
+def parameter_descriptors(params: str) -> tuple[str, ...]:
+    index = 0
+    found: list[str] = []
+    while index < len(params):
+        start = index
+        index = _skip_field(params, index)
+        found.append(params[start:index])
+    return tuple(found)
+
+
+def split_method_descriptor(descriptor: str) -> tuple[str, str]:
+    """Return the concatenated parameter descriptors and the result descriptor."""
+    if not descriptor.startswith("(") or ")" not in descriptor:
+        raise ClassFileError(f"bad method descriptor: {descriptor}")
+    index = 1
+    while descriptor[index] != ")":
+        index = _skip_field(descriptor, index)
+    return descriptor[1:index], descriptor[index + 1 :]
+
+
+def parse_class(data: bytes) -> ParsedClass:
+    reader = _Reader(data)
+    if len(data) < 8 or reader.u4() != 0xCAFEBABE:
+        raise ClassFileError("class file does not start with 0xCAFEBABE")
+    _ = reader.u2()
+    _ = reader.u2()
+    pool = _constant_pool(reader)
+    access = reader.u2()
+    internal = _class_name(pool, reader.u2())
+    super_index = reader.u2()
+    super_internal = _class_name(pool, super_index) if super_index else None
+    interfaces = tuple(_class_name(pool, reader.u2()) for _ in range(reader.u2()))
+    is_interface = bool(access & ACC_INTERFACE)
+    fields = tuple(_members(reader, pool, internal, is_interface, methods=False))
+    methods = tuple(_members(reader, pool, internal, is_interface, methods=True))
+    return ParsedClass(internal, super_internal, is_interface, interfaces, methods, fields)
+
+
+def _constant_pool(reader: _Reader) -> list[object]:
+    count = reader.u2()
+    pool: list[object] = [None] * count
+    index = 1
+    while index < count:
+        tag = reader.u1()
+        if tag == 1:
+            pool[index] = reader.bytes(reader.u2()).decode("utf-8", "surrogateescape")
+        elif tag in {7, 8, 16, 19, 20}:
+            pool[index] = ("class", reader.u2()) if tag == 7 else reader.u2()
+        elif tag in {3, 4, 9, 10, 11, 12, 17, 18}:
+            reader.skip(4)
+        elif tag in {5, 6}:
+            reader.skip(8)
+            index += 1
+        elif tag == 15:
+            reader.skip(3)
+        else:
+            raise ClassFileError(f"unknown constant-pool tag {tag}")
+        index += 1
+    return pool
+
+
+def _class_name(pool: list[object], index: int) -> str:
+    entry = pool[index]
+    if not isinstance(entry, tuple) or entry[0] != "class":
+        raise ClassFileError(f"constant pool {index} is not a class")
+    name = pool[entry[1]]
+    if not isinstance(name, str):
+        raise ClassFileError(f"class name {entry[1]} is not Utf8")
+    return name
+
+
+def _utf8(pool: list[object], index: int) -> str:
+    value = pool[index]
+    if not isinstance(value, str):
+        raise ClassFileError(f"constant pool {index} is not Utf8")
+    return value
+
+
+def _members(
+    reader: _Reader,
+    pool: list[object],
+    owner: str,
+    is_interface: bool,
+    *,
+    methods: bool,
+) -> list[ClassMember]:
+    found: list[ClassMember] = []
+    for _ in range(reader.u2()):
+        access = reader.u2()
+        name = _utf8(pool, reader.u2())
+        descriptor = _utf8(pool, reader.u2())
+        for _attribute in range(reader.u2()):
+            _ = reader.u2()
+            reader.skip(reader.u4())
+        visible = bool(access & (ACC_PUBLIC | ACC_PROTECTED))
+        if not visible or access & ACC_SYNTHETIC or access & ACC_PRIVATE:
+            continue
+        is_static = bool(access & ACC_STATIC)
+        opcode = ""
+        if methods:
+            if is_static:
+                opcode = "invokestatic"
+            elif name == "<init>":
+                opcode = "invokespecial"
+            elif is_interface:
+                opcode = "invokeinterface"
+            else:
+                opcode = "invokevirtual"
+        found.append(ClassMember(owner, name, descriptor, is_static, opcode))
+    return found
+
+
+def _skip_field(descriptor: str, index: int) -> int:
+    while descriptor[index] == "[":
+        index += 1
+    if descriptor[index] == "L":
+        end = descriptor.index(";", index)
+        return end + 1
+    return index + 1

Py2APK/cli.py

@@ -0,0 +1,159 @@
+"""Command-line interface for Py2APK."""
+
+from __future__ import annotations
+
+import argparse
+from collections.abc import Sequence
+from pathlib import Path
+from typing import cast
+
+from Py2APK.cli_build import build_project
+from Py2APK.cli_compile import compile_project
+from Py2APK.cli_fetch_jars import fetch_jars
+from Py2APK.cli_fetch_platform import main as fetch_platform_main
+from Py2APK.cli_setup import download_jars
+from Py2APK.cli_init import init_project
+
+
+def _setup(args: argparse.Namespace) -> int:
+    destination_arg = cast(str | None, args.destination)
+    destination = None if destination_arg is None else Path(destination_arg)
+    return download_jars(destination)
+
+
+def _init(args: argparse.Namespace) -> int:
+    icon = None if args.icon is None else str(args.icon)
+    return init_project(
+        template_name=str(args.template),
+        icon=icon,
+        package=str(args.package),
+        name=str(args.name),
+        destination=Path(str(args.directory)),
+    )
+
+
+def _fetch_jars(args: argparse.Namespace) -> int:
+    repositories = list(args.repositories or [])
+    dependency_file = None if args.dependencies is None else Path(args.dependencies)
+    return fetch_jars(Path(args.directory).expanduser(), dependency_file, repositories)
+
+
+def _fetch_platform(args: argparse.Namespace) -> int:
+    return fetch_platform_main(Path(args.directory).expanduser())
+
+
+def _compile(_args: argparse.Namespace) -> int:
+    return compile_project()
+
+
+def _build(args: argparse.Namespace) -> int:
+    return build_project(Path(args.directory).expanduser())
+
+
+def create_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="py2apk",
+        description="Build Android APKs from Python source trees.",
+    )
+    subparsers = parser.add_subparsers(dest="command", metavar="COMMAND")
+
+    setup_parser = subparsers.add_parser(
+        "setup",
+        help="set up the required toolchain JAR files",
+    )
+    _ = setup_parser.add_argument(
+        "-d",
+        "--dst",
+        dest="destination",
+        help="destination jars directory (default: detected package assets)",
+    )
+    setup_parser.set_defaults(handler=_setup)
+
+    init_parser = subparsers.add_parser(
+        "init",
+        help="initialize a project from a template",
+    )
+    init_parser.add_argument(
+        "--template",
+        default="blank",
+        help="project template (default: blank)",
+    )
+    init_parser.add_argument("--icon", help="path to the app icon")
+    init_parser.add_argument(
+        "--pkg",
+        dest="package",
+        required=True,
+        help="Android package name",
+    )
+    init_parser.add_argument("--name", required=True, help="display name of the app")
+    init_parser.add_argument("directory", help="directory to create")
+    init_parser.set_defaults(handler=_init)
+
+    compile_parser = subparsers.add_parser(
+        "compile",
+        help="find Python sources that need Jasmin output",
+    )
+    compile_parser.set_defaults(handler=_compile)
+
+    build_parser = subparsers.add_parser(
+        "build",
+        help="build a project into an APK",
+    )
+    build_parser.add_argument(
+        "directory",
+        nargs="?",
+        default=".",
+        help="project directory (default: current directory)",
+    )
+    build_parser.set_defaults(handler=_build)
+
+    fetch_jars_parser = subparsers.add_parser(
+        "fetch_jars",
+        help="fetch dependency jars and the Android platform jar",
+    )
+    fetch_jars_parser.add_argument(
+        "-r",
+        dest="dependencies",
+        help="dependency file (default: deps.txt)",
+    )
+    fetch_jars_parser.add_argument(
+        "-R",
+        dest="repositories",
+        action="append",
+        help="extra Maven repository URL, tried before Central (repeatable)",
+    )
+    fetch_jars_parser.add_argument(
+        "directory",
+        nargs="?",
+        default=".",
+        help="project directory (default: current directory)",
+    )
+    fetch_jars_parser.set_defaults(handler=_fetch_jars)
+
+    fetch_platform_parser = subparsers.add_parser(
+        "fetch_platform",
+        help="fetch the Android platform stub jar for targetSdkVersion",
+    )
+    fetch_platform_parser.add_argument(
+        "directory",
+        nargs="?",
+        default=".",
+        help="project directory (default: current directory)",
+    )
+    fetch_platform_parser.set_defaults(handler=_fetch_platform)
+
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = create_parser()
+    args = parser.parse_args(argv)
+    handler = getattr(args, "handler", None)
+    if handler is None:
+        parser.print_help()
+        return 0
+    return handler(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

Py2APK/cli_build.py

@@ -0,0 +1,273 @@
+# pyright: reportMissingModuleSource=false
+
+"""Build an initialized Py2APK project into a signed APK."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+from collections.abc import Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import cast
+
+import yaml
+
+from Py2APK.cli_compile import compile_project
+from Py2APK.cli_fetch_jars import fetch_jars
+from Py2APK.cli_setup import KEY_ALIAS, asset_directories, ensure_keystore
+from Py2APK.jar_index import dex_jars, library_jars
+
+
+ROOT_BUILD_FILES = ("AndroidManifest.xml", "apktool.yml")
+
+
+@dataclass(frozen=True)
+class _Toolchain:
+    apktool: Path
+    jasmin: Path
+    r8: Path
+    signer: Path
+
+
+def _jar_directories(project_root: Path) -> list[Path]:
+    directories: list[Path] = []
+    configured = os.environ.get("PY2APK_JARS")
+    if configured:
+        directories.append(Path(configured).expanduser())
+    directories.append(project_root / "jars")
+    directories.extend(assets / "jars" for assets in asset_directories())
+
+    unique: list[Path] = []
+    for directory in directories:
+        if directory not in unique:
+            unique.append(directory)
+    return unique
+
+
+def _toolchain(project_root: Path) -> tuple[_Toolchain | None, Path]:
+    directories = _jar_directories(project_root)
+    fallback = next((path for path in directories if path.is_dir()), directories[0])
+    for directory in directories:
+        if not directory.is_dir():
+            continue
+        found = _find_toolchain(directory)
+        if found is not None:
+            return found, directory
+    return None, fallback
+
+
+def _single_jar(directory: Path, pattern: str) -> Path | None:
+    matches = sorted(directory.glob(pattern))
+    if len(matches) == 1:
+        return matches[0]
+    return None
+
+
+def _find_toolchain(jars_dir: Path) -> _Toolchain | None:
+    if not jars_dir.is_dir():
+        return None
+    apktool = _single_jar(jars_dir, "apktool_*.jar")
+    jasmin = _single_jar(jars_dir, "jasmin-*-jar-with-dependencies.jar")
+    r8 = _single_jar(jars_dir, "r8-*.jar")
+    signer = _single_jar(jars_dir, "uber-apk-signer-*.jar")
+    if apktool and jasmin and r8 and signer:
+        return _Toolchain(apktool.resolve(), jasmin.resolve(), r8.resolve(), signer.resolve())
+    return None
+
+
+def _sync_build_inputs(project_root: Path) -> None:
+    target_root = project_root / "target"
+    for filename in ROOT_BUILD_FILES:
+        source = project_root / filename
+        target = target_root / filename
+        if source.is_file() and (
+            not target.is_file() or source.stat().st_mtime_ns > target.stat().st_mtime_ns
+        ):
+            target.parent.mkdir(parents=True, exist_ok=True)
+            _ = shutil.copy2(source, target)
+
+
+def _apk_output(target_root: Path) -> Path:
+    config_path = target_root / "apktool.yml"
+    try:
+        config = cast(object, yaml.safe_load(config_path.read_text()))
+    except (OSError, yaml.YAMLError) as error:
+        raise ValueError(f"could not read {config_path}: {error}") from error
+
+    if not isinstance(config, dict):
+        raise ValueError(f"invalid apktool configuration: {config_path}")
+    values = cast(dict[str, object], config)
+    filename = values.get("apkFileName")
+    if not isinstance(filename, str) or not filename:
+        raise ValueError(f"apkFileName is missing from {config_path}")
+    return target_root / "dist" / filename
+
+
+def _run_command(
+    command: Sequence[str],
+    project_root: Path,
+    visible: Sequence[str] | None = None,
+) -> int:
+    shown = command if visible is None else visible
+    print(f"+ {' '.join(shown)}")
+    try:
+        completed = subprocess.run(command, cwd=project_root, check=False)
+    except OSError as error:
+        print(f"error: could not run {command[0]!r}: {error}", file=sys.stderr)
+        return 1
+    if completed.returncode != 0:
+        message = (
+            f"error: command failed with exit code {completed.returncode}: "
+            f"{' '.join(command)}"
+        )
+        print(message, file=sys.stderr)
+    return completed.returncode
+
+
+def build_project(project_root: Path | None = None) -> int:
+    root = (Path.cwd() if project_root is None else project_root).resolve()
+
+    if not (root / "jars.db").is_file() and fetch_jars(root) != 0:
+        return 1
+
+    if compile_project(root) != 0:
+        return 1
+
+    _sync_build_inputs(root)
+    target_root = root / "target"
+    try:
+        apk = _apk_output(target_root)
+    except ValueError as error:
+        print(f"error: {error}", file=sys.stderr)
+        return 1
+
+    toolchain, jars_dir = _toolchain(root)
+    if toolchain is None:
+        print(f"error: required JARs are missing from {jars_dir}", file=sys.stderr)
+        print(f"run: py2apk setup -d {jars_dir}", file=sys.stderr)
+        return 1
+
+    jasmin_files = sorted((target_root / "j").rglob("*.j"))
+    if not jasmin_files:
+        print("error: compile produced no Jasmin files", file=sys.stderr)
+        return 1
+
+    classes_root = target_root / "classes"
+    dex_root = target_root / "dex"
+    shutil.rmtree(classes_root, ignore_errors=True)
+    shutil.rmtree(dex_root, ignore_errors=True)
+    classes_root.mkdir(parents=True)
+    dex_root.mkdir(parents=True)
+
+    jasmin_command = [
+        "java",
+        "-jar",
+        str(toolchain.jasmin),
+        "-d",
+        str(classes_root),
+        *(str(path) for path in jasmin_files),
+    ]
+    if _run_command(jasmin_command, root) != 0:
+        return 1
+
+    class_files = sorted(classes_root.rglob("*.class"))
+    if not class_files:
+        print("error: Jasmin produced no class files", file=sys.stderr)
+        return 1
+
+    d8_command = [
+        "java",
+        "-cp",
+        str(toolchain.r8),
+        "com.android.tools.r8.D8",
+        "--output",
+        str(dex_root),
+    ]
+    for library in library_jars(root / "jars.db"):
+        d8_command.extend(("--lib", str(library)))
+    d8_command.extend(str(path) for path in class_files)
+    d8_command.extend(str(path) for path in dex_jars(root / "jars.db"))
+    if _run_command(d8_command, root) != 0:
+        return 1
+
+    dex_file = dex_root / "classes.dex"
+    if not dex_file.is_file():
+        print("error: D8 produced no classes.dex", file=sys.stderr)
+        return 1
+    _ = shutil.copy2(dex_file, target_root / "classes.dex")
+
+    apktool_command = [
+        "java",
+        "-jar",
+        str(toolchain.apktool),
+        "b",
+        str(target_root),
+    ]
+    if _run_command(apktool_command, root) != 0:
+        return 1
+
+    if not apk.is_file():
+        print(f"error: apktool produced no APK at {apk}", file=sys.stderr)
+        return 1
+    try:
+        signed = _sign_apk(toolchain, apk, root)
+    except (OSError, RuntimeError) as error:
+        print(f"error: {error}", file=sys.stderr)
+        return 1
+    if signed is None:
+        return 1
+    print(f"built: {apk.relative_to(root)}")
+    print(f"signed: {signed.relative_to(root)}")
+    return 0
+
+
+def _sign_apk(toolchain: _Toolchain, apk: Path, project_root: Path) -> Path | None:
+    """Sign ``apk`` with the setup keystore and return ``name.signed.apk``."""
+    keystore = ensure_keystore()
+    password = keystore.with_name("default.keystore.pass").read_text(encoding="utf-8").strip()
+    if not password:
+        raise RuntimeError(f"keystore password file is empty: {keystore.with_name('default.keystore.pass')}")
+    out_dir = apk.parent.parent / "sign"
+    shutil.rmtree(out_dir, ignore_errors=True)
+    out_dir.mkdir(parents=True)
+    command = [
+        "java",
+        "-jar",
+        str(toolchain.signer),
+        "-a",
+        str(apk),
+        "--ks",
+        str(keystore),
+        "--ksAlias",
+        KEY_ALIAS,
+        "--ksPass",
+        password,
+        "--ksKeyPass",
+        password,
+        "--out",
+        str(out_dir),
+        "--allowResign",
+    ]
+    visible: list[str] = []
+    skip_next = False
+    for part in command:
+        if skip_next:
+            visible.append("***")
+            skip_next = False
+            continue
+        visible.append(part)
+        if part in ("--ksPass", "--ksKeyPass"):
+            skip_next = True
+    if _run_command(command, project_root, visible) != 0:
+        return None
+    produced = sorted(out_dir.glob("*.apk"))
+    if len(produced) != 1:
+        print(f"error: uber-apk-signer produced no single APK in {out_dir}", file=sys.stderr)
+        return None
+    signed = apk.with_name(f"{apk.stem}.signed.apk")
+    signed.unlink(missing_ok=True)
+    _ = shutil.move(produced[0], signed)
+    return signed