Support testing recipes on Android emulator and iOS simulator and fixes issues found

.ci/common.sh

@@ -3,3 +3,38 @@ function publish_to_pypi() {
         curl -F package=@$wheel https://$GEMFURY_TOKEN@push.fury.io/flet/
     done
 }
+
+# Resolve which python-build tarball source to use.
+# When PYTHON_BUILD_RUN_ID is set (workflow_dispatch input), fetch the
+# named tarball from that python-build Actions run's artifacts; otherwise
+# download from the canonical v<version> release URL.
+#
+# Args:
+#   $1 artifact_platform — "android" | "darwin" (matches the python-build artifact name)
+#   $2 tarball           — e.g. python-android-mobile-forge-3.12.tar.gz
+#   $3 extract_dir       — local dir to extract the tarball into
+#
+# Caller env:
+#   PYTHON_SHORT_VERSION — e.g. 3.12 (required)
+#   PYTHON_BUILD_RUN_ID  — empty for release URL; non-empty for `gh run download`
+#   GH_TOKEN             — needed only when PYTHON_BUILD_RUN_ID is set
+#   RUNNER_TEMP          — GitHub Actions runner temp dir (only used in override path)
+function fetch_python_build_tarball() {
+    local artifact_platform="$1"
+    local tarball="$2"
+    local extract_dir="$3"
+    if [[ -n "${PYTHON_BUILD_RUN_ID:-}" ]]; then
+        echo "Fetching $tarball from python-build run $PYTHON_BUILD_RUN_ID"
+        local stage="$RUNNER_TEMP/python-build-artifact"
+        rm -rf "$stage"
+        mkdir -p "$stage"
+        gh run download "$PYTHON_BUILD_RUN_ID" \
+            --repo flet-dev/python-build \
+            --name "python-${artifact_platform}-${PYTHON_SHORT_VERSION}" \
+            --dir "$stage"
+        tar -xzf "$stage/$tarball" -C "$extract_dir"
+    else
+        curl -#OL "https://github.com/flet-dev/python-build/releases/download/v${PYTHON_SHORT_VERSION}/$tarball"
+        tar -xzf "$tarball" -C "$extract_dir"
+    fi
+}

.ci/install_ndk.sh

@@ -1,51 +1,76 @@
-if [[ -z "${NDK_HOME-}" ]]; then
-    NDK_HOME=$HOME/ndk/$NDK_VERSION
-    echo "NDK_HOME environment variable is not set."
-    if [ ! -d $NDK_HOME ]; then
-        echo "Installing NDK $NDK_VERSION to $NDK_HOME"
-        mkdir -p downloads
-
-        if [ $(uname) = "Darwin" ]; then
-            seven_zip=downloads/7zip/7zz
-            if ! test -f $seven_zip; then
-                echo "Installing 7-zip"
-                mkdir -p $(dirname $seven_zip)
-                cd $(dirname $seven_zip)
-                curl -#OL https://www.7-zip.org/a/7z2301-mac.tar.xz
-                tar -xf 7z2301-mac.tar.xz
-                cd -
-            fi
-
-            ndk_dmg=android-ndk-$NDK_VERSION-darwin.dmg
-            if ! test -f downloads/$ndk_dmg; then
-                echo ">>> Downloading $ndk_dmg"
-                curl -#L -o downloads/$ndk_dmg https://dl.google.com/android/repository/$ndk_dmg
-            fi
-
-            cd downloads
-            $seven_zip x $ndk_dmg
-            mkdir -p $(dirname $NDK_HOME)
-            mv Android\ NDK\ */AndroidNDK*.app/Contents/NDK $NDK_HOME
-            rm -rf Android\ NDK\ *
-            cd -
-        else
-            ndk_zip=android-ndk-$NDK_VERSION-linux.zip
-            if ! test -f downloads/$ndk_zip; then
-                echo ">>> Downloading $ndk_zip"
-                curl -#L -o downloads/$ndk_zip https://dl.google.com/android/repository/$ndk_zip
-            fi
-            cd downloads
-            unzip -oq $ndk_zip
-            mkdir -p $(dirname $NDK_HOME)
-            mv android-ndk-$NDK_VERSION $NDK_HOME
-            cd -
-            echo "NDK installed to $NDK_HOME"
-        fi
-    else
-        echo "NDK $NDK_VERSION is already installed in $NDK_HOME"
+#!/usr/bin/env bash
+# Install an Android NDK component via sdkmanager.
+#
+# Usage:
+#   .ci/install_ndk.sh                    # uses $NDK_VERSION
+#   .ci/install_ndk.sh 27.3.13750724      # explicit component version
+#   .ci/install_ndk.sh r27d               # release letter (resolved via Google's manifest)
+#
+# Installs into $ANDROID_HOME/ndk/<component-version>/ — sdkmanager's
+# standard layout, which is also where AGP looks for Gradle builds.
+# When SOURCED (`. install_ndk.sh ...`), exports NDK_HOME pointing at
+# the resulting install path; forge reads that env var.
+#
+# Idempotent: if the NDK is already installed, the sdkmanager call is skipped.
+#
+# Requires `sdkmanager` from the Android SDK cmdline-tools. On CI both
+# the Ubuntu and macOS runner images ship it; locally install Android
+# Studio or the standalone cmdline-tools.
+
+set -eu
+
+version="${1:-${NDK_VERSION:-}}"
+if [ -z "$version" ]; then
+    echo "usage: $0 <ndk-version>  (or set NDK_VERSION)" >&2
+    exit 2
+fi
+
+# Resolve release-letter form (e.g. "r27d") to the component version
+# (e.g. "27.3.13750724") via Google's repository manifest. Skipped when
+# the input is already in component form. Uses awk to track the most-recent
+# `path="ndk;<version>"` attribute.
+if [[ "$version" =~ ^r[0-9]+[a-z]*$ ]]; then
+    letter="$version"
+    version=$(curl -sfL https://dl.google.com/android/repository/repository2-3.xml \
+                | awk -v zip="android-ndk-${letter}-linux.zip" '
+                    match($0, /path="ndk;[0-9.]+"/) {
+                        current = substr($0, RSTART+10, RLENGTH-11)
+                    }
+                    !found && index($0, zip) { print current; found=1 }
+                  ')
+    if [ -z "$version" ]; then
+        echo "Could not resolve NDK release letter '$letter' to a component version." >&2
+        echo "Check it exists at https://dl.google.com/android/repository/repository2-3.xml" >&2
+        exit 4
     fi
-else
-    echo "NDK home: $NDK_HOME"
+    echo "Resolved $letter → $version"
+fi
+
+: "${ANDROID_HOME:?ANDROID_HOME must be set (Android SDK location)}"
+
+sdkmanager="$ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager"
+if [ ! -x "$sdkmanager" ]; then
+    echo "sdkmanager not found at $sdkmanager" >&2
+    echo "  Install Android Studio or the standalone cmdline-tools first." >&2
+    exit 3
+fi
+
+install_dir="$ANDROID_HOME/ndk/$version"
+
+# Idempotency check: any host-triplet clang under the install dir means
+# it's already installed and usable.
+if ! find "$install_dir/toolchains/llvm/prebuilt"/*/bin/aarch64-linux-android*-clang 2>/dev/null | grep -q .; then
+    echo "Installing NDK $version via sdkmanager…"
+    yes | "$sdkmanager" --licenses > /dev/null
+    "$sdkmanager" --install "ndk;$version"
 fi
 
-export NDK_HOME
+echo "NDK $version installed at $install_dir"
+export NDK_HOME="$install_dir"
+
+# When run as a GH Actions step (not sourced — the export above doesn't
+# persist across steps), write NDK_HOME to $GITHUB_ENV so downstream
+# steps inherit it. Harmless to no-op when $GITHUB_ENV is unset (local).
+if [ -n "${GITHUB_ENV:-}" ]; then
+    echo "NDK_HOME=$install_dir" >> "$GITHUB_ENV"
+fi

.ci/read_meta.py

@@ -0,0 +1,78 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["pyyaml", "jinja2"]
+# ///
+"""Read fields from a recipe's meta.yaml and print them as one
+tab-separated line:
+
+    <version>\t<build_number>\t<space-joined-platforms>
+
+Examples:
+
+    2.2.2\t0\t                    # numpy (no platforms, no build override)
+    1.6.1\t0\tandroid             # pyjnius
+    1.2.3\t0\tios                 # pyobjus
+    8.11.0\t1\t                   # flet-libcurl (uses Jinja `{% set %}`)
+
+Used by the build-wheels.yml matrix step to (a) skip per-recipe
+(platform, pkg) combinations that the recipe opts out of, and (b)
+include the version + build number in each job's display name.
+
+A standalone PEP 723 script rather than an inline here-doc in the
+workflow — testable in isolation, declares its own pyyaml/jinja2 deps
+so the runner doesn't need them preinstalled.
+
+meta.yaml is a Jinja template (forge renders it before YAML-parsing).
+We render it the same way, with a generic SDK context — the fields we
+read here are platform-independent, so any plausible render values
+work. Picking `sdk='android'` is arbitrary and convenient.
+
+On any failure (file missing, template invalid, YAML invalid,
+schema-shape unexpected) we print a blank-but-tab-aligned line so the
+bash caller's `IFS=$'\\t' read -r ver build platforms` doesn't blow up
+— the caller treats empty fields as "unknown, fall back to whatever
+the package spec or workflow defaults already say."""
+
+import sys
+
+import jinja2
+import yaml
+
+
+def main(path: str) -> int:
+    version = ""
+    build_number = ""
+    platforms = ""
+    try:
+        with open(path) as f:
+            tpl = f.read()
+        rendered = jinja2.Template(tpl).render(
+            sdk="android",
+            sdk_version=24,
+            arch="arm64-v8a",
+            version=None,
+            py_version=(3, 12, 12),
+        )
+        meta = yaml.safe_load(rendered) or {}
+        pkg = meta.get("package") or {}
+        if "version" in pkg:
+            version = str(pkg["version"])
+        plat = pkg.get("platforms")
+        if plat:
+            platforms = " ".join(plat)
+        # build.number defaults to 0 in the schema, but raw meta.yaml may
+        # omit it. Match the schema default rather than treating it as
+        # unknown.
+        build = (meta.get("build") or {}).get("number", 0)
+        build_number = str(build)
+    except Exception:
+        pass
+    print(f"{version}\t{build_number}\t{platforms}")
+    return 0
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print("usage: read_meta.py <recipe-meta.yaml-path>", file=sys.stderr)
+        sys.exit(2)
+    sys.exit(main(sys.argv[1]))

.ci/run_android_test.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+# Run inside reactivecircus/android-emulator-runner@v2's script: field.
+# That action runs each script line through `sh -c` separately, which breaks
+# multi-line bash constructs (functions, traps, if blocks). So the whole
+# logic lives in this dedicated script file with its own bash shebang;
+# the workflow's `script:` field just invokes this file as a one-liner.
+#
+# Side effects:
+#   - installs + launches the recipe-tester APK at
+#     tests/recipe-tester/build/apk/recipe-tester.apk
+#   - delegates the poll-and-parse to .ci/wait_for_console.sh
+#   - on failure, dumps `adb logcat -d` and a screencap into the workspace
+#     root so the workflow's upload-artifact step can pick them up
+#     (the AVD is alive at trap-time; the post-action phase has already
+#     killed it by the time the workflow's failure-conditional steps run)
+
+set -eux
+
+cleanup() {
+    rc=$?
+    if [ "$rc" -ne 0 ]; then
+        adb logcat -d > logcat-on-failure.txt 2>/dev/null || true
+        adb exec-out screencap -p > screen-on-failure.png 2>/dev/null || true
+    fi
+    return $rc
+}
+trap cleanup EXIT
+
+adb install -r tests/recipe-tester/build/apk/recipe-tester.apk
+adb logcat -c
+adb shell monkey -p com.flet.recipe_tester -c android.intent.category.LAUNCHER 1
+
+# 15min hard cap on the device-side run; recipe tests should finish in
+# <2min, the extra slack absorbs AVD slowness.
+TIMEOUT=900 .ci/wait_for_console.sh android

.ci/run_ios_test.sh

@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+# Mirror of .ci/run_android_test.sh for the iOS Simulator lane.
+#
+# Boots an iPhone simulator if none is running, installs the recipe-tester
+# .app, launches it, then delegates the EXIT-sentinel poll to
+# .ci/wait_for_console.sh ios.
+#
+# Side effects:
+#   - on failure, dumps `xcrun simctl spawn booted log show --last 10m`
+#     into syslog-on-failure.txt and a screencap into screen-on-failure.png
+#     so the workflow's upload-artifact step can pick them up. The simulator
+#     is still booted at trap-time (the workflow doesn't shut it down
+#     itself), so these calls work.
+#
+# Why a separate script (not inline `run:`): same reason as the Android
+# helper — keep the dash/bash quirks inside a file with a proper bash
+# shebang so multi-line constructs survive whatever shell the action
+# eventually picks. (Less critical here since the iOS step is a plain
+# `run: bash` rather than an action's split-by-line script:, but it's
+# consistent and keeps the diff focused.)
+
+set -eux
+
+APP=tests/recipe-tester/build/ios-simulator/recipe-tester.app
+IOS_BUNDLE=${IOS_BUNDLE:-com.flet.recipe-tester}
+
+cleanup() {
+    rc=$?
+    if [ "$rc" -ne 0 ]; then
+        xcrun simctl spawn booted log show --last 10m > syslog-on-failure.txt 2>/dev/null || true
+        xcrun simctl io booted screenshot screen-on-failure.png 2>/dev/null || true
+    fi
+    return $rc
+}
+trap cleanup EXIT
+
+# Pick + boot a simulator if none is currently booted. Robust to the
+# specific device names changing between macos image versions: grab the
+# first available iPhone in any iOS runtime.
+if ! xcrun simctl list devices booted | grep -q "Booted"; then
+    UDID=$(xcrun simctl list devices available -j \
+        | jq -r '.devices | to_entries[]
+                 | select(.key | contains("iOS"))
+                 | .value[]
+                 | select(.isAvailable == true and (.name | startswith("iPhone")))
+                 | .udid' \
+        | head -1)
+    if [ -z "$UDID" ]; then
+        echo "::error::no iPhone simulator available on this runner"
+        xcrun simctl list devices available
+        exit 3
+    fi
+    echo "Booting simulator $UDID"
+    xcrun simctl boot "$UDID"
+fi
+xcrun simctl bootstatus booted -b
+
+xcrun simctl install booted "$APP"
+xcrun simctl launch booted "$IOS_BUNDLE"
+
+# Same 15-min device-side cap as Android. Tests should finish in <2min;
+# the slack absorbs cold-boot + first-launch Python init overhead.
+TIMEOUT=900 .ci/wait_for_console.sh ios