catalyst-core 1.1.0 → 1.2.0-canary.2

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/MainActivity.kt

@@ -8,7 +8,9 @@ import android.view.MotionEvent
 import android.view.WindowManager
 import androidx.activity.OnBackPressedCallback
 import androidx.appcompat.app.AppCompatActivity
+import androidx.core.graphics.Insets
 import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
 
 import org.json.JSONObject
 import java.util.Properties
@@ -51,6 +53,7 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
     private var isHardwareAccelerationEnabled = false
     private var currentUrl: String = ""
     private var edgeToEdgeEnabled = false
+    private var backCallback: OnBackPressedCallback? = null
     private var latestSafeAreaInsets: SafeAreaInsets = SafeAreaInsets.ZERO
     private var splashOverlay: SplashOverlay? = null
 
@@ -77,6 +80,12 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
         }
     }
 
+    // targetSdk 35+ draws every window edge-to-edge on Android 15+, and Android 16 removed
+    // the opt-out. With edgeToEdge off in the config, the shell pads its root view by the
+    // system-bar insets instead, so content still sits between the bars.
+    private val systemDrawsEdgeToEdge: Boolean
+        get() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM
+
     private fun configureEdgeToEdge() {
         edgeToEdgeEnabled = EdgeToEdgeUtils.isEnabled(properties)
 
@@ -119,6 +128,16 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
         // Track inset changes (first layout, rotation, cutout, bar visibility); insets stay unconsumed
         var lastCachedInsets = cachedInsets
         ViewCompat.setOnApplyWindowInsetsListener(rootView) { view, insets ->
+            // edgeToEdge off on Android 15+: pad by the bars, and hand the children insets
+            // without them so the WebView doesn't inset its content a second time.
+            var childInsets = insets
+            if (!edgeToEdgeEnabled && systemDrawsEdgeToEdge) {
+                val barTypes = WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout()
+                val bars = insets.getInsets(barTypes)
+                view.setPadding(bars.left, bars.top, bars.right, bars.bottom)
+                childInsets = WindowInsetsCompat.Builder(insets).setInsets(barTypes, Insets.NONE).build()
+            }
+
             val updatedInsets = SafeAreaUtils.fromWindowInsets(
                 insets,
                 edgeToEdgeEnabled,
@@ -141,7 +160,7 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
                 lastCachedInsets = updatedInsets
             }
 
-            insets
+            childInsets
         }
         ViewCompat.requestApplyInsets(rootView)
     }
@@ -327,7 +346,12 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
         }
         
         // Initialize keyboard utility (pass webView so keyboard events reach WebPerfCollector)
-        keyboardUtil = KeyboardUtil(this, binding.webviewContainer, binding.webview, edgeToEdgeEnabled)
+        keyboardUtil = KeyboardUtil(
+            this,
+            binding.webviewContainer,
+            binding.webview,
+            edgeToEdgeEnabled || systemDrawsEdgeToEdge
+        )
         keyboardUtil.initialize()
         
         // Enable hardware acceleration for the window
@@ -381,7 +405,10 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
         setupSafeAreaHandling()
 
         // Setup back press handler (modern API)
-        onBackPressedDispatcher.addCallback(this, object : OnBackPressedCallback(true) {
+        // Android 16 turns predictive back on by default; OnBackPressedDispatcher is the
+        // supported path for it. The callback steps aside to let the system leave the app
+        // and is re-armed in onResume, since a task moved to the back keeps this activity.
+        backCallback = object : OnBackPressedCallback(true) {
             override fun handleOnBackPressed() {
                 if (customWebView.canGoBack()) {
                     if (BuildConfig.DEBUG) {
@@ -397,7 +424,7 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
                     onBackPressedDispatcher.onBackPressed()
                 }
             }
-        })
+        }.also { onBackPressedDispatcher.addCallback(this, it) }
         
         // Load URL based on environment and deep link data
         try {
@@ -471,6 +498,7 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
 
     override fun onResume() {
         super.onResume()
+        backCallback?.isEnabled = true
         customWebView.onResume()
     }
 

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/utils/KeyboardUtil.kt

@@ -18,6 +18,7 @@ class KeyboardUtil(
     private val activity: Activity,
     private val webViewContainer: View,
     private val webView: WebView? = null,
+    // True whenever the window draws behind the system bars: edgeToEdge on, or Android 15+.
     private val edgeToEdgeEnabled: Boolean = false,
 ) {
     private var originalHeight: Int = 0
@@ -81,9 +82,12 @@ class KeyboardUtil(
             val keyboardHeight = if (edgeToEdgeEnabled) {
                 // Edge-to-edge: rootView spans behind the system bars, so measure how far the
                 // visible frame's bottom sits above rootView's bottom (screen coords; works in split-screen)
+                // The parent's bottom padding is the navigation bar when MainActivity pads for
+                // system bars (edgeToEdge off on Android 15+); the keyboard covers that strip.
                 val location = IntArray(2)
                 rootView.getLocationOnScreen(location)
-                maxOf(0, (location[1] + rootView.height) - rect.bottom)
+                val parentBottomPadding = (webViewContainer.parent as? View)?.paddingBottom ?: 0
+                maxOf(0, (location[1] + rootView.height) - rect.bottom - parentBottomPadding)
             } else {
                 val visibleHeight = rect.height()
                 screenHeight - visibleHeight

package/dist/native/androidProject/app/src/test/java/io/yourname/androidproject/ConfigMappingTest.kt

@@ -26,6 +26,8 @@ class ConfigMappingTest {
 
         while (keys.hasNext()) {
             val key = keys.next()
+            // The release override block is merged by the CLI, never shipped as-is.
+            if (prefix.isEmpty() && key == "release") continue
             val value = jsonObj.opt(key)
             val fullKey = if (prefix.isEmpty()) key else "$prefix.$key"
 
@@ -232,6 +234,29 @@ class ConfigMappingTest {
         assertEquals("3005", properties.getProperty("port"))
     }
 
+    @Test
+    fun `test top-level release override block is not flattened`() {
+        val json = JSONObject().apply {
+            put("LOCAL_IP", "192.168.1.100")
+            put("release", JSONObject().apply {
+                put("LOCAL_IP", "www.example.com")
+                put("allowPrivateHost", false)
+            })
+            put("android", JSONObject().apply {
+                put("release", "kept")
+            })
+        }
+
+        val properties = Properties()
+        extractProperties(json, properties)
+
+        assertEquals("192.168.1.100", properties.getProperty("LOCAL_IP"))
+        assertNull(properties.getProperty("release.LOCAL_IP"))
+        assertNull(properties.getProperty("release.allowPrivateHost"))
+        // Only the top-level key is reserved
+        assertEquals("kept", properties.getProperty("android.release"))
+    }
+
     // ============================================================
     // Test Category 2: Build Type Handling (4 tests)
     // ============================================================

package/dist/native/androidSetup.js

@@ -4,154 +4,63 @@ var _fs = _interopRequireDefault(require("fs"));
 var _path = _interopRequireDefault(require("path"));
 var _child_process = require("child_process");
 var _utils = require("./utils.js");
+var _androidToolchain = require("./androidToolchain.js");
+var _localState = require("./localState.js");
 var _terminalProgress = _interopRequireDefault(require("./terminalProgress.js"));
-var _setupServer = require("./setupServer.js");
+var _diagnostic = require("../cli/diagnostic.js");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// setupEmulator:android installs what an Android build needs (JDK, SDK
+// packages, an emulator) and starts the emulator. It changes nothing in the
+// app: config/config.json is read for sdkPath and emulatorName when they are
+// set, never written. buildApp:android does the same checks itself, so this
+// command is optional.
+
 const catalystCorePath = _path.default.dirname(require.resolve("catalyst-core/package.json"));
 const pwd = _path.default.join(catalystCorePath, "dist/native");
-const configPath = `${process.env.PWD}/config/config.json`;
+const configPath = _path.default.join(process.cwd(), "config", "config.json");
+const flags = (0, _utils.parseNativeArgs)(process.argv.slice(2));
 
 // Sentence case, verb first: these read as a sequence of actions, not as
 // headings.
 const steps = {
-  java: "Check Java environment",
-  config: "Initialize configuration",
+  java: "Check Java (JDK 17 to 23)",
+  sdk: "Set up the Android SDK",
   androidTools: "Validate Android tools",
-  emulator: "Configure Android emulator",
-  properties: "Update local.properties",
-  saveConfig: "Save configuration",
-  setupServer: "Set up server"
+  emulator: "Start the Android emulator",
+  properties: "Update local.properties"
 };
 const progress = new _terminalProgress.default(steps, "catalyst setupEmulator", {
   subject: "android"
 });
-async function checkJavaInstallation() {
-  try {
-    (0, _utils.runCommand)("java -version");
-    (0, _utils.runCommand)("javac -version");
-    return true;
-  } catch (error) {
-    progress.log("Java installation not found or not properly configured", "error");
-    return false;
-  }
-}
-async function installJava() {
-  progress.log("Installing Java (Zulu JDK 17)...");
-  try {
-    try {
-      (0, _utils.runCommand)("brew --version");
-    } catch (error) {
-      throw new Error("Homebrew is required but not installed. Please install Homebrew first.");
-    }
-    const javaHome = "/Library/Java/JavaVirtualMachines/zulu-17.jdk/Contents/Home";
-
-    // Try installing Java
-    try {
-      await (0, _utils.runCommand)("brew install --cask zulu@17");
-    } catch (error) {
-      if (error.message.includes("already installed")) {
-        progress.log("Attempting to reinstall Java...", "info");
-        try {
-          await (0, _utils.runCommand)("brew reinstall --cask zulu@17");
-        } catch (reinstallError) {
-          throw new Error(`Failed to reinstall Java: ${reinstallError.message}. Please run 'brew reinstall --cask zulu@17' manually.`);
-        }
-      } else {
-        throw error;
-      }
-    }
-
-    // Verify Java installation
-    if (!_fs.default.existsSync(javaHome)) {
-      throw new Error(`Java installation not found at ${javaHome}. Please verify the installation manually.`);
-    }
-
-    // Set up environment variables
-    const homeDir = process.env.HOME;
-    const shellProfile = `${homeDir}/.zshrc`;
-    const exportCommand = `\n# Java Configuration\nexport JAVA_HOME=${javaHome}\nexport PATH=$JAVA_HOME/bin:$PATH\n`;
-    try {
-      _fs.default.appendFileSync(shellProfile, exportCommand);
-    } catch (error) {
-      throw new Error(`Failed to update ${shellProfile}: ${error.message}. Please add the following lines manually:\n${exportCommand}`);
-    }
+const log = (message, type = "info") => progress.log(message, type);
 
-    // Set for current process
-    process.env.JAVA_HOME = javaHome;
-    process.env.PATH = `${javaHome}/bin:${process.env.PATH}`;
-
-    // Verify Java configuration
-    try {
-      const javaVersion = (0, _utils.runCommand)("java -version");
-      progress.log("Installed Java 17 (Zulu)", "info");
-      progress.log(`Java Version: ${javaVersion}`, "info");
-      progress.log(`IMPORTANT: Please run the following commands to complete setup:`, "warning");
-      progress.log(`1. source ${shellProfile}`, "note");
-      progress.log(`2. echo $JAVA_HOME`, "note");
-      return true;
-    } catch (error) {
-      throw new Error(`Java installation verified but environment not configured. Please run:\n1. source ${shellProfile}\n2. echo $JAVA_HOME`);
-    }
-  } catch (error) {
-    progress.log(error.message, "error");
-    progress.log("Manual Setup Instructions:", "note");
-    progress.log("1. Run: brew reinstall --cask zulu@17", "note");
-    progress.log("2. Add to ~/.zshrc:", "note");
-    progress.log("   export JAVA_HOME=/Library/Java/JavaVirtualMachines/zulu-17.jdk/Contents/Home", "note");
-    progress.log("   export PATH=$JAVA_HOME/bin:$PATH", "note");
-    progress.log("3. Run: source ~/.zshrc", "note");
-    throw error;
-  }
-}
+/**
+ * A usable JDK for this process and every tool it starts (Gradle, sdkmanager,
+ * avdmanager). JAVA_HOME is set here only; no shell profile is edited.
+ */
 async function validateJavaEnvironment() {
   progress.start("java");
-  const hasJava = await checkJavaInstallation();
-  if (!hasJava) {
-    progress.log("Java installation required. Starting installation process...");
-    const javaInstalled = await installJava();
-    if (!javaInstalled) {
-      progress.fail("java", "Failed to set up Java environment");
-      throw new Error("Failed to set up Java environment");
-    }
-  }
+  const java = await (0, _androidToolchain.ensureJava)({
+    flags,
+    log
+  });
+  (0, _androidToolchain.applyJavaHome)(java);
+  progress.log(`Java ${java.version} from ${java.source} (${java.home})`, "info");
   progress.complete("java");
 }
-async function initializeConfig() {
-  const configFile = _fs.default.readFileSync(configPath, "utf8");
-  const config = JSON.parse(configFile);
-  const {
-    WEBVIEW_CONFIG
-  } = config;
-  if (!WEBVIEW_CONFIG || Object.keys(WEBVIEW_CONFIG).length === 0) {
-    progress.log("WebView Config missing in " + configPath, "error");
-    process.exit(1);
-  }
-  if (!WEBVIEW_CONFIG.android) {
-    WEBVIEW_CONFIG.android = {};
-  }
-  return {
-    WEBVIEW_CONFIG
-  };
-}
-async function saveConfig(newConfig) {
+
+/** WEBVIEW_CONFIG.android from config.json, or {} when there is none. Read only. */
+function readAndroidConfig() {
   try {
-    const existingConfigFile = _fs.default.readFileSync(configPath, "utf8");
-    const existingConfig = JSON.parse(existingConfigFile);
-    const updatedConfig = {
-      ...existingConfig,
-      WEBVIEW_CONFIG: {
-        ...existingConfig.WEBVIEW_CONFIG,
-        android: newConfig.WEBVIEW_CONFIG.android
-      }
-    };
-    _fs.default.writeFileSync(configPath, JSON.stringify(updatedConfig, null, 2));
-  } catch (error) {
-    progress.log("Failed to save configuration: " + error.message, "error");
-    process.exit(1);
+    const config = JSON.parse(_fs.default.readFileSync(configPath, "utf8"));
+    const android = config?.WEBVIEW_CONFIG?.android;
+    return android && typeof android === "object" ? android : {};
+  } catch {
+    return {};
   }
 }
 function validateAndroidTools(androidConfig) {
-  const ANDROID_SDK = (0, _utils.expandHome)(androidConfig.sdkPath);
+  const ANDROID_SDK = androidConfig.sdkPath;
   const EMULATOR_PATH = `${ANDROID_SDK}/emulator/emulator`;
   const ADB_PATH = `${ANDROID_SDK}/platform-tools/adb`;
   if (!ANDROID_SDK) {
@@ -166,7 +75,7 @@ function validateAndroidTools(androidConfig) {
     throw new Error(`ADB not found at: ${ADB_PATH}`);
   }
   try {
-    (0, _utils.runCommand)(`${ADB_PATH} version`);
+    (0, _utils.runFile)(ADB_PATH, ["version"]);
   } catch (error) {
     throw new Error(`ADB is not working properly: ${error.message}`);
   }
@@ -174,12 +83,12 @@ function validateAndroidTools(androidConfig) {
     throw new Error(`Emulator not found at: ${EMULATOR_PATH}`);
   }
   try {
-    (0, _utils.runCommand)(`${EMULATOR_PATH} -version`);
+    (0, _utils.runFile)(EMULATOR_PATH, ["-version"]);
   } catch (error) {
     throw new Error(`Emulator is not working properly: ${error.message}`);
   }
   try {
-    const avdOutput = (0, _utils.runCommand)(`${EMULATOR_PATH} -list-avds`);
+    const avdOutput = (0, _utils.runFile)(EMULATOR_PATH, ["-list-avds"]);
     if (!avdOutput.includes(androidConfig.emulatorName)) {
       throw new Error(`Specified emulator "${androidConfig.emulatorName}" not found in available AVDs`);
     }
@@ -194,7 +103,7 @@ function validateAndroidTools(androidConfig) {
 }
 async function checkEmulator(ADB_PATH) {
   try {
-    const devices = (0, _utils.runCommand)(`${ADB_PATH} devices`, {
+    const devices = (0, _utils.runFile)(ADB_PATH, ["devices"], {
       timeout: 15000
     });
     return devices.includes("emulator");
@@ -215,75 +124,72 @@ async function startEmulator(EMULATOR_PATH, androidConfig) {
   });
   child.unref();
 }
-async function updateLocalProperties(sdkPath) {
+function updateLocalProperties(sdkPath) {
   progress.start("properties");
-  try {
-    (0, _utils.runCommand)(`cd ${pwd}/androidProject && ./gradlew updateSdkPath -PsdkPath="${sdkPath}"`);
-    progress.complete("properties");
-  } catch (error) {
-    progress.fail("properties", `Failed to update local.properties: ${error.message}`);
-    throw error;
-  }
+  (0, _utils.ensureLocalProperties)(`${pwd}/androidProject`, sdkPath);
+  progress.complete("properties");
 }
 async function setupAndroidEnvironment() {
   try {
     await validateJavaEnvironment();
-    progress.start("config");
-    await initializeConfig();
-    const config = await (0, _utils.validateAndCompleteConfig)("android", configPath);
-    progress.complete("config");
+    progress.start("sdk");
+    const fileAndroid = readAndroidConfig();
+    const sdkPath = (0, _androidToolchain.resolveSdkPath)(fileAndroid);
+    const last = (0, _localState.getLastTarget)("android");
+    const sdk = await (0, _androidToolchain.ensureAndroidSdk)({
+      sdkPath,
+      emulatorName: fileAndroid.emulatorName,
+      preferredAvd: last?.target === "emulator" ? last.avd : undefined,
+      flags,
+      log
+    });
+    if (sdk.installed.length) progress.log(`Installed ${sdk.installed.join(", ")}`, "success");
+    if (sdk.createdAvd) progress.log(`Created the "${sdk.emulatorName}" emulator`, "success");
+    progress.complete("sdk");
+    const androidConfig = {
+      ...fileAndroid,
+      sdkPath,
+      emulatorName: sdk.emulatorName
+    };
     progress.start("androidTools");
     const {
       EMULATOR_PATH,
       ADB_PATH
-    } = validateAndroidTools(config.android);
+    } = validateAndroidTools(androidConfig);
     progress.complete("androidTools");
     progress.start("emulator");
     const emulatorRunning = await checkEmulator(ADB_PATH);
     if (!emulatorRunning) {
       progress.log("No emulator running, attempting to start one...");
-      await startEmulator(EMULATOR_PATH, config.android);
+      await startEmulator(EMULATOR_PATH, androidConfig);
     } else {
       progress.log("Emulator already running", "info");
     }
     progress.complete("emulator");
-    if (config.android?.sdkPath) {
-      await updateLocalProperties((0, _utils.expandHome)(config.android.sdkPath));
-    }
-    progress.start("saveConfig");
-    await saveConfig({
-      WEBVIEW_CONFIG: config
-    });
-    progress.complete("saveConfig");
-    progress.start("setupServer");
-    await (0, _setupServer.setupServer)(configPath, message => progress.log(message, "info"));
-    progress.complete("setupServer");
+    updateLocalProperties(sdkPath);
 
-    // What was configured, not what the keys mean -- the explanation
+    // What this machine uses, not what the keys mean: the explanation
     // belongs in the docs, not in every successful run's transcript.
-    // validateAndCompleteConfig returns { port, android: {...} } -- flat,
-    // not nested under WEBVIEW_CONFIG.
-    const androidCfg = config.android || {};
-    progress.printTreeContent("Config  config/config.json", [{
-      text: `port           ${config.port ?? ""}`,
-      color: "gray"
-    }, {
-      text: `buildType      ${androidCfg.buildType ?? ""}`,
-      color: "gray"
-    }, {
-      text: `sdkPath        ${androidCfg.sdkPath ?? ""}`,
+    progress.printTreeContent("Android", [{
+      text: `sdk        ${sdkPath}`,
       color: "gray"
     }, {
-      text: `emulatorName   ${androidCfg.emulatorName ?? ""}`,
+      text: `emulator   ${sdk.emulatorName}`,
       color: "gray"
     }]);
     progress.summary("Ready", "Run catalyst buildApp:android to install the app");
     process.exit(0);
   } catch (error) {
+    // A coded error (ANDROID-007, NATIVE-005, ...) gets the full diagnostic:
+    // code, hint and doc link. Anything else keeps the one-line failure.
+    const coded = /^[A-Z]+-\d{3}$/.test(String(error?.code || ""));
     if (progress.currentStep) {
-      progress.fail(progress.currentStep.id, error.message);
+      progress.fail(progress.currentStep.id, coded ? undefined : error.message);
     }
-    progress.hint(error.hint);
+    if (coded) process.stderr.write((0, _diagnostic.buildFailure)({
+      error,
+      stage: "Android setup"
+    }));else progress.hint(error.hint);
     process.exit(1);
   }
 }