kivyforge 3.0.0.dev0__py3-none-any.whl

kivyforge/platforms/android/bootstrap/templates/androidtest/KivyforgeContractTest.java

@@ -0,0 +1,76 @@
+package org.kivyforge.test;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import android.content.Context;
+import android.content.Intent;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import java.io.File;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/**
+ * The kivyforge contract smoke test (android/06 --smoke).
+ *
+ * Launches PythonActivity, which runs the app in self-test mode (the
+ * KIVYFORGE_SELFTEST flag makes the bootstrap import a known stdlib + wheel
+ * extension through the sys.meta_path finder, fire an invoke0 proxy
+ * round-trip, and pull the Activity through Kivy's bootstrap contract), then
+ * asserts the on-device result markers. No app-specific test code — this
+ * validates the load-bearing runtime mechanisms (extension-module finder,
+ * invoke0 glue, and the Kivy 3 Activity contract) on a real device/emulator.
+ */
+@RunWith(AndroidJUnit4.class)
+public class KivyforgeContractTest {
+
+    private static final int TIMEOUT_MS = 90_000;
+    private static final String RESULT_FILE = "kivyforge_selftest.txt";
+
+    @Test
+    public void contractSelfTestPasses() throws Exception {
+        Context ctx = ApplicationProvider.getApplicationContext();
+        File result = new File(ctx.getFilesDir(), RESULT_FILE);
+        if (result.exists() && !result.delete()) {
+            fail("could not clear stale self-test result " + result);
+        }
+
+        Intent intent = new Intent(ctx, org.kivy.android.PythonActivity.class);
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        intent.putExtra("kivyforge_selftest", true);
+        ctx.startActivity(intent);
+
+        long deadline = System.currentTimeMillis() + TIMEOUT_MS;
+        String contents = "";
+        while (System.currentTimeMillis() < deadline) {
+            if (result.exists()) {
+                contents = new String(
+                    Files.readAllBytes(result.toPath()), StandardCharsets.UTF_8);
+                if (contents.contains("SELFTEST_DONE")) {
+                    break;
+                }
+            }
+            Thread.sleep(500);
+        }
+
+        assertTrue(
+            "self-test did not complete within " + TIMEOUT_MS + "ms; got: "
+                + contents,
+            contents.contains("SELFTEST_DONE"));
+        assertTrue(
+            "extension-module finder check failed: " + contents,
+            contents.contains("EXT_OK"));
+        assertTrue(
+            "pyjnius invoke0 proxy round-trip failed: " + contents,
+            contents.contains("PROXY_OK"));
+        assertTrue(
+            "Kivy's Android bootstrap contract failed: " + contents,
+            contents.contains("KIVY_CONTRACT_OK"));
+        assertTrue(
+            "self-test reported a failure: " + contents,
+            contents.contains("SELFTEST_ALL_OK"));
+    }
+}

kivyforge/platforms/android/bootstrap/templates/bootstrap_py/_kivy_bootstrap.py

@@ -0,0 +1,50 @@
+"""kivyforge's implementation of Kivy's Android bootstrap contract.
+
+Kivy 3 holds no Android bootstrap class name of its own: it imports this
+module — the name is Kivy's, not kivyforge's — and asks it for the current
+``android.app.Activity``.  That indirection is the whole point of the contract:
+Kivy runs on a kivyforge-built app and a python-for-android-built one without
+knowing, or caring, which produced it.  kivyforge's obligation is just this
+file; the activity class name below is kivyforge's business alone.
+
+Kivy pulls on first use rather than kivyforge registering at startup, so nothing
+here imports Kivy.  That is deliberate: importing Kivy from the bootstrap would
+fix Kivy's ``KIVY_*`` environment and configuration before the app's ``main.py``
+had a chance to set it.
+
+The Activity is read fresh on every call and never cached.  Android recreates it
+on rotation, on configuration change and after process death, so a stored
+instance both goes stale and pins a JNI reference to a dead Activity.
+
+Only ``get_activity()`` is implemented; the contract's optional members are
+deliberately absent.  ``get_context()`` would only repeat what Kivy already
+derives from the Activity.  ``remove_presplash()`` has nothing to do: kivyforge's
+splash is the platform's own — the system splash window on API 31+, and the
+theme's ``windowBackground`` below it — so it is dismissed by the framework when
+the first frame draws rather than being a View anyone can tear down, unlike
+python-for-android, which overlays a View and must remove it.  Kivy treats an
+absent hook as the no-op it is, so there is nothing to stub out.
+"""
+
+from jnius import autoclass
+
+# kivyforge's own activity, fixed at build time (generate/manifest.py names the
+# same class as the launcher activity).  Kivy never sees this string.
+_ACTIVITY_CLASS = "org.kivy.android.PythonActivity"
+
+_activity_class = None
+
+
+def get_activity():
+    """Return the current ``android.app.Activity``, or ``None`` if there is none.
+
+    ``None`` is a legitimate answer, not a failure: code may run in a process
+    with no Activity, and Kivy treats it as such.
+    """
+    global _activity_class
+    if _activity_class is None:
+        # Resolved on first call rather than at import, so that a reflection
+        # failure surfaces from the call that needs the Activity instead of from
+        # Kivy's discovery import, where it would look like a missing module.
+        _activity_class = autoclass(_ACTIVITY_CLASS)
+    return _activity_class.mActivity

kivyforge/platforms/android/bootstrap/templates/bootstrap_py/_kivyforge_bootstrap.py

@@ -0,0 +1,54 @@
+"""Kivyforge extension-module finder (Phase-0 prototype).
+
+Android exposes native libraries only from the flat nativeLibraryDir; Python
+extension modules are imported by dotted name from nested paths. The build
+flattens every extension .so into jniLibs/<abi>/ as ``libpy.<dotted>.so`` and
+records the mapping in ``ext_manifest.json``; this finder resolves imports
+through that manifest with a stock ExtensionFileLoader.
+
+See docs/design/platforms/android/05-bootstrap-android.md, "Extension-module
+finder".
+"""
+
+import json
+import os
+import sys
+from importlib.machinery import ExtensionFileLoader, ModuleSpec
+
+
+class KivyforgeExtensionFinder:
+    def __init__(self, mapping, native_dir):
+        self._mapping = mapping
+        self._native_dir = native_dir
+
+    def find_spec(self, fullname, path=None, target=None):
+        filename = self._mapping.get(fullname)
+        if filename is None:
+            return None
+        location = os.path.join(self._native_dir, filename)
+        if not os.path.exists(location):
+            raise ImportError(
+                f"kivyforge: manifest maps {fullname!r} to {filename!r}, "
+                f"but it is not present in {self._native_dir!r} — "
+                "the APK native-library extraction did not deliver it"
+            )
+        loader = ExtensionFileLoader(fullname, location)
+        spec = ModuleSpec(fullname, loader, origin=location)
+        # Submodule extensions (e.g. jnius.jnius) need is_package=False, which
+        # ModuleSpec already defaults to for ExtensionFileLoader.
+        return spec
+
+    def __repr__(self):
+        return (
+            f"<KivyforgeExtensionFinder {len(self._mapping)} modules "
+            f"at {self._native_dir!r}>"
+        )
+
+
+def install(manifest_path, native_dir):
+    with open(manifest_path, encoding="utf-8") as f:
+        mapping = json.load(f)
+    finder = KivyforgeExtensionFinder(mapping, native_dir)
+    sys.meta_path.insert(0, finder)
+    print(f"kivyforge bootstrap: finder installed ({len(mapping)} extensions)")
+    return finder

kivyforge/platforms/android/bootstrap/templates/bootstrap_py/_kivyforge_selftest.py

@@ -0,0 +1,97 @@
+"""kivyforge contract self-test (android/05 §contract smoke-test hook).
+
+Inert in a normal launch: the native launcher imports and runs this only when
+KIVYFORGE_SELFTEST is set (the instrumented KivyforgeContractTest sets it via
+an intent extra the Activity forwards to the environment). It exercises the two
+novel, load-bearing runtime mechanisms on-device — the flattened-extension
+sys.meta_path finder and the pyjnius invoke0 glue — and writes a result file
+the instrumentation polls.
+
+Adds no attack surface or startup cost to a shipped app: it never runs unless
+the test flag is present.
+"""
+
+import os
+import traceback
+
+
+def _result_path() -> str:
+    private = os.environ.get("ANDROID_PRIVATE", ".")
+    return os.path.join(private, "kivyforge_selftest.txt")
+
+
+def run() -> bool:
+    lines: list[str] = []
+    ok = True
+
+    # 1. A stdlib lib-dynload extension AND a wheel extension, both resolved
+    #    through the kivyforge finder (flattened .so + manifest).
+    try:
+        import _ssl  # noqa: F401  (stdlib, DT_NEEDEDs libssl_python.so)
+
+        import jnius  # noqa: F401  (wheel extension: jnius.jnius)
+
+        lines.append("EXT_OK")
+    except Exception:
+        ok = False
+        lines.append("EXT_FAIL")
+        lines.append(traceback.format_exc())
+
+    # 2. pyjnius invoke0 round-trip: a Python-implemented Java interface driven
+    #    from Java (the NativeInvocationHandler matched pair).
+    try:
+        from jnius import PythonJavaClass, autoclass, java_method
+
+        class _Cmp(PythonJavaClass):
+            __javainterfaces__ = ["java/util/Comparator"]
+            __javacontext__ = "app"
+
+            @java_method("(Ljava/lang/Object;Ljava/lang/Object;)I")
+            def compare(self, a, b):
+                sa, sb = str(a), str(b)
+                return -1 if sa < sb else (1 if sa > sb else 0)
+
+        ArrayList = autoclass("java.util.ArrayList")
+        Collections = autoclass("java.util.Collections")
+        lst = ArrayList()
+        for item in ("cherry", "apple", "banana"):
+            lst.add(item)
+        Collections.sort(lst, _Cmp())
+        ordered = [lst.get(i) for i in range(lst.size())]
+        assert ordered == ["apple", "banana", "cherry"], ordered
+        lines.append("PROXY_OK")
+    except Exception:
+        ok = False
+        lines.append("PROXY_FAIL")
+        lines.append(traceback.format_exc())
+
+    # 3. Kivy 3's Android bootstrap contract: Kivy names no activity class of
+    #    its own, it imports _kivy_bootstrap and pulls the Activity from there.
+    #    Checked on-device because this is kivyforge's side of an interface
+    #    another project relies on, and the failure it guards against — a
+    #    bundle that starts fine and dies when Kivy first needs the Activity —
+    #    is invisible to a unit test of the staging code.
+    try:
+        import _kivy_bootstrap
+
+        activity = _kivy_bootstrap.get_activity()
+        assert activity is not None, "no Activity while the Activity is running"
+        # Prove it is the live Activity rather than some retained husk.
+        assert activity.getPackageName(), "Activity did not answer as a Context"
+        lines.append("KIVY_CONTRACT_OK")
+    except Exception:
+        ok = False
+        lines.append("KIVY_CONTRACT_FAIL")
+        lines.append(traceback.format_exc())
+
+    if ok:
+        lines.append("SELFTEST_ALL_OK")
+    lines.append("SELFTEST_DONE")
+
+    try:
+        with open(_result_path(), "w", encoding="utf-8") as f:
+            f.write("\n".join(lines) + "\n")
+    except Exception:
+        traceback.print_exc()
+    print("kivyforge selftest:", " ".join(lines[:1] + ["…"]), flush=True)
+    return ok

kivyforge/platforms/android/bootstrap/templates/cpp/CMakeLists.txt

@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 3.10)
+project(kivyforge_launcher)
+
+# The kivyforge native launcher: exports SDL_main, initializes CPython.
+# Headers + libpython come from the python.org Android runtime prefix.
+#
+# Multi-ABI: AGP invokes CMake once per ABI; PYTHON_PREFIX_DIR arrives with a
+# literal {{triplet}} placeholder that resolves to this ABI's target triplet
+# (aarch64-linux-android / x86_64-linux-android) — the same mechanism the
+# python.org testbed uses, so each ABI's launcher links its own libpython.
+string(
+    REPLACE {{triplet}} ${CMAKE_LIBRARY_ARCHITECTURE}
+    PYTHON_PREFIX_DIR ${PYTHON_PREFIX_DIR}
+)
+
+include_directories(${PYTHON_PREFIX_DIR}/include/python${PYTHON_VERSION})
+link_directories(${PYTHON_PREFIX_DIR}/lib)
+
+add_library(main SHARED main.c)
+target_link_libraries(main log python${PYTHON_VERSION})

kivyforge/platforms/android/bootstrap/templates/cpp/main.c

@@ -0,0 +1,150 @@
+/* Kivyforge native launcher (libmain.so), from the Phase-0 prototype.
+ *
+ * Two callers, one sequence:
+ *  - SDL calls SDL_main() on its own thread after SDLActivity has loaded the
+ *    SDL family + libpython + this library. By that point PythonActivity has
+ *    unpacked the bundle and set the environment contract.
+ *  - PythonService calls nativeStart() from its own background thread, in its
+ *    own process, after doing the same unpack + environment setup. No SDL is
+ *    loaded there; nothing below needs it.
+ *
+ * This implements the 05-bootstrap-android.md launch sequence steps 4-6:
+ * PyConfig with site_import deferred and explicit module search paths,
+ * finder installation from the bundle manifest, site + addsitedir, then
+ * the entry-point import. Everything is read from the environment, so these
+ * sources carry no project-specific values.
+ */
+#include <android/log.h>
+#include <jni.h>
+#include <Python.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define TAG "kivyforge"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__)
+
+static int fail_status(const char *where, PyStatus status) {
+    LOGE("%s failed: %s", where, status.err_msg ? status.err_msg : "(no message)");
+    return 1;
+}
+
+/* Initialize CPython from the unpacked bundle and import the entry point.
+ * Returns 0 on success. Shared by SDL_main and the service entry. */
+static int kf_start_python(void) {
+    const char *bundle = getenv("KF_BUNDLE");
+    const char *native_dir = getenv("KF_NATIVE_DIR");
+    if (!bundle || !native_dir) {
+        LOGE("KF_BUNDLE / KF_NATIVE_DIR not set");
+        return 1;
+    }
+    LOGI("launcher: bundle=%s native=%s", bundle, native_dir);
+
+    char stdlib_path[1024], bootstrap_path[1024], app_path[1024], sp_path[1024];
+    snprintf(stdlib_path, sizeof stdlib_path, "%s/stdlib", bundle);
+    snprintf(bootstrap_path, sizeof bootstrap_path, "%s/bootstrap", bundle);
+    snprintf(app_path, sizeof app_path, "%s/app", bundle);
+    snprintf(sp_path, sizeof sp_path, "%s/site-packages", bundle);
+
+    PyPreConfig pre;
+    PyPreConfig_InitPythonConfig(&pre);
+    pre.utf8_mode = 1;
+    PyStatus status = Py_PreInitialize(&pre);
+    if (PyStatus_Exception(status)) return fail_status("Py_PreInitialize", status);
+
+    PyConfig config;
+    PyConfig_InitPythonConfig(&config);
+    config.buffered_stdio = 0;
+    config.install_signal_handlers = 1;
+    config.site_import = 0;             /* deferred: finder first, then site */
+    /* No use_system_logger field on the 3.14 Android build: CPython redirects
+     * the Python-level sys.stdout/stderr to logcat itself (per the runtime
+     * testbed). Finding for the docs: this is automatic on Android. */
+    /* Explicit search paths: bypass getpath landmark discovery entirely.
+     * The kivyforge bundle is its own layout, not a prefix. */
+    config.module_search_paths_set = 1;
+    wchar_t *wpaths[3];
+    const char *paths[3] = { stdlib_path, bootstrap_path, app_path };
+    for (int i = 0; i < 3; i++) {
+        wpaths[i] = Py_DecodeLocale(paths[i], NULL);
+        status = PyWideStringList_Append(&config.module_search_paths, wpaths[i]);
+        if (PyStatus_Exception(status))
+            return fail_status("module_search_paths", status);
+    }
+    status = PyConfig_SetBytesString(&config, &config.home, bundle);
+    if (PyStatus_Exception(status)) return fail_status("home", status);
+    status = PyConfig_SetBytesString(&config, &config.prefix, bundle);
+    if (PyStatus_Exception(status)) return fail_status("prefix", status);
+    status = PyConfig_SetBytesString(&config, &config.exec_prefix, bundle);
+    if (PyStatus_Exception(status)) return fail_status("exec_prefix", status);
+    status = PyConfig_SetBytesString(&config, &config.program_name, "kivyforge-app");
+    if (PyStatus_Exception(status)) return fail_status("program_name", status);
+
+    status = Py_InitializeFromConfig(&config);
+    PyConfig_Clear(&config);
+    if (PyStatus_Exception(status))
+        return fail_status("Py_InitializeFromConfig", status);
+    LOGI("launcher: interpreter up");
+
+    /* Step 5: finder, then site, then pip-deps site dir, then the entry point
+     * named by KF_ENTRY_POINT. When KIVYFORGE_SELFTEST is set (the instrumented
+     * contract test's intent extra, forwarded to the env by PythonActivity),
+     * run the inert self-test hook instead of the app entry point.
+     *
+     * KF_SERVICE_MARKER, when set, names a file the interpreter stamps once it
+     * is up and stamps again if the entry-point import raises — the signal the
+     * generated service contract test polls (a service entry point normally
+     * never returns, so there is nothing else to wait for). */
+    const char *selftest = getenv("KIVYFORGE_SELFTEST");
+    char code[4096];
+    snprintf(code, sizeof code,
+        "import _kivyforge_bootstrap\n"
+        "_kivyforge_bootstrap.install(%s'%s/ext_manifest.json', %s'%s')\n"
+        "import site\n"
+        "site.main()\n"
+        "site.addsitedir(%s'%s')\n"
+        "import importlib, os, traceback\n"
+        "_marker = os.environ.get('KF_SERVICE_MARKER')\n"
+        "if _marker:\n"
+        "    with open(_marker, 'w') as _f:\n"
+        "        _f.write('SERVICE_READY\\n')\n"
+        "try:\n"
+        "    if %d:\n"
+        "        import _kivyforge_selftest\n"
+        "        _kivyforge_selftest.run()\n"
+        "    else:\n"
+        "        importlib.import_module(os.environ.get('KF_ENTRY_POINT') or 'main')\n"
+        "except Exception:\n"
+        "    traceback.print_exc()\n"
+        "    if _marker:\n"
+        "        with open(_marker, 'a') as _f:\n"
+        "            _f.write('SERVICE_ENTRY_FAILED\\n')\n"
+        "    raise SystemExit(1)\n",
+        "r", bootstrap_path, "r", native_dir, "r", sp_path,
+        (selftest && selftest[0] == '1') ? 1 : 0);
+    int rc = PyRun_SimpleString(code);
+    LOGI("launcher: entry-point import returned %d", rc);
+
+    /* Keep the process alive briefly so instrumentation/logcat settle, then
+     * finalize. A real app never reaches here while Kivy runs its loop. */
+    Py_Finalize();
+    return rc == 0 ? 0 : 1;
+}
+
+/* SDL's Java glue dlopens libmain.so and dlsyms "SDL_main" — the symbol must
+ * be exported regardless of compiler visibility defaults. */
+__attribute__((visibility("default")))
+int SDL_main(int argc, char *argv[]) {
+    return kf_start_python();
+}
+
+/* org.kivy.android.PythonService.nativeStart(): the same sequence for a
+ * generated service's process. Resolved by JNI name, so it must be exported. */
+__attribute__((visibility("default")))
+JNIEXPORT jint JNICALL
+Java_org_kivy_android_PythonService_nativeStart(JNIEnv *env, jobject thiz) {
+    (void)env;
+    (void)thiz;
+    return (jint)kf_start_python();
+}

kivyforge/platforms/android/bootstrap/templates/java/org/jnius/NativeInvocationHandler.java

@@ -0,0 +1,48 @@
+package org.jnius;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+
+// SPIKE item 1 / kivyforge bootstrap-template simulation.
+//
+// This file is delivered APP-SIDE (via `android.add_src` in buildozer.spec), NOT
+// from the pyjnius wheel. It mirrors how kivyforge will ship
+// NativeInvocationHandler.java as a generated bootstrap template alongside
+// MainActivity.java / PythonActivity.java, compiled + dex'd by the app's Gradle.
+//
+// MATCHED-PAIR COUPLING: the `native Object invoke0(...)` signature below is bound
+// at runtime (RegisterNatives) by the pyjnius wheel. This class and the wheel's
+// invoke0 native-method contract MUST be updated together -- nothing enforces this
+// now that the glue no longer ships in the wheel. Keep in sync with
+// jnius/jnius_proxy.pxi in the pyjnius source.
+public class NativeInvocationHandler implements InvocationHandler {
+    static boolean DEBUG = false;
+    private long ptr;
+
+    public NativeInvocationHandler(long ptr) {
+        this.ptr = ptr;
+    }
+
+    public Object invoke(Object proxy, Method method, Object[] args) {
+        if ( DEBUG ) {
+            String message = "+ java:invoke(<proxy>, " + method + ", " + args;
+            System.out.print(message);
+            System.out.println(")");
+            System.out.flush();
+        }
+
+        Object ret = invoke0(proxy, method, args);
+
+        if ( DEBUG ) {
+            System.out.print("+ java:invoke returned: ");
+            System.out.println(ret);
+        }
+
+        return ret;
+    }
+
+    public long getPythonObjectPointer() {
+        return ptr;
+    }
+
+    native Object invoke0(Object proxy, Method method, Object[] args);
+}

kivyforge/platforms/android/bootstrap/templates/java/org/kivy/android/PythonActivity.java

@@ -0,0 +1,75 @@
+package org.kivy.android;
+
+import android.os.Bundle;
+import android.system.Os;
+import android.util.Log;
+
+import org.libsdl.app.SDLActivity;
+
+import java.io.File;
+
+/**
+ * Kivyforge PythonActivity.
+ *
+ * Generation-agnostic: the SDL family named in getLibraries() below is
+ * substituted at render time (SDL2 for Kivy 2.x, SDL3 for Kivy 3.x), and the
+ * matching org/libsdl/app glue is vendored alongside it.
+ *
+ * Load model (docs/design/platforms/android/05-bootstrap-android.md):
+ *  - SDLActivity static init loads the SDL family -> libpython -> libmain
+ *    (getLibraries order below), so the SDL JNIEnv getter is resident before
+ *    any Python runs.
+ *  - The asset bundle (_python_bundle) is unpacked to app-private storage
+ *    before super.onCreate(), version-stamped so a second launch skips it.
+ *  - The environment contract is set before any native code runs.
+ *  - libmain's SDL_main initializes CPython (site_import deferred), installs
+ *    the extension-module finder from the bundle manifest, then imports the
+ *    entry-point module named by KF_ENTRY_POINT.
+ */
+public class PythonActivity extends SDLActivity {
+    private static final String TAG = "kivyforge";
+
+    // [tool.kivy].entry_point, substituted at render time. The launcher reads
+    // it from the environment, so the native sources stay project-independent.
+    private static final String ENTRY_POINT = "main";
+
+    // Kivy-compatibility: kivy.app / kivy.metrics reach the activity through
+    // autoclass('org.kivy.android.PythonActivity').mActivity, and
+    // org.renpy.android.Hardware.getDPI() reads it too. Preserving this static
+    // is what keeps unmodified Kivy-Android code working (android/05
+    // §namespace preservation).
+    public static PythonActivity mActivity = null;
+
+    @Override
+    protected String getMainFunction() {
+        return "SDL_main";
+    }
+
+    @Override
+    protected String[] getLibraries() {
+        return new String[] {
+            "SDL2", "SDL2_image", "SDL2_mixer", "SDL2_ttf",
+            "python3.14",
+            "main",
+        };
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        mActivity = this;
+        try {
+            // Contract smoke-test hook (android/05): the instrumented test
+            // passes this extra so the launcher runs the inert self-test.
+            if (getIntent() != null
+                    && getIntent().getBooleanExtra("kivyforge_selftest", false)) {
+                Os.setenv("KIVYFORGE_SELFTEST", "1", true);
+            }
+            File bundleDir = PythonBundle.unpack(this);
+            PythonBundle.setEnvironment(this, bundleDir, ENTRY_POINT);
+        } catch (Exception e) {
+            Log.e(TAG, "bundle unpack failed", e);
+            throw new RuntimeException(e);
+        }
+        super.onCreate(savedInstanceState);
+    }
+}