kivyforge 3.0.0.dev0__py3-none-any.whl

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

@@ -0,0 +1,132 @@
+package org.kivy.android;
+
+import android.content.Context;
+import android.system.Os;
+import android.util.Log;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.RandomAccessFile;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+
+/**
+ * The asset-bundle unpack + environment contract, shared by every process that
+ * starts a kivyforge interpreter (docs/design/platforms/android/05).
+ *
+ * PythonActivity and PythonService both need exactly this sequence, and a
+ * service runs in its own process (android:process=":service_*"), so it unpacks
+ * and configures independently rather than inheriting the activity's state.
+ * Keeping one implementation is deliberate: the environment contract is the
+ * most delicate part of the load model, and two copies would drift.
+ */
+public class PythonBundle {
+    private static final String TAG = "kivyforge";
+
+    /** Unpack assets/_python_bundle to filesDir, skipped when VERSION matches.
+     *
+     * Serialized across processes: a service starts in its own process and may
+     * race the activity here, and two unpacks into the same directory would
+     * leave a half-written bundle behind whichever finished first.
+     */
+    public static File unpack(Context ctx) throws Exception {
+        File lock = new File(ctx.getFilesDir(), "_python_bundle.lock");
+        try (RandomAccessFile raf = new RandomAccessFile(lock, "rw");
+             FileChannel channel = raf.getChannel();
+             FileLock held = channel.lock()) {
+            return unpackLocked(ctx);
+        }
+    }
+
+    private static File unpackLocked(Context ctx) throws Exception {
+        File target = new File(ctx.getFilesDir(), "_python_bundle");
+        File stamp = new File(target, "VERSION");
+        String wanted = readAsset(ctx, "_python_bundle/VERSION");
+        if (stamp.exists()) {
+            String have = new String(
+                Files.readAllBytes(stamp.toPath()), StandardCharsets.UTF_8);
+            if (have.equals(wanted)) {
+                Log.i(TAG, "bundle up to date (VERSION " + have + "), skipping unpack");
+                Os.setenv("KF_UNPACK_SKIPPED", "1", true);
+                return target;
+            }
+        }
+        Log.i(TAG, "unpacking bundle...");
+        long t0 = System.currentTimeMillis();
+        deleteRecursive(target);
+        extractAssetDir(ctx, "_python_bundle", ctx.getFilesDir());
+        Log.i(TAG, "bundle unpacked in " + (System.currentTimeMillis() - t0) + " ms");
+        Os.setenv("KF_UNPACK_SKIPPED", "0", true);
+        return target;
+    }
+
+    /**
+     * Set the environment contract the native launcher and Kivy/pyjnius read.
+     * Must run before any native code in the process.
+     */
+    public static void setEnvironment(Context ctx, File bundleDir, String entryPoint)
+            throws Exception {
+        File appDir = new File(bundleDir, "app");
+        Os.setenv("KF_BUNDLE", bundleDir.getAbsolutePath(), true);
+        Os.setenv("KF_NATIVE_DIR", ctx.getApplicationInfo().nativeLibraryDir, true);
+        Os.setenv("KF_ENTRY_POINT", entryPoint, true);
+        // pyjnius/Kivy environment contract:
+        Os.setenv("ANDROID_ARGUMENT", appDir.getAbsolutePath(), true);
+        Os.setenv("ANDROID_APP_PATH", appDir.getAbsolutePath(), true);
+        Os.setenv("ANDROID_PRIVATE", ctx.getFilesDir().getAbsolutePath(), true);
+        Os.setenv("ANDROID_UNPACK", bundleDir.getAbsolutePath(), true);
+        Os.setenv("TMPDIR", ctx.getCacheDir().getAbsolutePath(), false);
+    }
+
+    private static String readAsset(Context ctx, String path) throws Exception {
+        try (InputStream in = ctx.getAssets().open(path)) {
+            return new String(readAll(in), StandardCharsets.UTF_8);
+        }
+    }
+
+    private static byte[] readAll(InputStream in) throws Exception {
+        java.io.ByteArrayOutputStream bos = new java.io.ByteArrayOutputStream();
+        byte[] buf = new byte[65536];
+        int n;
+        while ((n = in.read(buf)) > 0) bos.write(buf, 0, n);
+        return bos.toByteArray();
+    }
+
+    private static void extractAssetDir(Context ctx, String path, File targetDir)
+            throws Exception {
+        String[] names = ctx.getAssets().list(path);
+        if (names == null) throw new RuntimeException("cannot list asset " + path);
+        File subdir = new File(targetDir, path);
+        if (!subdir.exists() && !subdir.mkdirs())
+            throw new RuntimeException("mkdirs failed: " + subdir);
+        for (String name : names) {
+            String subPath = path + "/" + name;
+            InputStream in;
+            try {
+                in = ctx.getAssets().open(subPath);
+            } catch (FileNotFoundException e) {
+                extractAssetDir(ctx, subPath, targetDir);
+                continue;
+            }
+            try (InputStream input = in;
+                 OutputStream out = new FileOutputStream(new File(subdir, name))) {
+                byte[] buf = new byte[65536];
+                int n;
+                while ((n = input.read(buf)) > 0) out.write(buf, 0, n);
+            }
+        }
+    }
+
+    private static void deleteRecursive(File f) {
+        if (f.isDirectory()) {
+            File[] children = f.listFiles();
+            if (children != null) for (File c : children) deleteRecursive(c);
+        }
+        f.delete();
+    }
+}

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

@@ -0,0 +1,189 @@
+package org.kivy.android;
+
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.Service;
+import android.content.Intent;
+import android.os.Build;
+import android.os.IBinder;
+import android.system.Os;
+import android.util.Log;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * Base class for the services generated from [[tool.kivy.android.services]]
+ * (docs/design/platforms/android/05 §services).
+ *
+ * Each declared service becomes a subclass that names its Python entry point
+ * and, when it is a foreground service, its notification. The manifest gives
+ * every service its own android:process, so this runs in a fresh process: it
+ * unpacks the bundle, sets the same environment contract the activity does, and
+ * starts one interpreter — on a background thread, because the interpreter does
+ * not return until the entry point does and blocking a service's main thread is
+ * an ANR.
+ *
+ * There is no SDL here. The service's Python does background work, so only
+ * libpython and libmain are loaded; nothing creates a window or a JNIEnv-owning
+ * SDL thread.
+ */
+public class PythonService extends Service implements Runnable {
+    private static final String TAG = "kivyforge";
+    // The libpython soname stem, substituted at render time.
+    private static final String PYTHON_LIB = "python3.14";
+
+    private static final int NOTIFICATION_ID = 1;
+
+    private boolean mStarted = false;
+    private Thread mThread = null;
+
+    // --- overridden by the generated subclass ------------------------------ #
+
+    /** The service's [[services]] name, used for logging + the ready marker. */
+    protected String getServiceName() {
+        return getClass().getSimpleName();
+    }
+
+    /** The Python module this service imports (its own entry_point). */
+    protected String getEntryPoint() {
+        return "main";
+    }
+
+    protected boolean isForeground() {
+        return false;
+    }
+
+    protected String getChannelId() {
+        return "kivyforge_service";
+    }
+
+    protected String getChannelName() {
+        return "Background service";
+    }
+
+    protected String getNotificationTitle() {
+        return getServiceName();
+    }
+
+    protected String getNotificationText() {
+        return "";
+    }
+
+    /** A drawable resource name for the notification icon, or null for none. */
+    protected String getNotificationIcon() {
+        return null;
+    }
+
+    // --- service lifecycle ------------------------------------------------- #
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        if (isForeground()) {
+            // Mandatory on Android 14+: a foreground service that does not
+            // call startForeground() promptly is killed by the OS.
+            startForegroundNotification();
+        }
+        if (!mStarted) {
+            mStarted = true;
+            String argument = intent == null
+                ? null : intent.getStringExtra("kivyforge_service_argument");
+            try {
+                prepare(argument);
+            } catch (Exception e) {
+                Log.e(TAG, "service " + getServiceName() + " failed to prepare", e);
+                stopSelf();
+                return START_NOT_STICKY;
+            }
+            mThread = new Thread(this, "python-service-" + getServiceName());
+            mThread.start();
+        }
+        // Deliberately not sticky: a crash-looping service that the OS keeps
+        // restarting is worse than one that stays down and is visible as down.
+        return START_NOT_STICKY;
+    }
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+
+    /** Unpack + environment, then the ready-marker path the smoke test polls. */
+    private void prepare(String argument) throws Exception {
+        File bundleDir = PythonBundle.unpack(this);
+        PythonBundle.setEnvironment(this, bundleDir, getEntryPoint());
+        // p4a convention, kept so existing service code keeps working.
+        Os.setenv("PYTHON_SERVICE_ARGUMENT", argument == null ? "" : argument, true);
+        File marker = markerFile(this, getServiceName());
+        marker.delete();
+        Os.setenv("KF_SERVICE_MARKER", marker.getAbsolutePath(), true);
+    }
+
+    /** Where the interpreter records that it came up (android/06 --smoke). */
+    public static File markerFile(Service service, String name) {
+        return new File(service.getFilesDir(), "kivyforge_service_" + name + ".txt");
+    }
+
+    @Override
+    public void run() {
+        Log.i(TAG, "service " + getServiceName() + ": starting " + getEntryPoint());
+        try {
+            System.loadLibrary(PYTHON_LIB);
+            System.loadLibrary("main");
+            int rc = nativeStart();
+            Log.i(TAG, "service " + getServiceName() + " returned " + rc);
+        } catch (UnsatisfiedLinkError e) {
+            Log.e(TAG, "service " + getServiceName() + ": native start failed", e);
+            recordFailure(e.toString());
+        } finally {
+            stopSelf();
+        }
+    }
+
+    private void recordFailure(String detail) {
+        File marker = markerFile(this, getServiceName());
+        try (FileOutputStream out = new FileOutputStream(marker, true)) {
+            out.write(("SERVICE_START_FAILED " + detail + "\n")
+                .getBytes(StandardCharsets.UTF_8));
+        } catch (Exception ignored) {
+            // The marker is diagnostics; losing it must not mask the real error.
+        }
+    }
+
+    private void startForegroundNotification() {
+        NotificationManager manager = getSystemService(NotificationManager.class);
+        Notification.Builder builder;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            NotificationChannel channel = new NotificationChannel(
+                getChannelId(), getChannelName(), NotificationManager.IMPORTANCE_LOW);
+            manager.createNotificationChannel(channel);
+            builder = new Notification.Builder(this, getChannelId());
+        } else {
+            builder = new Notification.Builder(this);
+        }
+        builder.setContentTitle(getNotificationTitle());
+        builder.setContentText(getNotificationText());
+        builder.setSmallIcon(notificationIconResource());
+        startForeground(NOTIFICATION_ID, builder.build());
+    }
+
+    private int notificationIconResource() {
+        String icon = getNotificationIcon();
+        if (icon != null) {
+            int id = getResources().getIdentifier(icon, "drawable", getPackageName());
+            if (id == 0) {
+                id = getResources().getIdentifier(icon, "mipmap", getPackageName());
+            }
+            if (id != 0) {
+                return id;
+            }
+            Log.w(TAG, "notification icon " + icon + " not found; using the launcher");
+        }
+        return getApplicationInfo().icon;
+    }
+
+    /** Implemented in libmain (cpp/main.c): brings up CPython in this process. */
+    private native int nativeStart();
+}

kivyforge/platforms/android/bootstrap/templates/java/org/renpy/android/Hardware.java

@@ -0,0 +1,276 @@
+/*
+ * org.renpy.android.Hardware — Kivy-compatibility shim.
+ *
+ * Kivy's own kivy/metrics.py calls autoclass('org.renpy.android.Hardware')
+ * for DPI/fontscale, so the kivyforge bootstrap must supply this class for
+ * unmodified Kivy-Android apps to start (android/05 §namespace preservation).
+ * Vendored verbatim from python-for-android (MIT License,
+ * https://github.com/kivy/python-for-android) — the surface Kivy was written
+ * against. Kivy's startup path (getDPI/get_fontscale) uses only the
+ * PythonActivity.mActivity reference; `context` is initialized lazily below so
+ * the sensor/network helpers work without a cross-package assignment.
+ *
+ * vibrate/getDPI/checkNetwork call APIs Android has since deprecated
+ * (Vibrator#vibrate(int), Display#getMetrics, ConnectivityManager
+ * #getActiveNetworkInfo) but not removed; their replacements need API
+ * 26/30/29 respectively, above this project's min_sdk floor of 24, so the
+ * deprecated call is kept rather than forking this surface into two paths.
+ * @SuppressWarnings("deprecation") on each is a deliberate, understood
+ * choice, not an oversight — see android/05 for the min_sdk floor.
+ */
+package org.renpy.android;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import android.net.wifi.ScanResult;
+import android.net.wifi.WifiManager;
+import android.os.Vibrator;
+import android.util.DisplayMetrics;
+import android.view.View;
+import android.view.inputmethod.InputMethodManager;
+import java.util.List;
+import org.kivy.android.PythonActivity;
+
+/**
+ * Methods that are expected to be called via JNI, to access the device's non-screen hardware. (For
+ * example, the vibration and accelerometer.)
+ */
+public class Hardware {
+
+    // The context.
+    static Context context;
+    static View view;
+    public static final float defaultRv[] = {0f, 0f, 0f};
+
+    /** Vibrate for s seconds. */
+    @SuppressWarnings("deprecation")
+    public static void vibrate(double s) {
+        Vibrator v = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
+        if (v != null) {
+            v.vibrate((int) (1000 * s));
+        }
+    }
+
+    /** Get an Overview of all Hardware Sensors of an Android Device */
+    public static String getHardwareSensors() {
+        SensorManager sm = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
+        List<Sensor> allSensors = sm.getSensorList(Sensor.TYPE_ALL);
+
+        if (allSensors != null) {
+            String resultString = "";
+            for (Sensor s : allSensors) {
+                resultString += String.format("Name=" + s.getName());
+                resultString += String.format(",Vendor=" + s.getVendor());
+                resultString += String.format(",Version=" + s.getVersion());
+                resultString += String.format(",MaximumRange=" + s.getMaximumRange());
+                // XXX MinDelay is not in the 2.2
+                // resultString += String.format(",MinDelay=" + s.getMinDelay());
+                resultString += String.format(",Power=" + s.getPower());
+                resultString += String.format(",Type=" + s.getType() + "\n");
+            }
+            return resultString;
+        }
+        return "";
+    }
+
+    /**
+     * Get Access to 3 Axis Hardware Sensors Accelerometer, Orientation and Magnetic Field Sensors
+     */
+    public static class generic3AxisSensor implements SensorEventListener {
+        private final SensorManager sSensorManager;
+        private final Sensor sSensor;
+        private final int sSensorType;
+        SensorEvent sSensorEvent;
+
+        public generic3AxisSensor(int sensorType) {
+            sSensorType = sensorType;
+            sSensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
+            sSensor = sSensorManager.getDefaultSensor(sSensorType);
+        }
+
+        public void onAccuracyChanged(Sensor sensor, int accuracy) {}
+
+        public void onSensorChanged(SensorEvent event) {
+            sSensorEvent = event;
+        }
+
+        /** Enable or disable the Sensor by registering/unregistering */
+        public void changeStatus(boolean enable) {
+            if (enable) {
+                sSensorManager.registerListener(this, sSensor, SensorManager.SENSOR_DELAY_NORMAL);
+            } else {
+                sSensorManager.unregisterListener(this, sSensor);
+            }
+        }
+
+        /** Read the Sensor */
+        public float[] readSensor() {
+            if (sSensorEvent != null) {
+                return sSensorEvent.values;
+            } else {
+                return defaultRv;
+            }
+        }
+    }
+
+    public static generic3AxisSensor accelerometerSensor = null;
+    public static generic3AxisSensor orientationSensor = null;
+    public static generic3AxisSensor magneticFieldSensor = null;
+
+    /** functions for backward compatibility reasons */
+    public static void accelerometerEnable(boolean enable) {
+        if (accelerometerSensor == null)
+            accelerometerSensor = new generic3AxisSensor(Sensor.TYPE_ACCELEROMETER);
+        accelerometerSensor.changeStatus(enable);
+    }
+
+    public static float[] accelerometerReading() {
+        if (accelerometerSensor == null) return defaultRv;
+        return (float[]) accelerometerSensor.readSensor();
+    }
+
+    public static void orientationSensorEnable(boolean enable) {
+        if (orientationSensor == null)
+            orientationSensor = new generic3AxisSensor(Sensor.TYPE_ORIENTATION);
+        orientationSensor.changeStatus(enable);
+    }
+
+    public static float[] orientationSensorReading() {
+        if (orientationSensor == null) return defaultRv;
+        return (float[]) orientationSensor.readSensor();
+    }
+
+    public static void magneticFieldSensorEnable(boolean enable) {
+        if (magneticFieldSensor == null)
+            magneticFieldSensor = new generic3AxisSensor(Sensor.TYPE_MAGNETIC_FIELD);
+        magneticFieldSensor.changeStatus(enable);
+    }
+
+    public static float[] magneticFieldSensorReading() {
+        if (magneticFieldSensor == null) return defaultRv;
+        return (float[]) magneticFieldSensor.readSensor();
+    }
+
+    public static DisplayMetrics metrics = new DisplayMetrics();
+
+    /** Get display DPI. */
+    @SuppressWarnings("deprecation")
+    public static int getDPI() {
+        // AND: Shouldn't have to get the metrics like this every time...
+        PythonActivity.mActivity.getWindowManager().getDefaultDisplay().getMetrics(metrics);
+        return metrics.densityDpi;
+    }
+
+    // /**
+    //  * Show the soft keyboard.
+    //  */
+    // public static void showKeyboard(int input_type) {
+    //     //Log.i("python", "hardware.Java show_keyword  " input_type);
+
+    //     InputMethodManager imm = (InputMethodManager)
+    // context.getSystemService(Context.INPUT_METHOD_SERVICE);
+
+    //     SDLSurfaceView vw = (SDLSurfaceView) view;
+
+    //     int inputType = input_type;
+
+    //     if (vw.inputType != inputType){
+    //         vw.inputType = inputType;
+    //         imm.restartInput(view);
+    //         }
+
+    //     imm.showSoftInput(view, InputMethodManager.SHOW_FORCED);
+    // }
+
+    /** Hide the soft keyboard. */
+    public static void hideKeyboard() {
+        InputMethodManager imm =
+                (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
+        imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
+    }
+
+    /** Scan WiFi networks */
+    static List<ScanResult> latestResult;
+
+    public static void enableWifiScanner() {
+        IntentFilter i = new IntentFilter();
+        i.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
+
+        context.registerReceiver(
+                new BroadcastReceiver() {
+
+                    @Override
+                    public void onReceive(Context c, Intent i) {
+                        // Code to execute when SCAN_RESULTS_AVAILABLE_ACTION event occurs
+                        WifiManager w = (WifiManager) c.getSystemService(Context.WIFI_SERVICE);
+                        latestResult = w.getScanResults(); // Returns a <list> of scanResults
+                    }
+                },
+                i);
+    }
+
+    public static String scanWifi() {
+
+        // Now you can call this and it should execute the broadcastReceiver's
+        // onReceive()
+        if (latestResult != null) {
+
+            String latestResultString = "";
+            for (ScanResult result : latestResult) {
+                latestResultString +=
+                        String.format("%s\t%s\t%d\n", result.SSID, result.BSSID, result.level);
+            }
+
+            return latestResultString;
+        }
+
+        return "";
+    }
+
+    /** network state */
+    public static boolean network_state = false;
+
+    /**
+     * Check network state directly
+     *
+     * <p>(only one connection can be active at a given moment, detects all network type)
+     */
+    @SuppressWarnings("deprecation")
+    public static boolean checkNetwork() {
+        boolean state = false;
+        final ConnectivityManager conMgr =
+                (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
+
+        final NetworkInfo activeNetwork = conMgr.getActiveNetworkInfo();
+        if (activeNetwork != null && activeNetwork.isConnected()) {
+            state = true;
+        } else {
+            state = false;
+        }
+
+        return state;
+    }
+
+    /** To receive network state changes */
+    public static void registerNetworkCheck() {
+        IntentFilter i = new IntentFilter();
+        i.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
+        context.registerReceiver(
+                new BroadcastReceiver() {
+
+                    @Override
+                    public void onReceive(Context c, Intent i) {
+                        network_state = checkNetwork();
+                    }
+                },
+                i);
+    }
+}

kivyforge/platforms/android/bootstrap/templates/sdl2/LICENSE-SDL.txt

@@ -0,0 +1,18 @@
+Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+  
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+  
+1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required. 
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+

kivyforge/platforms/android/bootstrap/templates/sdl2/SDL_REVISION.txt

@@ -0,0 +1,3 @@
+#define SDL_MAJOR_VERSION   2
+#define SDL_MINOR_VERSION   32
+#define SDL_PATCHLEVEL      10

kivyforge/platforms/android/bootstrap/templates/sdl2/org/libsdl/app/HIDDevice.java

@@ -0,0 +1,22 @@
+package org.libsdl.app;
+
+import android.hardware.usb.UsbDevice;
+
+interface HIDDevice
+{
+    public int getId();
+    public int getVendorId();
+    public int getProductId();
+    public String getSerialNumber();
+    public int getVersion();
+    public String getManufacturerName();
+    public String getProductName();
+    public UsbDevice getDevice();
+    public boolean open();
+    public int sendFeatureReport(byte[] report);
+    public int sendOutputReport(byte[] report);
+    public boolean getFeatureReport(byte[] report);
+    public void setFrozen(boolean frozen);
+    public void close();
+    public void shutdown();
+}