catalyst-core 1.1.0 → 1.2.0-canary.2

package/dist/native/buildAndroid/index.js

@@ -5,9 +5,15 @@ const {
   displayPath
 } = require("../../cli/theme.js");
 const fs = require("fs");
+const {
+  execFileSync
+} = require("child_process");
 const {
   runCommand,
-  runInteractiveCommand
+  runFile,
+  runInteractiveCommand,
+  isInteractive,
+  select
 } = require("../utils.js");
 const {
   buildFailure
@@ -23,18 +29,74 @@ const {
 const createConfigPhase = require("./config.js");
 const createAssetsPhase = require("./assets.js");
 const createBuildPhase = require("./build.js");
+const {
+  resolveAndroidSigning,
+  exportUploadCertificate,
+  legacyKeystorePath
+} = require("./signing.js");
+const {
+  parseAdbDevices,
+  chooseAndroidTarget,
+  reachDevServer
+} = require("./devices.js");
+const {
+  releaseOutputDir,
+  releaseArtifactPaths
+} = require("./output.js");
+const {
+  DEFAULT_VERSION_NAME,
+  assertReleaseFolderFree
+} = require("../releaseOutput.js");
+const {
+  applyJavaHome,
+  ensureAndroidSdk,
+  ensureJava,
+  resolveSdkPath
+} = require("../androidToolchain.js");
+const {
+  getLastTarget,
+  saveLastTarget
+} = require("../localState.js");
+const {
+  ensureDevServer,
+  migrateLanAddresses,
+  devServerPorts,
+  readHmrPort
+} = require("../setupServer.js");
 const catalystCorePath = path.dirname(require.resolve("catalyst-core/package.json"));
 const pwd = path.join(catalystCorePath, "dist/native");
 const ANDROID_PACKAGE = "io.yourname.androidproject";
 const steps = {
+  server: "Start dev server",
   config: "Initialize configuration",
-  tools: "Validate Android tools",
-  emulator: "Check and start emulator",
+  tools: "Check Java and the Android SDK",
+  signing: "Resolve upload key",
+  emulator: "Prepare the device",
   copyAssets: "Copy build assets",
   build: "Build and install application",
   aab: "Build signed AAB"
 };
-function createAndroidBuild(config) {
+
+/**
+ * @param {object} config - { WEBVIEW_CONFIG, BUILD_OUTPUT_PATH } from config.json
+ * @param {object} [options] - parseNativeArgs()
+ * @param {boolean} [options.release] - `--release`: build the signed AAB whatever android.buildType says
+ * @param {string} [options.url] - `--url`: the release's production URL, over WEBVIEW_CONFIG.url
+ * @param {boolean} [options.device] - `--device`: run on the connected phone, not the emulator
+ * @param {boolean} [options.yes] - `--yes`: allow JDK/SDK/emulator installs without a terminal
+ * @param {boolean} [options.acceptLicenses] - `--accept-licenses`
+ */
+function createAndroidBuild(config, {
+  release: releaseFlag = false,
+  url,
+  device: wantDevice = false,
+  yes = false,
+  acceptLicenses = false
+} = {}) {
+  const flags = {
+    yes,
+    acceptLicenses
+  };
   const {
     WEBVIEW_CONFIG,
     BUILD_OUTPUT_PATH
@@ -53,6 +115,7 @@ function createAndroidBuild(config) {
     progress,
     ANDROID_PACKAGE,
     runCommand,
+    runFile,
     runInteractiveCommand
   };
   const {
@@ -69,12 +132,9 @@ function createAndroidBuild(config) {
     processNotifications
   } = createAssetsPhase(ctx);
   const {
-    detectPhysicalDevice,
-    testPhysicalDeviceInstallation,
     handleEmulatorSetup,
     buildApp,
     launchApp,
-    moveApkToOutputPath,
     buildSignedAAB
   } = createBuildPhase(ctx);
   function syncAIPackageIfEnabled(wvConfig, progress) {
@@ -106,55 +166,178 @@ function createAndroidBuild(config) {
       entry.isDirectory() ? copyDirSync(s, d) : fs.copyFileSync(s, d);
     }
   }
+
+  /** adb on one SDK, with a bound: a wedged adb server never answers. */
+  function adbRunner(ADB_PATH) {
+    return args => execFileSync(ADB_PATH, args, {
+      encoding: "utf8",
+      timeout: 15000,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  }
+  function listDevices(ADB_PATH) {
+    if (!fs.existsSync(ADB_PATH)) return [];
+    try {
+      return parseAdbDevices(adbRunner(ADB_PATH)(["devices", "-l"]));
+    } catch (error) {
+      progress.log(`adb devices failed: ${error.message}`, "warning");
+      return [];
+    }
+  }
   async function buildAndroidApp() {
     let androidConfig = null;
     let targetDevice = null;
+    let resolved = null;
+    let signing = null;
+    let artifactPath = null;
+    let certificatePath = null;
     try {
+      const log = (message, type) => progress.log(message, type);
+      const appRoot = process.cwd();
+      // Older setups saved this machine's LAN address in config.json.
+      // Put localhost back once, before the config is read (never for
+      // a release or in CI).
+      migrateLanAddresses({
+        cwd: appRoot,
+        release: releaseFlag,
+        platform: "android",
+        log
+      });
       progress.start("config");
+      resolved = await initializeConfig({
+        release: releaseFlag,
+        url
+      });
       const {
         WEBVIEW_CONFIG: wvConfig,
-        BUILD_OUTPUT_PATH: bop
-      } = await initializeConfig();
+        version,
+        applicationId
+      } = resolved;
       androidConfig = wvConfig.android;
-      const buildType = androidConfig.buildType || "debug";
+      const release = resolved.release;
       const buildOptimisation = !!androidConfig.buildOptimisation || false;
+      progress.log(`Version ${version.versionName || DEFAULT_VERSION_NAME} (${version.buildNumber}), ${applicationId}`, "info");
+      // Before any tooling runs: a second release in the same minute
+      // would overwrite the first one's bundle.
+      if (release) assertReleaseFolderFree(releaseOutputDir({
+        appRoot,
+        androidConfig,
+        version
+      }), [".aab"]);
       progress.complete("config");
+
+      // One-command dev: a debug build starts the dev server when
+      // nothing answers on its port, and waits until it does.
+      if (resolved.usesDevServer) {
+        progress.start("server");
+        await ensureDevServer({
+          cwd: appRoot,
+          log
+        });
+        progress.complete("server");
+      }
       progress.start("tools");
+      // Gradle and keytool get JDK 17 to 23 through this process's
+      // environment; no shell profile is involved. Missing pieces are
+      // installed after a yes (or --yes); the SDK path is read, never written.
+      const java = await ensureJava({
+        flags,
+        log
+      });
+      applyJavaHome(java);
+      progress.log(`Java ${java.version} from ${java.source}`, "info");
+      androidConfig.sdkPath = resolveSdkPath(androidConfig);
+      const adbPath = path.join(androidConfig.sdkPath, "platform-tools", "adb");
+
+      // Where a debug build runs: the emulator unless --device, or a
+      // person here picks a connected phone.
+      const last = getLastTarget("android", {
+        cwd: appRoot
+      });
+      let target = null;
+      const pickTarget = async () => chooseAndroidTarget({
+        wantDevice,
+        devices: listDevices(adbPath),
+        last,
+        isTTY: isInteractive(),
+        select,
+        emulatorHint: androidConfig.emulatorName || (last?.target === "emulator" ? last.avd : undefined)
+      });
+      // Without --device the choice comes first, so a picked phone
+      // skips the emulator install. With it, adb may need installing first.
+      if (!release && !wantDevice) target = await pickTarget();
+      const needEmulator = !release && !wantDevice && target?.target === "emulator";
+      const sdk = await ensureAndroidSdk({
+        sdkPath: androidConfig.sdkPath,
+        emulatorName: androidConfig.emulatorName,
+        preferredAvd: last?.target === "emulator" ? last.avd : undefined,
+        needEmulator,
+        flags,
+        log
+      });
+      if (sdk.installed.length) progress.log(`Installed ${sdk.installed.join(", ")}`, "success");
+      if (sdk.createdAvd) progress.log(`Created the "${sdk.emulatorName}" emulator`, "success");
+      if (sdk.emulatorName) androidConfig.emulatorName = sdk.emulatorName;
       const {
         ADB_PATH,
         EMULATOR_PATH
-      } = validateAndroidTools(androidConfig);
+      } = validateAndroidTools(androidConfig, {
+        needEmulator
+      });
+      if (!release && wantDevice) target = await pickTarget();
       progress.complete("tools");
-      if (buildType !== "release") {
+      if (release) {
+        progress.start("signing");
+        signing = await resolveAndroidSigning({
+          appRoot,
+          androidConfig,
+          isTTY: isInteractive(),
+          log,
+          // Named from the config as written: appId and appName
+          // overwrite packageName and android.appName in androidConfig.
+          legacyKeystorePath: legacyKeystorePath(resolved.config?.WEBVIEW_CONFIG?.android, {
+            cwd: appRoot
+          }),
+          commonName: androidConfig.appName
+        });
+        progress.log(`Upload key: ${signing.source} (alias ${signing.keyAlias})`, "info");
+        progress.complete("signing");
+      } else {
         progress.start("emulator");
-        const physicalDevice = await detectPhysicalDevice(ADB_PATH);
-        if (physicalDevice) {
-          progress.log(`Found physical device: ${physicalDevice.model} (${physicalDevice.id})`, "success");
-          const canInstallOnPhysical = await testPhysicalDeviceInstallation(ADB_PATH, physicalDevice.id);
-          if (canInstallOnPhysical) {
-            targetDevice = {
-              type: "physical",
-              id: physicalDevice.id,
-              model: physicalDevice.model
-            };
-            progress.log(`Using physical device: ${physicalDevice.model}`, "success");
-          } else {
-            progress.log("Physical device installation test failed, falling back to emulator", "warning");
-            targetDevice = await handleEmulatorSetup(ADB_PATH, EMULATOR_PATH, androidConfig);
-          }
+        if (target.target === "device") {
+          targetDevice = {
+            type: "physical",
+            id: target.serial,
+            model: target.model || target.serial
+          };
+          progress.log(`Using the connected phone ${targetDevice.model}`, "success");
+          saveLastTarget("android", {
+            target: "device",
+            serial: target.serial
+          }, {
+            cwd: appRoot
+          });
         } else {
-          targetDevice = await handleEmulatorSetup(ADB_PATH, EMULATOR_PATH, androidConfig);
+          const emulator = await handleEmulatorSetup(ADB_PATH, EMULATOR_PATH, androidConfig);
+          targetDevice = {
+            ...emulator,
+            id: emulator.serial
+          };
+          saveLastTarget("android", {
+            target: "emulator",
+            avd: emulator.name
+          }, {
+            cwd: appRoot
+          });
         }
         progress.complete("emulator");
-      } else {
-        progress.log("Skipping device setup for release build", "info");
       }
       progress.start("copyAssets");
       await copyBuildAssets(androidConfig, buildOptimisation);
       await copySplashscreenAssets();
       await copyOfflinePage();
       await copySplashHtml();
-      await copyIconAssets();
+      await copyIconAssets(androidConfig);
       await configureAppName(androidConfig);
       const pluginConfig = resolvePluginConfig(wvConfig);
       composeAndroidPlugins({
@@ -167,45 +350,81 @@ function createAndroidBuild(config) {
       progress.log(`Build optimization: ${buildOptimisation ? "Enabled" : "Disabled"}`, "info");
       syncAIPackageIfEnabled(wvConfig, progress);
       progress.complete("copyAssets");
-      let movedApkPath = null;
-      if (buildType === "release") {
+      const gradleOptions = {
+        configPath: resolved.resolvedConfigPath,
+        applicationId,
+        version
+      };
+      if (release) {
         progress.start("aab");
-        await buildSignedAAB(androidConfig);
+        const outputDir = releaseOutputDir({
+          appRoot,
+          androidConfig,
+          version
+        });
+        const names = releaseArtifactPaths(outputDir, androidConfig.newProjectName || androidConfig.appName || "app");
+        const aab = await buildSignedAAB(androidConfig, {
+          ...gradleOptions,
+          signing,
+          buildOptimisation,
+          finalAabPath: names.aab
+        });
+        artifactPath = aab?.finalAabPath || names.aab;
+        // The upload certificate beside the bundle (#508): Play asks
+        // for it when an upload key is registered or reset.
+        certificatePath = exportUploadCertificate(signing, names.certificate);
         progress.complete("aab");
-        movedApkPath = await moveApkToOutputPath(buildType, bop, androidConfig.appName);
       } else {
         progress.start("build");
-        await buildApp(ADB_PATH, androidConfig, buildOptimisation, targetDevice);
-        await launchApp(ADB_PATH, buildType, targetDevice);
+        await buildApp(androidConfig, buildOptimisation, targetDevice.id, gradleOptions);
+        // Debug builds load http://localhost:<port>; on the device that
+        // is the device itself. Forward every port the app uses to this
+        // machine, after the install and before the launch, every run.
+        const packageName = `${applicationId}.debug`;
+        const ports = devServerPorts(resolved.config, {
+          hmrPort: await readHmrPort({
+            cwd: appRoot
+          })
+        });
+        reachDevServer(adbRunner(ADB_PATH), targetDevice.id, packageName, ports);
+        progress.log(`Forwarded ports ${ports.join(", ")} to this machine (adb reverse)`, "info");
+        launchApp(ADB_PATH, targetDevice.id, packageName);
         progress.complete("build");
-        movedApkPath = await moveApkToOutputPath(buildType, bop, androidConfig.appName);
       }
 
       // Aligned key/value rows, matching the Config tree the setup
       // commands print. printTreeContent draws the branch glyphs.
       const deviceName = targetDevice?.type === "physical" ? targetDevice.model : `${androidConfig.emulatorName} emulator`;
-      const summaryItems = [{
+      const summaryItems = release ? [] : [{
         text: `device     ${deviceName}`,
         color: "gray"
       }];
-      if (movedApkPath) {
+      if (artifactPath) {
         summaryItems.push({
-          text: `artifact   ${displayPath(movedApkPath, process.cwd())}`,
+          text: `artifact   ${displayPath(artifactPath, appRoot)}`,
           color: "gray"
         });
       }
-      if (buildType === "release") {
+      if (certificatePath) {
         summaryItems.push({
-          text: `output     Signed AAB in build-output/`,
+          text: `cert       ${displayPath(certificatePath, appRoot)}`,
           color: "gray"
         });
       }
       summaryItems.push({
-        text: `build      ${buildType}${buildOptimisation ? ", optimised" : ""}`,
+        text: `version    ${version.versionName || DEFAULT_VERSION_NAME} (${version.buildNumber})`,
+        color: "gray"
+      });
+      summaryItems.push({
+        text: `build      ${release ? "release" : "debug"}${buildOptimisation ? ", optimised" : ""}`,
         color: "gray"
       });
       progress.printTreeContent("Build", summaryItems);
-      progress.summary(`Installed on ${deviceName}`, "Run catalyst start to serve the app");
+      if (release) {
+        progress.summary("Built the signed AAB", "Upload it to Google Play");
+      } else {
+        progress.summary(`Running on ${deviceName}`, "Edit your app; the dev server reloads it");
+      }
     } catch (error) {
       // Mark the step, then show what actually broke. The old handler
       // printed a generic "check your SDK" checklist here, which is
@@ -218,13 +437,19 @@ function createAndroidBuild(config) {
         code: "ANDROID-000"
       }));
       throw error;
+    } finally {
+      // The unpacked CI credentials and the resolved config are temp files.
+      signing?.cleanup();
+      resolved?.cleanup();
     }
   }
   async function buildAndroidForTesting() {
     try {
       const {
-        WEBVIEW_CONFIG: wvConfig
+        WEBVIEW_CONFIG: wvConfig,
+        cleanup
       } = await initializeConfig();
+      cleanup();
       const androidConfig = wvConfig.android;
       const buildOptimisation = !!androidConfig.buildOptimisation || false;
       await copyBuildAssets(androidConfig, buildOptimisation);

package/dist/native/buildAndroid/output.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.releaseArtifactPaths = releaseArtifactPaths;
+exports.releaseOutputDir = releaseOutputDir;
+var _path = _interopRequireDefault(require("path"));
+var _releaseOutput = require("../releaseOutput.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Where a release puts its files: build-output/android/<version>-<build>/
+ * in the app, or <android.outputPath>/<version>-<build>/ when the config
+ * sets an output path. One folder per build, so nothing is overwritten.
+ *
+ * @param {object} options
+ * @param {string} [options.appRoot]
+ * @param {{ outputPath?: string }} [options.androidConfig]
+ * @param {{ versionName?: string, buildNumber: number | string }} options.version - resolveNativeConfig().version
+ * @returns {string}
+ */
+function releaseOutputDir({
+  appRoot = process.cwd(),
+  androidConfig = {},
+  version
+}) {
+  const root = androidConfig.outputPath ? _path.default.resolve(appRoot, androidConfig.outputPath) : _path.default.join(appRoot, "build-output", "android");
+  return _path.default.join(root, (0, _releaseOutput.releaseFolderName)(version));
+}
+
+/**
+ * The release files in that folder: the bundle for Play and the upload
+ * certificate (PEM) that identifies the key that signed it.
+ *
+ * @param {string} dir - releaseOutputDir()
+ * @param {string} name - the app's name; made file-name safe here
+ */
+function releaseArtifactPaths(dir, name) {
+  return {
+    aab: _path.default.join(dir, `${(0, _releaseOutput.artifactBaseName)(name)}.aab`),
+    certificate: _path.default.join(dir, "upload_certificate.pem")
+  };
+}