html2apk 0.2.0 → 0.4.0

package/src/core/build-apk.js

@@ -5,14 +5,27 @@ const os = require("os");
 const path = require("path");
 const { resolveBuildOptions } = require("./config");
 const { validateEntryFile, validateRequiredOptions } = require("./validation");
-const { createCordovaProject, addAndroidPlatform, buildAndroid, addCordovaPlugin } = require("../cordova/project");
+const { createCordovaProject, addAndroidPlatform, buildAndroid, runAndroidDevice, addCordovaPlugin } = require("../cordova/project");
 const { writeConfigXml } = require("../cordova/config-xml");
 const { findApk } = require("../cordova/apk-finder");
-const { copyWebAssets, ensureDir, removePath, copyFile } = require("../utils/fs-extra");
+const { copyWebAssets, ensureDir, removePath, copyFile, copyDirectory } = require("../utils/fs-extra");
 const { createCommandRunner } = require("../utils/command-runner");
 const { installBridgePlugin } = require("../bridge/install-bridge");
 const { getRuntimeEnvironment } = require("../runtime-manager");
 
+const AUTO_THEME_SCRIPT_NAME = "html2apk-auto-theme.js";
+const ONESIGNAL_SCRIPT_NAME = "html2apk-onesignal.js";
+const ONESIGNAL_PLUGIN_PACKAGE = "onesignal-cordova-plugin";
+const DEFAULT_APP_ICON_NAME = "html2apk.png";
+
+function defaultAppIconPath() {
+  return path.resolve(__dirname, "..", "..", DEFAULT_APP_ICON_NAME);
+}
+
+function withDefaultAppIcon(assetPath) {
+  return String(assetPath || "").trim() || defaultAppIconPath();
+}
+
 function isRemoteAsset(assetPath) {
   return /^https?:\/\//i.test(String(assetPath || ""));
 }
@@ -34,6 +47,172 @@ function toCordovaPath(value) {
   return String(value).replace(/\\/g, "/");
 }
 
+function isAutoTheme(options) {
+  return String(options.themeMode || options.theme || "").toLowerCase() === "auto";
+}
+
+function oneSignalAppId(options) {
+  return String(options.oneSignalAppId || options.onesignalAppId || options.oneSignal?.appId || options.onesignal?.appId || "").trim();
+}
+
+function hasOneSignal(options) {
+  return oneSignalAppId(options).length > 0;
+}
+
+function scriptTag(scriptPath) {
+  return `<script src="${scriptPath}"></script>`;
+}
+
+async function injectCordovaRuntimeIntoHtml(htmlPath, scriptPath = "cordova.js") {
+  let html = await fs.readFile(htmlPath, "utf8");
+  if (/<script\b[^>]*\bsrc=["'][^"']*cordova\.js["'][^>]*>/i.test(html)) {
+    return false;
+  }
+
+  const tag = scriptTag(scriptPath);
+  if (/<head\b[^>]*>/i.test(html)) {
+    html = html.replace(/<head\b[^>]*>/i, (match) => `${match}\n  ${tag}`);
+  } else if (/<html\b[^>]*>/i.test(html)) {
+    html = html.replace(/<html\b[^>]*>/i, (match) => `${match}\n  ${tag}`);
+  } else {
+    html = `${tag}\n${html}`;
+  }
+
+  await fs.writeFile(htmlPath, html, "utf8");
+  return true;
+}
+
+async function installCordovaRuntimeScript(buildDir, options) {
+  const wwwDir = path.join(buildDir, "www");
+  const entryHtmlPath = path.resolve(wwwDir, options.entryFile || "index.html");
+  const scriptPath = toCordovaPath(path.relative(path.dirname(entryHtmlPath), path.join(wwwDir, "cordova.js"))) || "cordova.js";
+
+  if (!isInside(wwwDir, entryHtmlPath)) {
+    throw new Error(`Entry file must stay inside the Cordova www folder: ${options.entryFile}`);
+  }
+
+  return injectCordovaRuntimeIntoHtml(entryHtmlPath, scriptPath);
+}
+
+async function injectScriptIntoHtml(htmlPath, scriptPath) {
+  let html = await fs.readFile(htmlPath, "utf8");
+  if (html.includes(scriptPath)) {
+    return;
+  }
+
+  const tag = scriptTag(scriptPath);
+  if (/<\/body>/i.test(html)) {
+    html = html.replace(/<\/body>/i, `  ${tag}\n</body>`);
+  } else {
+    html = `${html}\n${tag}\n`;
+  }
+
+  await fs.writeFile(htmlPath, html, "utf8");
+}
+
+async function installAutoThemeScript(buildDir, options) {
+  if (!isAutoTheme(options)) {
+    return false;
+  }
+
+  const wwwDir = path.join(buildDir, "www");
+  const source = path.resolve(__dirname, "..", "templates", AUTO_THEME_SCRIPT_NAME);
+  const target = path.join(wwwDir, AUTO_THEME_SCRIPT_NAME);
+  const entryHtmlPath = path.resolve(wwwDir, options.entryFile || "index.html");
+  const scriptPath = toCordovaPath(path.relative(path.dirname(entryHtmlPath), target));
+
+  if (!isInside(wwwDir, entryHtmlPath)) {
+    throw new Error(`Entry file must stay inside the Cordova www folder: ${options.entryFile}`);
+  }
+
+  await copyFile(source, target);
+  await injectScriptIntoHtml(entryHtmlPath, scriptPath || AUTO_THEME_SCRIPT_NAME);
+  return true;
+}
+
+function jsString(value) {
+  return JSON.stringify(String(value || ""));
+}
+
+async function installOneSignalScript(buildDir, options) {
+  const appId = oneSignalAppId(options);
+  if (!appId) {
+    return false;
+  }
+
+  const wwwDir = path.join(buildDir, "www");
+  const source = path.resolve(__dirname, "..", "templates", ONESIGNAL_SCRIPT_NAME);
+  const target = path.join(wwwDir, ONESIGNAL_SCRIPT_NAME);
+  const entryHtmlPath = path.resolve(wwwDir, options.entryFile || "index.html");
+  const scriptPath = toCordovaPath(path.relative(path.dirname(entryHtmlPath), target));
+  const template = await fs.readFile(source, "utf8");
+
+  if (!isInside(wwwDir, entryHtmlPath)) {
+    throw new Error(`Entry file must stay inside the Cordova www folder: ${options.entryFile}`);
+  }
+
+  await fs.writeFile(
+    target,
+    template.replace("__HTML2APK_ONESIGNAL_APP_ID__", jsString(appId)),
+    "utf8"
+  );
+  await injectScriptIntoHtml(entryHtmlPath, scriptPath || ONESIGNAL_SCRIPT_NAME);
+  return true;
+}
+
+function removePluginPlatform(pluginXml, platformName) {
+  const pattern = new RegExp(`\\n?\\s*<platform name="${platformName}">[\\s\\S]*?\\n\\s*</platform>`, "i");
+  return pluginXml.replace(pattern, "");
+}
+
+async function prepareBundledPlugin(buildDir, packageName) {
+  const localPath = path.resolve(__dirname, "..", "..", "node_modules", packageName);
+  try {
+    await fs.access(path.join(localPath, "plugin.xml"));
+  } catch {
+    return packageName;
+  }
+
+  const destination = path.join(buildDir, `${packageName}-android`);
+  await removePath(destination);
+  await copyDirectory(localPath, destination, () => false);
+
+  const packageJsonPath = path.join(destination, "package.json");
+  const sourcePackage = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
+  const pluginPackage = {
+    name: sourcePackage.name,
+    version: sourcePackage.version,
+    description: sourcePackage.description,
+    license: sourcePackage.license,
+    main: sourcePackage.main || "dist/index.cjs",
+    types: sourcePackage.types,
+    cordova: {
+      id: sourcePackage.cordova?.id || packageName,
+      platforms: ["android"]
+    }
+  };
+  Object.keys(pluginPackage).forEach((key) => {
+    if (pluginPackage[key] === undefined) {
+      delete pluginPackage[key];
+    }
+  });
+  await fs.writeFile(packageJsonPath, `${JSON.stringify(pluginPackage, null, 2)}\n`, "utf8");
+
+  const pluginXmlPath = path.join(destination, "plugin.xml");
+  let pluginXml = await fs.readFile(pluginXmlPath, "utf8");
+  pluginXml = removePluginPlatform(pluginXml, "ios");
+  await fs.writeFile(pluginXmlPath, pluginXml, "utf8");
+
+  return destination;
+}
+
+function hasPlugin(plugins, packageName) {
+  return (plugins || []).some((plugin) => {
+    const text = String(plugin || "").replace(/\\/g, "/").toLowerCase();
+    return text === packageName || text.endsWith(`/node_modules/${packageName}`) || text.endsWith(`/${packageName}`);
+  });
+}
+
 async function copyCordovaAsset(projectRoot, buildDir, assetPath, assetName) {
   if (!assetPath || isRemoteAsset(assetPath)) {
     return assetPath;
@@ -99,11 +278,147 @@ function outputApkName(options) {
   return `${safeName}-${options.version}-${flavor}.apk`;
 }
 
+function parseAdbDevices(output) {
+  return String(output || "")
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line
+      && !/^list of devices/i.test(line)
+      && !/^\*/.test(line)
+      && !/^adb server/i.test(line))
+    .map((line) => {
+      const parts = line.split(/\s+/);
+      return {
+        id: parts[0],
+        status: parts[1] || "unknown"
+      };
+    })
+    .filter((device) => device.id);
+}
+
+function deviceTargetId(device) {
+  return device && device.id ? String(device.id) : "";
+}
+
+async function ensureUsbDebugDevice(runner) {
+  let result;
+  try {
+    result = await runner.run("adb", ["devices"]);
+  } catch (error) {
+    throw new Error("ADB nao foi encontrado. Instale Android platform-tools pelo ambiente do html2apk e tente novamente.");
+  }
+
+  const devices = parseAdbDevices(result.stdout);
+  const physicalDevices = devices.filter((device) => !/^emulator-/i.test(device.id));
+  const ready = physicalDevices.find((device) => device.status === "device");
+  if (ready) {
+    return ready;
+  }
+
+  if (physicalDevices.some((device) => device.status === "unauthorized")) {
+    throw new Error("Celular encontrado, mas a depuracao USB ainda nao foi autorizada. Desbloqueie o celular e aceite a chave RSA de depuracao USB.");
+  }
+
+  if (physicalDevices.some((device) => device.status === "offline")) {
+    throw new Error("Celular USB encontrado, mas esta offline. Reconecte o cabo USB, desbloqueie o celular e confirme a depuracao USB.");
+  }
+
+  throw new Error("Nenhum celular USB autorizado foi encontrado. Ative Opcoes do desenvolvedor > Depuracao USB, conecte o celular e aceite a permissao RSA.");
+}
+
+async function prepareCordovaProject(projectRoot, buildDir, options, runner, log) {
+  await createCordovaProject(buildDir, options, runner);
+  const cordovaOptions = { ...options };
+  const effectiveIcon = withDefaultAppIcon(options.icon);
+  const effectiveSplash = options.splash || effectiveIcon;
+  if (!String(options.icon || "").trim()) {
+    log("Icon: using the default html2apk icon.");
+  }
+  cordovaOptions.icon = await copyCordovaAsset(projectRoot, buildDir, effectiveIcon, "icon");
+  cordovaOptions.splash = await copyCordovaAsset(projectRoot, buildDir, effectiveSplash, "splash");
+  cordovaOptions.androidSplashScreenAnimatedIcon = toBuildAssetPath(buildDir, cordovaOptions.splash);
+  await writeConfigXml(path.join(buildDir, "config.xml"), cordovaOptions);
+  await copyWebAssets(path.resolve(projectRoot, options.webRoot || "."), path.join(buildDir, "www"), options, projectRoot);
+  if (await installCordovaRuntimeScript(buildDir, options)) {
+    log("Cordova runtime: injected cordova.js into the entry HTML.");
+  }
+  if (await installAutoThemeScript(buildDir, options)) {
+    log("Theme mode: auto (system bars follow the visible screen color).");
+  }
+  if (await installOneSignalScript(buildDir, options)) {
+    log("OneSignal: enabled for remote push notifications.");
+  }
+
+  const bridgePluginPath = await installBridgePlugin(buildDir);
+  await addCordovaPlugin(buildDir, bridgePluginPath, runner);
+
+  if (hasOneSignal(options) && !hasPlugin(options.plugins, ONESIGNAL_PLUGIN_PACKAGE)) {
+    await addCordovaPlugin(buildDir, await prepareBundledPlugin(buildDir, ONESIGNAL_PLUGIN_PACKAGE), runner);
+  }
+
+  for (const plugin of options.plugins) {
+    await addCordovaPlugin(buildDir, plugin, runner);
+  }
+
+  await addAndroidPlatform(buildDir, options, runner);
+}
+
+async function copyBuiltApk(projectRoot, buildDir, options) {
+  const apkPathInBuild = await findApk(buildDir, options);
+  const outputDir = path.resolve(projectRoot, options.outputDir || "dist");
+  await ensureDir(outputDir);
+
+  const apkPath = path.join(outputDir, outputApkName(options));
+  await copyFile(apkPathInBuild, apkPath);
+  return apkPath;
+}
+
+async function ensureBuiltDebugApk(buildDir, options, runner, log) {
+  try {
+    return await findApk(buildDir, options);
+  } catch {
+    log("USB debug: building debug APK for direct ADB install.");
+    await buildAndroid(buildDir, options, null, runner);
+    return findApk(buildDir, options);
+  }
+}
+
+async function installDebugApkWithAdb(buildDir, options, runner, device, log) {
+  const deviceId = deviceTargetId(device);
+  const apkPath = await ensureBuiltDebugApk(buildDir, options, runner, log);
+  log(`USB debug fallback: installing APK with ADB on ${deviceId}.`);
+
+  try {
+    await runner.run("adb", ["-s", deviceId, "install", "-r", "-d", apkPath]);
+  } catch (error) {
+    const output = `${error.stdout || ""}\n${error.stderr || ""}\n${error.message || ""}`;
+    if (/INSTALL_FAILED_UPDATE_INCOMPATIBLE/i.test(output)) {
+      throw new Error("O app ja esta instalado nesse celular com outra assinatura. Desinstale a versao antiga no Android e clique em Testar no USB novamente.");
+    }
+    throw error;
+  }
+
+  log(`USB debug fallback: opening ${options.packageId}.`);
+  await runner.run("adb", [
+    "-s",
+    deviceId,
+    "shell",
+    "monkey",
+    "-p",
+    options.packageId,
+    "-c",
+    "android.intent.category.LAUNCHER",
+    "1"
+  ]);
+
+  return apkPath;
+}
+
 async function buildApk(overrides = {}) {
   const onLog = typeof overrides.onLog === "function" ? overrides.onLog : null;
   const { projectRoot, configPath, options } = await resolveBuildOptions(overrides);
   validateRequiredOptions(options);
-  const { webRoot } = await validateEntryFile(projectRoot, options);
+  await validateEntryFile(projectRoot, options);
 
   const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "html2apk-"));
   const buildDir = path.join(tempRoot, "cordova-project");
@@ -129,31 +444,86 @@ async function buildApk(overrides = {}) {
       log(`JAVA_HOME: ${runtime.javaHome}`);
     }
 
-    await createCordovaProject(buildDir, options, runner);
-    const cordovaOptions = { ...options };
-    cordovaOptions.icon = await copyCordovaAsset(projectRoot, buildDir, options.icon, "icon");
-    cordovaOptions.splash = await copyCordovaAsset(projectRoot, buildDir, options.splash || options.icon, "splash");
-    cordovaOptions.androidSplashScreenAnimatedIcon = toBuildAssetPath(buildDir, cordovaOptions.splash);
-    await writeConfigXml(path.join(buildDir, "config.xml"), cordovaOptions);
-    await copyWebAssets(webRoot, path.join(buildDir, "www"), options, projectRoot);
+    await prepareCordovaProject(projectRoot, buildDir, options, runner, log);
+    const buildJsonPath = await createBuildJson(buildDir, options, projectRoot);
+    await buildAndroid(buildDir, options, buildJsonPath, runner);
 
-    const bridgePluginPath = await installBridgePlugin(buildDir);
-    await addCordovaPlugin(buildDir, bridgePluginPath, runner);
+    const apkPath = await copyBuiltApk(projectRoot, buildDir, options);
 
-    for (const plugin of options.plugins) {
-      await addCordovaPlugin(buildDir, plugin, runner);
+    if (!options.debug) {
+      await removePath(tempRoot);
+      tempCleaned = true;
     }
 
-    await addAndroidPlatform(buildDir, options, runner);
-    const buildJsonPath = await createBuildJson(buildDir, options, projectRoot);
-    await buildAndroid(buildDir, options, buildJsonPath, runner);
+    return {
+      apkPath,
+      buildDir: options.debug ? buildDir : null,
+      logs,
+      status: "success",
+      tempCleaned
+    };
+  } catch (error) {
+    log(`Error: ${error.message}`);
+    if (!options.debug) {
+      await removePath(tempRoot).catch(() => {});
+      tempCleaned = true;
+    } else {
+      log(`Debug mode enabled. Temporary build kept at: ${buildDir}`);
+    }
+
+    error.logs = logs;
+    error.buildDir = options.debug ? buildDir : null;
+    error.tempCleaned = tempCleaned;
+    error.status = "error";
+    throw error;
+  }
+}
+
+async function runDebugUsb(overrides = {}) {
+  const onLog = typeof overrides.onLog === "function" ? overrides.onLog : null;
+  const resolved = await resolveBuildOptions(overrides);
+  const projectRoot = resolved.projectRoot;
+  const configPath = resolved.configPath;
+  const options = {
+    ...resolved.options,
+    release: false
+  };
+  validateRequiredOptions(options);
+  await validateEntryFile(projectRoot, options);
+
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "html2apk-"));
+  const buildDir = path.join(tempRoot, "cordova-project");
+  const logs = [];
+  const runtime = getRuntimeEnvironment();
+  const runner = createCommandRunner({ logs, env: runtime.env, onLog });
+  let tempCleaned = false;
+
+  function log(line) {
+    logs.push(line);
+    if (onLog) {
+      onLog(line);
+    }
+  }
 
-    const apkPathInBuild = await findApk(buildDir, options);
-    const outputDir = path.resolve(projectRoot, options.outputDir || "dist");
-    await ensureDir(outputDir);
+  try {
+    log(`Project root: ${projectRoot}`);
+    log(configPath ? `Config: ${configPath}` : "Config: defaults only");
+    log("USB debug: checking connected Android device.");
+    const device = await ensureUsbDebugDevice(runner);
+    log(`USB debug device: ${device.id}`);
+
+    await prepareCordovaProject(projectRoot, buildDir, options, runner, log);
+    try {
+      await runAndroidDevice(buildDir, options, null, runner, deviceTargetId(device));
+    } catch (error) {
+      log("USB debug: Cordova run failed. Trying direct ADB install fallback.");
+      if (error.stdout || error.stderr) {
+        log([error.stdout, error.stderr].filter(Boolean).join("\n").trim().slice(-4000));
+      }
+      await installDebugApkWithAdb(buildDir, options, runner, device, log);
+    }
 
-    const apkPath = path.join(outputDir, outputApkName(options));
-    await copyFile(apkPathInBuild, apkPath);
+    const apkPath = await copyBuiltApk(projectRoot, buildDir, options);
 
     if (!options.debug) {
       await removePath(tempRoot);
@@ -163,8 +533,10 @@ async function buildApk(overrides = {}) {
     return {
       apkPath,
       buildDir: options.debug ? buildDir : null,
+      device,
       logs,
       status: "success",
+      usbDebug: true,
       tempCleaned
     };
   } catch (error) {
@@ -185,5 +557,9 @@ async function buildApk(overrides = {}) {
 }
 
 module.exports = {
-  buildApk
+  buildApk,
+  defaultAppIconPath,
+  injectCordovaRuntimeIntoHtml,
+  parseAdbDevices,
+  runDebugUsb
 };

package/src/core/config.js

@@ -71,6 +71,15 @@ function normalizeMinSdkVersion(value) {
     : DEFAULT_ANDROID_MIN_SDK_VERSION;
 }
 
+function normalizeThemeMode(value) {
+  return String(value || "").trim().toLowerCase() === "auto" ? "auto" : "fixed";
+}
+
+function normalizeThemeColor(value) {
+  const color = String(value || "").trim();
+  return /^#[0-9a-fA-F]{6}$/.test(color) ? color : "#126fff";
+}
+
 function normalizeOptions(options) {
   const normalized = { ...options };
 
@@ -85,6 +94,13 @@ function normalizeOptions(options) {
     : "default";
   normalized.debug = Boolean(normalized.debug);
   normalized.release = Boolean(normalized.release);
+  const themeColorText = String(normalized.themeColor || "").trim().toLowerCase();
+  const themeModeText = String(normalized.themeMode || "").trim().toLowerCase();
+  const themeText = String(normalized.theme || "").trim().toLowerCase();
+  normalized.themeMode = themeModeText === "auto" || themeText === "auto" || themeColorText === "auto" ? "auto" : "fixed";
+  normalized.theme = normalized.themeMode;
+  normalized.themeColor = normalizeThemeColor(themeColorText === "auto" ? normalized.backgroundColor : normalized.themeColor);
+  normalized.oneSignalAppId = normalizeOneSignalAppId(normalized.oneSignalAppId || normalized.onesignalAppId || normalized.oneSignal?.appId || normalized.onesignal?.appId);
   normalized.minSdkVersion = normalizeMinSdkVersion(normalized.minSdkVersion || normalized.androidMinSdkVersion);
   normalized.permissions = Array.isArray(normalized.permissions)
     ? normalized.permissions.map((permission) => String(permission).trim()).filter(Boolean)
@@ -92,12 +108,39 @@ function normalizeOptions(options) {
   normalized.plugins = Array.isArray(normalized.plugins)
     ? normalized.plugins.map((plugin) => String(plugin).trim()).filter(Boolean)
     : [];
+  normalized.deepLinks = normalizeDeepLinks(normalized.deepLinks);
   normalized.entryFile = normalized.entryFile || "index.html";
   normalized.webRoot = normalized.webRoot || ".";
 
   return normalized;
 }
 
+function normalizeOneSignalAppId(value) {
+  return String(value || "").trim();
+}
+
+function normalizeDeepLinks(value) {
+  const input = value && typeof value === "object" ? value : {};
+  const schemes = Array.isArray(input.schemes)
+    ? input.schemes.map((scheme) => String(scheme).trim()).filter(Boolean)
+    : [];
+  const appLinks = Array.isArray(input.appLinks)
+    ? input.appLinks
+      .filter((item) => item && typeof item === "object" && item.host)
+      .map((item) => ({
+        scheme: item.scheme || "https",
+        host: String(item.host).trim(),
+        paths: Array.isArray(item.paths) ? item.paths.map((pathItem) => String(pathItem).trim()).filter(Boolean) : [],
+        autoVerify: Boolean(item.autoVerify)
+      }))
+    : [];
+
+  return {
+    schemes,
+    appLinks
+  };
+}
+
 async function resolveBuildOptions(overrides = {}) {
   const projectRoot = path.resolve(overrides.projectRoot || process.cwd());
   const { config, configPath } = await loadProjectConfig(projectRoot);
@@ -118,5 +161,8 @@ module.exports = {
   resolveBuildOptions,
   mergeDeep,
   normalizeOptions,
-  normalizeMinSdkVersion
+  normalizeMinSdkVersion,
+  normalizeThemeMode,
+  normalizeOneSignalAppId,
+  normalizeDeepLinks
 };

package/src/core/defaults.js

@@ -31,6 +31,12 @@ function createDefaultOptions(projectRoot) {
     androidPlatform: "android@15.0.0",
     minSdkVersion: DEFAULT_ANDROID_MIN_SDK_VERSION,
     themeColor: "#126fff",
+    themeMode: "fixed",
+    oneSignalAppId: "",
+    deepLinks: {
+      schemes: [],
+      appLinks: []
+    },
     files: null,
     entryFile: "index.html",
     webRoot: ".",