html2apk 0.1.0

package/src/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+const { buildApk } = require("./core/build-apk");
+const { loadProjectConfig, resolveBuildOptions } = require("./core/config");
+const { runDoctor } = require("./runtime-manager/doctor");
+
+module.exports = {
+  buildApk,
+  loadProjectConfig,
+  resolveBuildOptions,
+  runDoctor
+};

package/src/runtime-manager/doctor.js

@@ -0,0 +1,164 @@
+"use strict";
+
+const fs = require("fs/promises");
+const os = require("os");
+const path = require("path");
+const { createCommandRunner } = require("../utils/command-runner");
+const {
+  REQUIRED_ANDROID_BUILD_TOOLS,
+  REQUIRED_ANDROID_PLATFORM,
+  getRuntimeEnvironment
+} = require("./index");
+
+async function pathExists(targetPath) {
+  if (!targetPath) {
+    return false;
+  }
+
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function checkWritableDirectory(targetPath) {
+  try {
+    await fs.mkdir(targetPath, { recursive: true });
+    const probe = path.join(targetPath, `.html2apk-doctor-${Date.now()}.tmp`);
+    await fs.writeFile(probe, "ok");
+    await fs.rm(probe, { force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function checkCommand(name, args, env) {
+  const logs = [];
+  const runner = createCommandRunner({ logs, env });
+  try {
+    const result = await runner.run(name, args);
+    return {
+      name,
+      ok: true,
+      details: (result.stdout || result.stderr || "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean)[0] || "found"
+    };
+  } catch (error) {
+    const output = [error.stderr, error.stdout]
+      .filter(Boolean)
+      .join("\n")
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean)[0];
+
+    return {
+      name,
+      ok: false,
+      details: output || error.message
+    };
+  }
+}
+
+async function runDoctor(options = {}) {
+  const runtime = getRuntimeEnvironment();
+  const checks = [];
+  const env = runtime.env;
+  const projectRoot = options.projectRoot || process.cwd();
+
+  checks.push(await checkCommand("java", ["-version"], env));
+  checks.push(await checkCommand("javac", ["-version"], env));
+  checks.push(await checkCommand("gradle", ["-v"], env));
+  checks.push(await checkCommand("cordova", ["--version"], env));
+
+  const androidSdk = runtime.androidSdk;
+  const sdkManager = runtime.cmdlineTools
+    ? path.join(runtime.cmdlineTools, process.platform === "win32" ? "sdkmanager.bat" : "sdkmanager")
+    : null;
+
+  checks.push({
+    name: "ANDROID_HOME or ANDROID_SDK_ROOT",
+    ok: Boolean(androidSdk),
+    details: androidSdk || "set ANDROID_HOME to your Android SDK directory"
+  });
+
+  checks.push({
+    name: "Android platform-tools",
+    ok: await pathExists(runtime.platformTools),
+    details: runtime.platformTools || "install Android SDK platform-tools"
+  });
+
+  checks.push({
+    name: "Android cmdline-tools",
+    ok: await pathExists(runtime.cmdlineTools),
+    details: runtime.cmdlineTools || "install Android command line tools"
+  });
+
+  checks.push({
+    name: "Android sdkmanager",
+    ok: await pathExists(sdkManager),
+    details: sdkManager || "install Android command line tools"
+  });
+
+  checks.push({
+    name: `Android build-tools ${REQUIRED_ANDROID_BUILD_TOOLS}`,
+    ok: await pathExists(runtime.requiredBuildTools),
+    details: runtime.requiredBuildTools || `install build-tools;${REQUIRED_ANDROID_BUILD_TOOLS} with sdkmanager`
+  });
+
+  checks.push({
+    name: `Android platform ${REQUIRED_ANDROID_PLATFORM}`,
+    ok: await pathExists(runtime.requiredPlatform),
+    details: runtime.requiredPlatform || `install platforms;${REQUIRED_ANDROID_PLATFORM} with sdkmanager`
+  });
+
+  checks.push({
+    name: "Project directory writable",
+    ok: await checkWritableDirectory(projectRoot),
+    details: projectRoot
+  });
+
+  checks.push({
+    name: "Temporary directory writable",
+    ok: await checkWritableDirectory(os.tmpdir()),
+    details: os.tmpdir()
+  });
+
+  const ok = checks.every((check) => check.ok);
+  return {
+    ok,
+    checks,
+    runtime,
+    suggestions: [
+      "Install a supported JDK and set JAVA_HOME.",
+      "Install Android Studio or Android command line tools.",
+      "Set ANDROID_HOME or ANDROID_SDK_ROOT, or install the SDK in the platform default path.",
+      "Install Cordova globally with: npm install -g cordova.",
+      `Install Android platform/build packages with: sdkmanager "platform-tools" "platforms;${REQUIRED_ANDROID_PLATFORM}" "build-tools;${REQUIRED_ANDROID_BUILD_TOOLS}".`
+    ]
+  };
+}
+
+function formatDoctorReport(report) {
+  const lines = ["html2apk doctor", ""];
+  for (const check of report.checks) {
+    lines.push(`${check.ok ? "OK " : "ERR"} ${check.name}`);
+    lines.push(`    ${check.details}`);
+  }
+
+  lines.push("");
+  lines.push(report.ok ? "Environment looks ready." : "Missing requirements:");
+  if (!report.ok) {
+    for (const suggestion of report.suggestions) {
+      lines.push(`- ${suggestion}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+module.exports = {
+  runDoctor,
+  formatDoctorReport
+};

package/src/runtime-manager/index.js

@@ -0,0 +1,190 @@
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const REQUIRED_ANDROID_PLATFORM = "android-36";
+const REQUIRED_ANDROID_BUILD_TOOLS = "36.0.0";
+
+function pathExists(targetPath) {
+  try {
+    return Boolean(targetPath) && fs.existsSync(targetPath);
+  } catch {
+    return false;
+  }
+}
+
+function unique(items) {
+  return Array.from(new Set(items.filter(Boolean)));
+}
+
+function pathDelimiter() {
+  return process.platform === "win32" ? ";" : ":";
+}
+
+function defaultAndroidSdkCandidates(env = process.env) {
+  const home = os.homedir();
+  const candidates = [
+    env.ANDROID_HOME,
+    env.ANDROID_SDK_ROOT
+  ];
+
+  if (process.platform === "win32") {
+    candidates.push(
+      env.LOCALAPPDATA ? path.join(env.LOCALAPPDATA, "Android", "Sdk") : null,
+      home ? path.join(home, "AppData", "Local", "Android", "Sdk") : null
+    );
+  } else if (process.platform === "darwin") {
+    candidates.push(
+      home ? path.join(home, "Library", "Android", "sdk") : null,
+      "/Library/Android/sdk"
+    );
+  } else {
+    candidates.push(
+      home ? path.join(home, "Android", "Sdk") : null,
+      "/opt/android-sdk",
+      "/usr/local/share/android-sdk"
+    );
+  }
+
+  return unique(candidates);
+}
+
+function getAndroidSdkPath(env = process.env) {
+  return defaultAndroidSdkCandidates(env).find(pathExists) || env.ANDROID_HOME || env.ANDROID_SDK_ROOT || null;
+}
+
+function getJavaHome(env = process.env) {
+  if (env.JAVA_HOME && pathExists(env.JAVA_HOME)) {
+    return env.JAVA_HOME;
+  }
+
+  const candidates = [];
+  if (process.platform === "win32") {
+    candidates.push(
+      latestSubdir(path.join(process.env.ProgramFiles || "C:\\Program Files", "Eclipse Adoptium")),
+      latestSubdir(path.join(process.env.ProgramFiles || "C:\\Program Files", "Java"))
+    );
+  } else if (process.platform === "darwin") {
+    candidates.push(
+      latestSubdir("/Library/Java/JavaVirtualMachines")
+    );
+  } else {
+    candidates.push(
+      latestSubdir("/usr/lib/jvm"),
+      latestSubdir("/usr/java")
+    );
+  }
+
+  return candidates.find(pathExists) || env.JAVA_HOME || null;
+}
+
+function latestSubdir(parent) {
+  if (!pathExists(parent)) {
+    return null;
+  }
+
+  const entries = fs.readdirSync(parent, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
+
+  return entries.length ? path.join(parent, entries[0]) : null;
+}
+
+function androidSdkPaths(androidSdk) {
+  if (!androidSdk) {
+    return [];
+  }
+
+  return unique([
+    path.join(androidSdk, "platform-tools"),
+    path.join(androidSdk, "emulator"),
+    path.join(androidSdk, "cmdline-tools", "latest", "bin"),
+    path.join(androidSdk, "tools", "bin"),
+    latestSubdir(path.join(androidSdk, "build-tools"))
+  ]);
+}
+
+function getGradleHome(env = process.env) {
+  if (env.GRADLE_HOME && pathExists(env.GRADLE_HOME)) {
+    return env.GRADLE_HOME;
+  }
+
+  const candidates = [];
+  if (process.platform === "win32") {
+    candidates.push(
+      latestSubdir(path.join(env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local"), "html2apk", "gradle")),
+      latestSubdir(path.join(process.env.ProgramFiles || "C:\\Program Files", "Gradle"))
+    );
+  } else {
+    candidates.push(
+      latestSubdir(path.join(os.homedir(), ".html2apk", "gradle")),
+      latestSubdir("/opt/gradle")
+    );
+  }
+
+  return candidates.find(pathExists) || env.GRADLE_HOME || null;
+}
+
+function prependToPath(env, entries) {
+  const key = Object.prototype.hasOwnProperty.call(env, "Path") ? "Path" : "PATH";
+  const current = env[key] || "";
+  env[key] = unique([...entries, ...current.split(pathDelimiter())]).join(pathDelimiter());
+}
+
+function getRuntimeEnvironment(env = process.env) {
+  const androidSdk = getAndroidSdkPath(env);
+  const javaHome = getJavaHome(env);
+  const gradleHome = getGradleHome(env);
+  const nextEnv = { ...env };
+  const pathEntries = [];
+
+  if (androidSdk) {
+    nextEnv.ANDROID_HOME = androidSdk;
+    nextEnv.ANDROID_SDK_ROOT = androidSdk;
+    pathEntries.push(...androidSdkPaths(androidSdk));
+  }
+
+  if (javaHome) {
+    nextEnv.JAVA_HOME = javaHome;
+    pathEntries.push(path.join(javaHome, "bin"));
+  }
+
+  if (gradleHome) {
+    nextEnv.GRADLE_HOME = gradleHome;
+    pathEntries.push(path.join(gradleHome, "bin"));
+  }
+
+  prependToPath(nextEnv, pathEntries);
+
+  return {
+    env: nextEnv,
+    javaHome,
+    gradleHome,
+    androidSdk,
+    platformTools: androidSdk ? path.join(androidSdk, "platform-tools") : null,
+    cmdlineTools: androidSdk ? path.join(androidSdk, "cmdline-tools", "latest", "bin") : null,
+    buildTools: androidSdk ? latestSubdir(path.join(androidSdk, "build-tools")) : null,
+    requiredBuildTools: androidSdk ? path.join(androidSdk, "build-tools", REQUIRED_ANDROID_BUILD_TOOLS) : null,
+    platforms: androidSdk ? path.join(androidSdk, "platforms") : null,
+    requiredPlatform: androidSdk ? path.join(androidSdk, "platforms", REQUIRED_ANDROID_PLATFORM) : null,
+    pathEntries
+  };
+}
+
+function prepareBuildEnvironment(env = process.env) {
+  return getRuntimeEnvironment(env).env;
+}
+
+module.exports = {
+  REQUIRED_ANDROID_BUILD_TOOLS,
+  REQUIRED_ANDROID_PLATFORM,
+  defaultAndroidSdkCandidates,
+  getAndroidSdkPath,
+  getGradleHome,
+  getJavaHome,
+  getRuntimeEnvironment,
+  prepareBuildEnvironment
+};

package/src/templates/cordova-plugin-html2apk-bridge/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "cordova-plugin-html2apk-bridge",
+  "version": "0.1.0",
+  "description": "Initial native bridge used by html2apk generated apps.",
+  "cordova": {
+    "id": "cordova-plugin-html2apk-bridge",
+    "platforms": [
+      "android"
+    ]
+  },
+  "keywords": [
+    "cordova",
+    "html2apk"
+  ],
+  "license": "MIT"
+}

package/src/templates/cordova-plugin-html2apk-bridge/plugin.xml

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<plugin id="cordova-plugin-html2apk-bridge" version="0.1.0" xmlns="http://apache.org/cordova/ns/plugins/1.0" xmlns:android="http://schemas.android.com/apk/res/android">
+  <name>Html2ApkBridge</name>
+
+  <js-module src="www/html2apk-bridge.js" name="Html2ApkBridge">
+    <clobbers target="Html2ApkNative" />
+  </js-module>
+
+  <platform name="android">
+    <config-file target="res/xml/config.xml" parent="/*">
+      <feature name="Html2ApkBridge">
+        <param name="android-package" value="dev.html2apk.bridge.Html2ApkBridge" />
+      </feature>
+    </config-file>
+
+    <config-file target="AndroidManifest.xml" parent="/manifest">
+      <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+      <uses-permission android:name="android.permission.VIBRATE" />
+      <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM" />
+      <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+    </config-file>
+
+    <config-file target="AndroidManifest.xml" parent="/manifest/application">
+      <receiver android:name="dev.html2apk.bridge.NotificationReceiver" android:exported="false" />
+      <receiver android:name="dev.html2apk.bridge.BootReceiver" android:enabled="true" android:exported="true">
+        <intent-filter>
+          <action android:name="android.intent.action.BOOT_COMPLETED" />
+          <action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
+        </intent-filter>
+      </receiver>
+    </config-file>
+
+    <source-file src="src/android/Html2ApkBridge.java" target-dir="app/src/main/java/dev/html2apk/bridge" />
+    <source-file src="src/android/NotificationReceiver.java" target-dir="app/src/main/java/dev/html2apk/bridge" />
+    <source-file src="src/android/BootReceiver.java" target-dir="app/src/main/java/dev/html2apk/bridge" />
+    <source-file src="src/android/NotificationStore.java" target-dir="app/src/main/java/dev/html2apk/bridge" />
+    <framework src="androidx.core:core:1.12.0" />
+  </platform>
+</plugin>

package/src/templates/cordova-plugin-html2apk-bridge/src/android/BootReceiver.java

@@ -0,0 +1,20 @@
+package dev.html2apk.bridge;
+
+import android.app.AlarmManager;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+
+public class BootReceiver extends BroadcastReceiver {
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        boolean exactAllowed = true;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
+            exactAllowed = alarmManager != null && alarmManager.canScheduleExactAlarms();
+        }
+
+        NotificationStore.rescheduleAll(context, exactAllowed);
+    }
+}