ruby_everywhere 0.2.0 → 0.4.0

data/bridge/package.json

@@ -1,11 +1,14 @@
 {
   "name": "@rubyeverywhere/bridge",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "One API for browser, desktop, and mobile — the JS half of RubyEverywhere",
   "type": "module",
   "main": "everywhere/bridge.js",
-  "exports": { ".": "./everywhere/bridge.js" },
-  "files": ["everywhere/bridge.js", "README.md", "LICENSE"],
+  "exports": {
+    ".": "./everywhere/bridge.js",
+    "./native.css": "./everywhere/native.css"
+  },
+  "files": ["everywhere/bridge.js", "everywhere/native.css", "README.md", "LICENSE"],
   "sideEffects": false,
   "keywords": ["rubyeverywhere", "tauri", "hotwire", "turbo", "rails", "desktop", "native", "bridge"],
   "homepage": "https://rubyeverywhere.com",

data/lib/everywhere/android_resources.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Everywhere
+  # Compiles an app's native/android/assets/ tree into Android drawable
+  # resources so native code can reach them by name — R.drawable.logo in Kotlin,
+  # @drawable/logo in a layout.
+  #
+  # Deliberately the same filename API as the iOS side (see AssetCatalog), so one
+  # assets/ tree can be authored once and dropped into both native/ios/ and
+  # native/android/: <name>[@2x|@3x][~dark].<ext>. What differs is where the
+  # markers land, because Android expresses both as directory qualifiers rather
+  # than as catalog metadata:
+  #
+  #   logo.png        → res/drawable/logo.png              (density-independent baseline)
+  #   logo@2x.png     → res/drawable-xhdpi/logo.png        (2x = 320dpi)
+  #   logo@3x.png     → res/drawable-xxhdpi/logo.png       (3x = 480dpi)
+  #   logo~dark.png   → res/drawable-night/logo.png
+  #   logo@2x~dark.png→ res/drawable-night-xhdpi/logo.png
+  #
+  # Sub-directories organise the source tree but do NOT namespace the result —
+  # res/ is flat, and asset names are global on iOS too, so assets/branding/
+  # logo.png is R.drawable.logo either way.
+  module AndroidResources
+    # Raster formats aapt2 accepts as-is. WebP is included (and PDF/SVG are not)
+    # because that is the split Android itself draws — the reverse of iOS.
+    RASTER = %w[.png .jpg .jpeg .webp].freeze
+
+    # A drawable written as XML: vectors, shapes, layer lists, selectors. Scale
+    # -free, so the density qualifiers above don't apply to them.
+    VECTOR = %w[.xml].freeze
+    EXTENSIONS = (RASTER + VECTOR).freeze
+
+    # iOS's @2x/@3x in Android's density buckets. 1x is plain `drawable`, not
+    # `drawable-mdpi`: both mean 160dpi, but the unqualified directory is also
+    # the fallback every density falls back TO, which is what a single-file
+    # asset needs to be.
+    DENSITIES = { nil => nil, "2x" => "xhdpi", "3x" => "xxhdpi" }.freeze
+
+    # Written by the Android builder itself (adaptive launcher icon layers) or
+    # shipped in the frozen template's own res/. Both would collide in the
+    # merged resource table, so they're refused by name here — a merge conflict
+    # from aapt2 arrives minutes into a Gradle run and names no fix.
+    RESERVED = %w[
+      ic_launcher ic_launcher_round ic_launcher_foreground ic_launcher_background
+      ic_tab_placeholder
+    ].freeze
+
+    # An Android resource entry is a field on the generated R class, so the name
+    # has to be a Java identifier — and aapt2 additionally rejects uppercase in
+    # a res/ filename. Hyphens and dots are legal on iOS and never here.
+    VALID_NAME = /\A[a-z][a-z0-9_]*\z/
+
+    # Reserved words can't name a field on R. `val`/`fun` are fine (Kotlin reads
+    # R from Java), so this is the Java list, not the Kotlin one.
+    JAVA_KEYWORDS = %w[
+      abstract assert boolean break byte case catch char class const continue default do double else
+      enum extends final finally float for goto if implements import instanceof int interface long
+      native new package private protected public return short static strictfp super switch
+      synchronized this throw throws transient try void volatile while
+    ].freeze
+
+    class << self
+      # Copy every image under `source` into `res` as a drawable resource.
+      # Returns [names, errors]; nothing is written when errors is non-empty, so
+      # a broken assets/ tree can't half-stamp the resource dirs.
+      def write!(source, res)
+        variants, errors = plan(source)
+        return [[], errors] unless errors.empty?
+
+        variants.each do |variant|
+          dir = File.join(res, variant[:dir])
+          FileUtils.mkdir_p(dir)
+          FileUtils.cp(variant[:path], File.join(dir, "#{variant[:name]}#{variant[:extension]}"))
+        end
+
+        [variants.map { |variant| variant[:name] }.uniq.sort, []]
+      end
+
+      private
+
+      # Errors are collected (not raised) so one `every build` reports every
+      # problem in the tree instead of the first.
+      def plan(source)
+        errors = []
+        files = Dir.glob(File.join(source, "**", "*"))
+                   .select { |path| File.file?(path) && !File.basename(path).start_with?(".") }
+                   .sort
+        images, other = files.partition { |path| EXTENSIONS.include?(File.extname(path).downcase) }
+
+        other.each { |path| errors << unsupported(path, source) }
+        variants = images.filter_map { |path| variant(path, source, errors) }
+        errors.concat(clash_errors(variants))
+
+        [variants, errors]
+      end
+
+      def unsupported(path, source)
+        relative = relative(path, source)
+        case File.extname(path).downcase
+        when ".svg", ".pdf"
+          "#{relative}: Android has no runtime SVG or PDF renderer — export a PNG, or convert it to " \
+            "a VectorDrawable (Android Studio: right-click res → New → Vector Asset) and ship the .xml"
+        else
+          "#{relative}: unsupported image type — use #{EXTENSIONS.join(", ")}"
+        end
+      end
+
+      def variant(path, source, errors)
+        relative = relative(path, source)
+        extension = File.extname(path).downcase
+        stem = File.basename(path, File.extname(path))
+
+        # A nine-patch is `logo.9.png`, whose stem carries a dot that no valid
+        # resource name may — so it would otherwise fail with a naming error
+        # that says nothing about what the author actually tried to do.
+        if stem.end_with?(".9")
+          errors << "#{relative}: nine-patch drawables aren't supported yet — ship a plain #{extension} " \
+                    "(or a VectorDrawable .xml, which stretches without one)"
+          return nil
+        end
+
+        name, scale, dark = parse(stem)
+
+        unless name.match?(VALID_NAME)
+          errors << "#{relative}: #{name.inspect} isn't a usable Android resource name — use lowercase " \
+                    "letters, digits and _, starting with a letter (#{suggestion(name).inspect} would " \
+                    "work). Unlike iOS, Android has no room for capitals, hyphens or dots here"
+          return nil
+        end
+        if JAVA_KEYWORDS.include?(name)
+          errors << "#{relative}: #{name.inspect} is a Java keyword, so it can't name a field on R — " \
+                    "rename it (#{"#{name}_image".inspect})"
+          return nil
+        end
+        if RESERVED.include?(name)
+          errors << "#{relative}: #{name} is reserved by the shell (launcher icon and tab placeholder) — " \
+                    "rename it"
+          return nil
+        end
+        if scale && VECTOR.include?(extension)
+          errors << "#{relative}: an XML drawable is scale-free — drop the @#{scale} suffix"
+          return nil
+        end
+
+        { name: name, extension: extension, dir: directory(scale, dark), source_dir: File.dirname(relative),
+          scale: scale, dark: dark, vector: VECTOR.include?(extension), path: path, relative: relative }
+      end
+
+      # Trailing @2x/@3x and ~dark markers, in either order, off the stem —
+      # character for character AssetCatalog#parse, because the two platforms
+      # read the same filenames.
+      def parse(stem)
+        name = stem.dup
+        scale = nil
+        dark = false
+        loop do
+          if name.sub!(/~dark\z/, "")
+            dark = true
+          elsif name.sub!(/@([23])x\z/, "")
+            scale = "#{Regexp.last_match(1)}x"
+          else
+            break
+          end
+        end
+        [name, scale, dark]
+      end
+
+      # Qualifier order is fixed by the platform and is not alphabetical: UI mode
+      # (night) comes before density. `drawable-xhdpi-night` is not a directory
+      # Android will ever match — it's silently ignored, which reads as "my dark
+      # asset doesn't work" with nothing in the log.
+      def directory(scale, dark)
+        ["drawable", dark ? "night" : nil, DENSITIES.fetch(scale)].compact.join("-")
+      end
+
+      # What the author probably meant, so the error can show it rather than
+      # describe it. Not applied automatically: R.drawable.<name> is written by
+      # hand in Kotlin, so a name we invented is a name nobody can guess.
+      def suggestion(name)
+        candidate = name.gsub(/([a-z0-9])([A-Z])/, '\1_\2').downcase.gsub(/[^a-z0-9]+/, "_")
+                        .gsub(/_+/, "_").delete_prefix("_").delete_suffix("_")
+        candidate.match?(/\A[a-z]/) ? candidate : "image_#{candidate}"
+      end
+
+      def clash_errors(variants)
+        errors = []
+        variants.group_by { |variant| variant[:name] }.each do |name, group|
+          dirs = group.map { |variant| variant[:source_dir] }.uniq
+          if dirs.length > 1
+            listed = dirs.map { |dir| dir == "." ? "assets/" : "assets/#{dir}/" }.join(" and ")
+            errors << "#{name}: same asset name in #{listed} — res/ is flat, so both would become " \
+                      "R.drawable.#{name}. Rename one"
+          end
+          if group.map { |variant| variant[:vector] }.uniq.length > 1
+            errors << "#{name}: mixes an XML drawable with bitmaps — pick one per asset"
+          end
+
+          # Same destination directory and same name: aapt2 sees two files
+          # claiming one resource, whatever their extensions.
+          group.group_by { |variant| variant[:dir] }.each_value do |clash|
+            next if clash.length < 2
+
+            errors << "#{name}: #{clash.map { |variant| variant[:relative] }.join(" and ")} both become " \
+                      "res/#{clash.first[:dir]}/#{name}"
+          end
+        end
+        errors
+      end
+
+      def relative(path, source)
+        path.delete_prefix("#{source}/")
+      end
+    end
+  end
+end

data/lib/everywhere/android_sdk.rb

@@ -0,0 +1,330 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require_relative "shellout"
+require_relative "ui"
+
+module Everywhere
+  # Locates the Android toolchain — SDK, adb, emulator, sdkmanager, JDK — for
+  # the builder, the emulator driver, `every logs` and `every doctor`.
+  #
+  # The one rule everything here follows: resolve BY LOCATION, never off PATH.
+  # Android Studio provisions the whole toolchain (SDK, platform-tools, the
+  # emulator, system images, a bundled JDK) and exports none of it — no shell
+  # profile is touched, so a machine that can build Android apps all day has no
+  # `adb`, no `sdkmanager` and often no `java` on PATH at all. A `which adb`
+  # here would report "missing" on a perfectly provisioned Mac. Fixed locations
+  # under the SDK root are what's actually stable, the same way `xcrun` shields
+  # the iOS builder from wherever Xcode put its internals.
+  module AndroidSdk
+    module_function
+
+    # Android Gradle Plugin 8.x refuses to run on anything older, and the
+    # failure surfaces as an unreadable Gradle/Kotlin stacktrace rather than a
+    # version complaint — so we check before Gradle ever starts.
+    MINIMUM_JDK = 17
+
+    # The API level the shell template compiles against. Named here (not in the
+    # builder) because `every doctor` has to print the sdkmanager line for it
+    # long before a build is attempted.
+    COMPILE_SDK = 35
+
+    # Android Studio's bundled JetBrains Runtime, per platform. Studio never
+    # exports it, so these paths are the only way to find a JDK on a machine
+    # whose owner installed Studio and nothing else.
+    STUDIO_JBR = [
+      "/Applications/Android Studio.app/Contents/jbr/Contents/Home",
+      "~/Applications/Android Studio.app/Contents/jbr/Contents/Home",
+      "/opt/android-studio/jbr",
+      "/usr/local/android-studio/jbr",
+      "~/android-studio/jbr",
+      "C:/Program Files/Android/Android Studio/jbr"
+    ].freeze
+
+    # --- platform ------------------------------------------------------------
+
+    def macos?   = RUBY_PLATFORM.include?("darwin")
+    def windows? = RUBY_PLATFORM.match?(/mswin|mingw|cygwin/)
+
+    # --- SDK root ------------------------------------------------------------
+
+    # Where the SDK lives on a default install, per platform. Studio writes
+    # exactly one of these and records it in its own settings — never in the
+    # environment — which is why the fallback matters more here than it would
+    # for a toolchain with an installer that edits your profile.
+    def default_sdk_roots
+      if macos?
+        ["~/Library/Android/sdk"]
+      elsif windows?
+        [ENV["LOCALAPPDATA"] && File.join(ENV["LOCALAPPDATA"], "Android", "Sdk")].compact
+      else
+        ["~/Android/Sdk"]
+      end
+    end
+
+    # The SDK root, or nil. An explicit env var wins so CI images and secondary
+    # SDKs work without moving anything; ANDROID_HOME comes first because it's
+    # the spelling Studio and the docs use now (ANDROID_SDK_ROOT is deprecated
+    # but still all over CI). A var pointing at a directory that isn't there is
+    # skipped rather than fatal — a stale export shouldn't hide the SDK sitting
+    # in the default location.
+    def sdk_root
+      [ENV["ANDROID_HOME"], ENV["ANDROID_SDK_ROOT"], *default_sdk_roots]
+        .reject { |dir| dir.to_s.empty? }
+        .map { |dir| File.expand_path(dir) }
+        .find { |dir| File.directory?(dir) }
+    end
+
+    def sdk_root!
+      sdk_root or UI.die!("no Android SDK — install Android Studio (it provisions the SDK, adb, " \
+                          "the emulator and a JDK in one go), or point ANDROID_HOME at an " \
+                          "existing SDK; looked in #{expected_sdk_root}")
+    end
+
+    # The path named in "we couldn't find it" messages, so the user is told
+    # where we looked rather than left to guess.
+    def expected_sdk_root
+      File.expand_path(default_sdk_roots.first || "~/Android/Sdk")
+    end
+
+    # --- tools ---------------------------------------------------------------
+
+    def adb      = sdk_tool("platform-tools", "adb")
+    def emulator = sdk_tool("emulator", "emulator")
+
+    def adb!
+      adb or UI.die!("no adb under #{sdk_root!} — #{install_hint("platform-tools")}")
+    end
+
+    def emulator!
+      emulator or UI.die!("no Android emulator under #{sdk_root!} — #{install_hint("emulator")}")
+    end
+
+    def sdkmanager = cmdline_tool("sdkmanager")
+    def avdmanager = cmdline_tool("avdmanager")
+
+    def sdkmanager!
+      sdkmanager or UI.die!("no sdkmanager under #{sdk_root!} — #{cmdline_tools_hint}")
+    end
+
+    def avdmanager!
+      avdmanager or UI.die!("no avdmanager under #{sdk_root!} — #{cmdline_tools_hint}")
+    end
+
+    # Whether this SDK can install anything at all. Worth asking on its own,
+    # because it's the one component whose absence makes every other
+    # remediation unquotable: without it there is no `sdkmanager` to run, and
+    # the Phase 0 machine had a complete SDK, adb, the emulator, build-tools and
+    # an AVD with no cmdline-tools anywhere — not in the SDK, not inside Android
+    # Studio. So a missing one is an advisory, not a broken machine.
+    def cmdline_tools? = !sdkmanager.nil?
+
+    # How to get command-line tools without already having them. The Studio
+    # route is first because it also accepts the licences, but the manual zip
+    # matters: it's the only answer for a machine with no Studio, and Studio's
+    # own SDK Tools list is exactly where this component was already unchecked.
+    CMDLINE_TOOLS_URL = "https://developer.android.com/studio#command-line-tools-only"
+
+    def cmdline_tools_hint
+      "install \"Android SDK Command-line Tools (latest)\" in Android Studio → Settings → " \
+        "Languages & Frameworks → Android SDK → SDK Tools, or download " \
+        "commandlinetools-#{host_tag}-*_latest.zip from #{CMDLINE_TOOLS_URL} and unzip it into " \
+        "#{cmdline_tools_dir} (so its bin/ lands there)"
+    end
+
+    # Where an unzipped command-line-tools release has to end up. Named because
+    # both hints point at it, and because "unzip it somewhere in the SDK" is
+    # the instruction people get wrong — the tools look for their own jars
+    # relative to this exact directory.
+    def cmdline_tools_dir
+      File.join(sdk_root || expected_sdk_root, "cmdline-tools", "latest")
+    end
+
+    # The token Google's command-line-tools downloads are named with.
+    def host_tag
+      return "mac" if macos?
+
+      windows? ? "win" : "linux"
+    end
+
+    # A tool at its fixed spot under the SDK root, or nil.
+    def sdk_tool(subdir, name)
+      root = sdk_root or return nil
+
+      tool_in(File.join(root, subdir), name)
+    end
+
+    # sdkmanager and avdmanager are the one pair that moved: current installs
+    # put them in cmdline-tools/latest/bin, an SDK pinned to a specific
+    # command-line-tools release uses cmdline-tools/<version>/bin, and anything
+    # provisioned before 2021 still has the legacy tools/bin copy. Try all three
+    # so `every doctor` can print a working install line on an older machine
+    # instead of a path that doesn't exist.
+    def cmdline_tool(name)
+      root = sdk_root or return nil
+
+      # Reverse-sorted so 12.0 beats 9.0 in the common case; "latest" is tried
+      # first anyway, so this ordering only decides between pinned releases.
+      versioned = Dir.glob(File.join(root, "cmdline-tools", "*", "bin")).sort.reverse
+      dirs = [File.join(root, "cmdline-tools", "latest", "bin"), *versioned,
+              File.join(root, "tools", "bin")]
+      dirs.uniq.filter_map { |dir| tool_in(dir, name) }.first
+    end
+
+    # Windows spells the same tools adb.exe and sdkmanager.bat; probing the
+    # suffixes here lets every caller ask for the plain Unix name.
+    def tool_in(dir, name)
+      [name, "#{name}.exe", "#{name}.bat"]
+        .map { |file| File.join(dir, file) }
+        .find { |path| File.file?(path) }
+    end
+
+    # A ready-to-paste instruction for installing a missing SDK package. When
+    # the SDK has no command-line tools at all there IS no command to paste, so
+    # say what to click in Studio instead — an honest instruction beats a
+    # copyable line that resolves to nothing. Phrased to read on its own, since
+    # callers append it after an em dash.
+    def install_hint(package)
+      if (manager = sdkmanager)
+        "run: #{manager.shellescape} #{package.inspect}"
+      else
+        # The short form of cmdline_tools_hint: doctor prints the full version
+        # once, above these lines, and repeating a URL and two absolute paths
+        # on every missing package buries what each line is actually about.
+        "install \"Android SDK Command-line Tools\" (Android Studio → SDK Tools, or unzip " \
+        "commandlinetools-#{host_tag}-*_latest.zip into #{cmdline_tools_dir}), " \
+        "then run: sdkmanager #{package.inspect}"
+      end
+    end
+
+    # --- JDK -----------------------------------------------------------------
+
+    # Gradle needs a JDK. JAVA_HOME wins because it's the one explicit choice on
+    # the machine; then macOS's own registry (which knows about JDKs installed
+    # by brew, Oracle or SDKMAN without any of them being on PATH); then
+    # Studio's bundled runtime, which is what a Studio-only machine actually has.
+    def java_home
+      explicit = ENV["JAVA_HOME"].to_s
+      return File.expand_path(explicit) if !explicit.empty? && File.directory?(explicit)
+
+      registry_java_home || studio_java_home
+    end
+
+    # Like #java_home but also enforces the minimum: a JDK 11 that resolves
+    # cleanly still fails the build later, deep inside Gradle, so reject it here
+    # where the message can name the cause.
+    def java_home!(minimum: MINIMUM_JDK)
+      home = java_home or
+        UI.die!("no JDK — install Android Studio (it bundles one at #{STUDIO_JBR.first}) " \
+                "or set JAVA_HOME to a JDK #{minimum} or newer")
+      version = java_version
+      return home if version.nil? || version >= minimum
+
+      UI.die!("#{home} is JDK #{version}; the Android Gradle Plugin needs #{minimum} or newer — " \
+              "set JAVA_HOME to a JDK #{minimum}+, or install Android Studio and use its bundled runtime")
+    end
+
+    # The JDK's major version, or nil if it can't be determined. Read from the
+    # `release` file the JDK ships rather than by running `java -version`: it's
+    # a file read instead of a JVM start, and it works for a JDK that isn't on
+    # PATH — which, per the rule at the top, is most of them. A JDK 8 reports
+    # JAVA_VERSION="1.8.0_412", so this yields 1, which compares correctly
+    # against MINIMUM_JDK without special-casing the old scheme.
+    def java_version
+      home = java_home or return nil
+      release = File.join(home, "release")
+      return File.read(release)[/^JAVA_VERSION="?(\d+)/, 1]&.to_i if File.file?(release)
+
+      java = tool_in(File.join(home, "bin"), "java") or return nil
+      out, status = Shellout.capture(java, "-version")
+      out[/version "?(\d+)/, 1]&.to_i if status&.success?
+    end
+
+    # macOS keeps a registry of installed JDKs that java_home queries; -v 17
+    # asks for "17 or newer", so a machine with only JDK 21 still answers.
+    def registry_java_home
+      return nil unless macos?
+
+      out, status = Shellout.capture("/usr/libexec/java_home", "-v", MINIMUM_JDK.to_s)
+      home = out.to_s.strip
+      home if status&.success? && !home.empty? && File.directory?(home)
+    end
+
+    def studio_java_home
+      STUDIO_JBR.map { |dir| File.expand_path(dir) }.find { |dir| File.directory?(dir) }
+    end
+
+    # --- installed packages --------------------------------------------------
+
+    # Which platforms/build-tools are on disk, read straight off the filesystem
+    # rather than from `sdkmanager --list`: that's a multi-second JVM start that
+    # also reaches out for the remote catalogue we don't care about, and it
+    # needs the command-line tools, which are exactly the component most likely
+    # to be missing on a Studio-only machine.
+    def installed_platforms   = sdk_package_dirs("platforms")
+    def installed_build_tools = sdk_package_dirs("build-tools")
+
+    def sdk_package_dirs(kind)
+      root = sdk_root or return []
+
+      Dir.glob(File.join(root, kind, "*"))
+         .select { |dir| File.directory?(dir) }
+         .map { |dir| File.basename(dir) }
+         .sort
+    end
+
+    # `platform?(35)` and `platform?("android-35")` both work — callers spell it
+    # whichever way reads better where they are.
+    def platform?(api = COMPILE_SDK)
+      name = api.to_s.start_with?("android-") ? api.to_s : "android-#{api}"
+      installed_platforms.include?(name)
+    end
+
+    def platform!(api = COMPILE_SDK)
+      return true if platform?(api)
+
+      package = "platforms;android-#{api.to_s.delete_prefix("android-")}"
+      UI.die!("the Android SDK has no #{package} (installed: " \
+              "#{installed_platforms.empty? ? "none" : installed_platforms.join(", ")}) — " \
+              "#{install_hint(package)}")
+    end
+
+    # --- AVDs ----------------------------------------------------------------
+
+    # Virtual devices, newest-created last. Asked of the emulator binary rather
+    # than globbed out of ~/.android/avd because the emulator also honours
+    # ANDROID_AVD_HOME and ANDROID_SDK_HOME — and an AVD it won't list is one we
+    # couldn't boot anyway. Studio's Device Manager writes to the same place, so
+    # a VM created in the GUI shows up here with no extra step.
+    def avds
+      exe = emulator or return []
+
+      out, status = Shellout.capture(exe, "-list-avds")
+      return [] unless status&.success?
+
+      # The emulator prints INFO/WARNING banners on the same stream; AVD names
+      # can only contain [A-Za-z0-9._-], so anything with a space is chatter.
+      out.lines.map(&:strip).reject(&:empty?).grep(/\A[\w.-]+\z/)
+    end
+
+    def avds!
+      found = avds
+      return found if found.any?
+
+      UI.die!("no Android virtual devices — #{create_avd_hint}")
+    end
+
+    # How to get a bootable AVD. The GUI route comes first because a machine
+    # with Studio installed almost always has a device defined already, and
+    # Device Manager also downloads the system image the CLI line assumes.
+    def create_avd_hint
+      "create one in Android Studio → Device Manager, or run: " \
+      "#{(avdmanager || "avdmanager").shellescape} create avd -n Pixel_API_#{COMPILE_SDK} " \
+      "-k \"system-images;android-#{COMPILE_SDK};google_apis;#{host_abi}\""
+    end
+
+    # The system image ABI that runs at native speed on this host — an x86_64
+    # image on Apple silicon boots, technically, at a speed nobody will wait for.
+    def host_abi = RUBY_PLATFORM.match?(/arm64|aarch64/) ? "arm64-v8a" : "x86_64"
+  end
+end