catalyst-core 1.1.0 → 1.2.0-canary.2

package/dist/native/buildAndroid/config.js

@@ -1,13 +1,12 @@
 "use strict";
 
 const fs = require("fs");
-const os = require("os");
 const {
-  detectAndroidSdk,
-  listAvds,
-  expandHome,
   ANDROID_SDK_HINT
 } = require("../utils.js");
+const {
+  resolveNativeConfig
+} = require("../nativeConfig.js");
 
 /** An error carrying the one action that fixes it, shown as the diagnostic's hint. */
 function withHint(message, hint) {
@@ -15,94 +14,87 @@ function withHint(message, hint) {
     hint
   });
 }
-const tilde = dir => dir.startsWith(os.homedir()) ? `~${dir.slice(os.homedir().length)}` : dir;
 function createConfigPhase(ctx) {
   const {
     configPath,
     progress
   } = ctx;
-  async function initializeConfig() {
+
+  /**
+   * Read config.json and resolve what this build uses (nativeConfig.js):
+   * release or debug, the start URL and its guard, the app id and the
+   * version. The resolved config is written to a temp file for Gradle;
+   * call `cleanup()` when done.
+   *
+   * @param {object} [options]
+   * @param {boolean} [options.release] - `--release`
+   * @param {string} [options.url] - `--url`
+   * @param {string} [options.devHost] - the host the device reaches the dev server on
+   */
+  async function initializeConfig({
+    release: releaseFlag = false,
+    url,
+    devHost
+  } = {}) {
     const configFile = fs.readFileSync(configPath, "utf8");
     const config = JSON.parse(configFile);
     const {
-      WEBVIEW_CONFIG,
+      WEBVIEW_CONFIG: baseConfig,
       BUILD_OUTPUT_PATH
     } = config;
-    if (!WEBVIEW_CONFIG || Object.keys(WEBVIEW_CONFIG).length === 0) {
+    if (!baseConfig || Object.keys(baseConfig).length === 0) {
       throw new Error("WebView Config missing in " + configPath);
     }
-    if (!WEBVIEW_CONFIG.android) {
-      throw withHint("Android config missing in WebView Config", "Run catalyst setupEmulator:android to create it, or add WEBVIEW_CONFIG.android to config/config.json.");
-    }
-    const buildType = WEBVIEW_CONFIG.android.buildType || "debug";
-    if (buildType === "release") {
-      progress.log("Release build detected - AAB will be generated", "info");
+    const log = (message, type) => progress.log(message, type);
+    const resolved = resolveNativeConfig("android", {
+      release: releaseFlag,
+      url,
+      devHost,
+      config,
+      log
+    });
+    if (resolved.release) {
+      progress.log("Release build - a signed AAB will be generated", "info");
+      progress.log(`Release start URL: ${resolved.startUrl}`, "info");
     }
     return {
-      WEBVIEW_CONFIG,
-      BUILD_OUTPUT_PATH
+      config,
+      WEBVIEW_CONFIG: resolved.WEBVIEW_CONFIG,
+      BUILD_OUTPUT_PATH,
+      release: resolved.release,
+      version: resolved.version,
+      applicationId: resolved.appId,
+      usesDevServer: resolved.usesDevServer,
+      resolvedConfigPath: resolved.configPath,
+      cleanup: resolved.cleanup
     };
   }
-  function validateAndroidTools(androidConfig) {
-    progress.status("validating tools");
 
-    // An unset sdkPath is usually just an SDK in the default place. Use it,
-    // and say so, rather than failing on a field most people never set.
-    if (!androidConfig.sdkPath) {
-      const detected = detectAndroidSdk();
-      if (!detected) throw withHint("Android SDK not found", ANDROID_SDK_HINT);
-      androidConfig.sdkPath = detected;
-      progress.log(`Using the Android SDK at ${tilde(detected)}`, "note");
-    }
-    // "~/Library/Android/sdk", as the hint suggests. Expanded in memory
-    // only; the config file keeps what the user wrote.
-    androidConfig.sdkPath = expandHome(androidConfig.sdkPath);
+  /**
+   * Check the SDK tools a build runs, once ensureAndroidSdk has installed
+   * them: adb answers, and the emulator binary is there when one is used.
+   *
+   * @param {{ sdkPath: string }} androidConfig - sdkPath already resolved (resolveSdkPath)
+   * @param {{ needEmulator?: boolean }} [options]
+   */
+  function validateAndroidTools(androidConfig, {
+    needEmulator = true
+  } = {}) {
+    progress.status("validating tools");
     const ANDROID_SDK = androidConfig.sdkPath;
     const ADB_PATH = `${ANDROID_SDK}/platform-tools/adb`;
     const EMULATOR_PATH = `${ANDROID_SDK}/emulator/emulator`;
-    if (!fs.existsSync(ANDROID_SDK)) {
-      throw withHint(`Android SDK path does not exist: ${ANDROID_SDK}`, ANDROID_SDK_HINT);
-    }
-    if (!fs.existsSync(ADB_PATH)) {
-      throw withHint(`adb not found at ${ADB_PATH}`, "Install Android SDK Platform-Tools from Android Studio's SDK Manager.");
-    }
+    if (!fs.existsSync(ADB_PATH)) throw withHint(`adb not found at ${ADB_PATH}`, ANDROID_SDK_HINT);
     try {
-      ctx.runCommand(`${ADB_PATH} version`, {
+      ctx.runFile(ADB_PATH, ["version"], {
         timeout: 15000
       });
     } catch (error) {
       if (error.hint) throw error;
       throw new Error(`ADB is not working properly: ${error.message}`);
     }
-    const buildType = androidConfig.buildType || "debug";
-    if (buildType !== "release") {
-      if (!fs.existsSync(EMULATOR_PATH)) {
-        throw new Error(`Emulator not found at: ${EMULATOR_PATH}`);
-      }
-      try {
-        ctx.runCommand(`${EMULATOR_PATH} -version`);
-      } catch (error) {
-        throw new Error(`Emulator is not working properly: ${error.message}`);
-      }
-      if (!androidConfig.emulatorName) {
-        const [first] = listAvds(ANDROID_SDK);
-        if (!first) {
-          throw withHint("No Android emulator found", "Create one in Android Studio's Device Manager, or set WEBVIEW_CONFIG.android.emulatorName.");
-        }
-        androidConfig.emulatorName = first;
-        progress.log(`Using the "${first}" emulator`, "note");
-      }
-      try {
-        const avdOutput = ctx.runCommand(`${EMULATOR_PATH} -list-avds`);
-        if (!avdOutput.includes(androidConfig.emulatorName)) {
-          throw new Error(`Specified emulator "${androidConfig.emulatorName}" not found in available AVDs`);
-        }
-        progress.log(`Emulator "${androidConfig.emulatorName}" exists`, "success");
-      } catch (error) {
-        throw new Error(`Error checking emulator AVD: ${error.message}`);
-      }
-    } else {
-      progress.log("Skipping emulator validation for release build", "info");
+    if (needEmulator && !fs.existsSync(EMULATOR_PATH)) {
+      throw withHint(`Emulator not found at ${EMULATOR_PATH}`, ANDROID_SDK_HINT);
     }
     return {
       ANDROID_SDK,

package/dist/native/buildAndroid/devices.js

@@ -0,0 +1,176 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.chooseAndroidTarget = chooseAndroidTarget;
+exports.devServerReachPlan = devServerReachPlan;
+exports.launchArgs = launchArgs;
+exports.parseAdbDevices = parseAdbDevices;
+exports.reachDevServer = reachDevServer;
+exports.readyPhones = readyPhones;
+var _utils = require("../utils.js");
+// Where a debug build runs, and how it reaches the dev server.
+//
+// The emulator is the default. `--device` picks a connected phone instead,
+// and in a terminal with both available the person is asked, with the last
+// pick (.catalyst/local.json) as the default. A phone is never picked just
+// because it is plugged in.
+//
+// Debug builds load http://localhost:<port>. On the emulator and on a USB
+// phone alike, localhost is the device itself, so every port the app uses
+// is forwarded to this machine with `adb reverse` after each install.
+
+/**
+ * Parse `adb devices -l`.
+ *
+ * @param {string} output
+ * @returns {{ serial: string, state: string, emulator: boolean, model: string | null }[]}
+ */
+function parseAdbDevices(output) {
+  return String(output || "").split("\n").map(line => line.trim()).filter(line => line && !line.startsWith("List of devices") && !line.startsWith("*")).map(line => {
+    const [serial, state, ...rest] = line.split(/\s+/);
+    const props = Object.fromEntries(rest.filter(token => token.includes(":")).map(token => [token.slice(0, token.indexOf(":")), token.slice(token.indexOf(":") + 1)]));
+    return {
+      serial,
+      state,
+      emulator: serial.startsWith("emulator-"),
+      model: props.model ? props.model.replace(/_/g, " ") : null
+    };
+  }).filter(device => device.serial && device.state);
+}
+
+/** Phones adb can install on: not an emulator, and authorized ("device"). */
+function readyPhones(devices) {
+  return devices.filter(device => !device.emulator && device.state === "device");
+}
+const phoneLabel = device => device.model ? `${device.model} (${device.serial})` : device.serial;
+
+/**
+ * Choose where a debug build runs.
+ *
+ * @param {object} options
+ * @param {boolean} [options.wantDevice] - `--device`
+ * @param {ReturnType<typeof parseAdbDevices>} options.devices
+ * @param {{ target: string, serial?: string, avd?: string } | null} [options.last] - getLastTarget("android")
+ * @param {Record<string, string | undefined>} [options.env] - ANDROID_SERIAL picks a phone without a terminal
+ * @param {boolean} [options.isTTY]
+ * @param {typeof selectChoice} [options.select]
+ * @param {string} [options.emulatorHint] - shown beside the emulator choice
+ * @returns {Promise<{ target: "emulator" } | { target: "device", serial: string, model: string | null }>}
+ */
+async function chooseAndroidTarget({
+  wantDevice = false,
+  devices,
+  last = null,
+  env = process.env,
+  isTTY,
+  select = _utils.select,
+  emulatorHint
+}) {
+  const phones = readyPhones(devices);
+  const asDevice = device => ({
+    target: "device",
+    serial: device.serial,
+    model: device.model
+  });
+  const lastPhone = last?.target === "device" ? phones.find(device => device.serial === last.serial) : undefined;
+  if (wantDevice) {
+    if (env.ANDROID_SERIAL) {
+      const named = phones.find(device => device.serial === env.ANDROID_SERIAL);
+      if (!named) {
+        throw (0, _utils.nativeError)("ANDROID-011", `ANDROID_SERIAL=${env.ANDROID_SERIAL} is not a connected phone`);
+      }
+      return asDevice(named);
+    }
+    if (!phones.length) {
+      const unauthorized = devices.filter(device => !device.emulator && device.state === "unauthorized");
+      throw (0, _utils.nativeError)("ANDROID-011", unauthorized.length ? `${unauthorized.map(device => device.serial).join(", ")} has not allowed this computer yet; accept the prompt on the phone` : "adb devices lists no phone");
+    }
+    if (phones.length === 1) return asDevice(phones[0]);
+    const question = `Several Android phones are connected (${phones.map(device => device.serial).join(", ")}). Which one`;
+    if (!isTTY) {
+      throw (0, _utils.needsAnswerError)(question, {
+        hint: "Set ANDROID_SERIAL to the serial of the phone to use (adb devices lists them), or run the command in a terminal to pick one."
+      });
+    }
+    const serial = await select(question, phones.map(device => ({
+      label: phoneLabel(device),
+      value: device.serial
+    })), {
+      defaultValue: (lastPhone || phones[0]).serial,
+      isTTY
+    });
+    return asDevice(phones.find(device => device.serial === serial));
+  }
+
+  // No flag: the emulator, unless a person here picks a connected phone.
+  if (!phones.length || !isTTY) return {
+    target: "emulator"
+  };
+  const pick = await select("Run the app on", [{
+    label: "Emulator",
+    value: "emulator",
+    hint: emulatorHint
+  }, ...phones.map(device => ({
+    label: phoneLabel(device),
+    value: device.serial,
+    hint: "connected phone"
+  }))], {
+    defaultValue: lastPhone ? lastPhone.serial : "emulator",
+    isTTY
+  });
+  if (pick === "emulator") return {
+    target: "emulator"
+  };
+  return asDevice(phones.find(device => device.serial === pick));
+}
+
+/**
+ * The adb calls that let the app on `serial` reach the dev server: stop the
+ * running app first (its in-app server scans device ports 3000 to 3099 and
+ * would hold the port a reverse needs), then reverse every port.
+ *
+ * @param {string} serial
+ * @param {string} packageName - the installed (debug) package
+ * @param {number[]} ports - devServerPorts()
+ * @returns {string[][]} adb argv lists, in order
+ */
+function devServerReachPlan(serial, packageName, ports) {
+  return [["-s", serial, "shell", "am", "force-stop", packageName], ...ports.map(port => ["-s", serial, "reverse", `tcp:${port}`, `tcp:${port}`])];
+}
+
+/**
+ * Run devServerReachPlan with `adb(args)`. Stopping the app may fail (it may
+ * not be running); a failed reverse is an error, since the app would load a
+ * page with nothing behind it.
+ *
+ * @param {(args: string[]) => unknown} adb
+ * @param {string} serial
+ * @param {string} packageName
+ * @param {number[]} ports
+ */
+function reachDevServer(adb, serial, packageName, ports) {
+  const [stop, ...reverses] = devServerReachPlan(serial, packageName, ports);
+  try {
+    adb(stop);
+  } catch {
+    // Not running is fine.
+  }
+  for (const args of reverses) {
+    try {
+      adb(args);
+    } catch (error) {
+      const detail = String(error.stderr || error.message || "").trim().split("\n")[0];
+      throw Object.assign(new Error(`adb ${args.slice(2).join(" ")} failed on ${serial}: ${detail}`), {
+        stage: "Connecting the device to the dev server",
+        hint: `Run adb -s ${serial} reverse --list to see what holds the port, quit it, and build again.`
+      });
+    }
+  }
+}
+
+/** adb argv that opens the app's launcher activity. */
+function launchArgs(serial, packageName) {
+  return ["-s", serial, "shell", "monkey", "-p", packageName, "-c", "android.intent.category.LAUNCHER", "1"];
+}