html2apk 0.2.0 → 0.3.0

package/README.md

@@ -186,6 +186,7 @@ html2apk build --entry-file index.html
 html2apk build --web-root .
 html2apk build --app-name MeuApp
 html2apk build --package-id com.seuapp.meuapp
+html2apk build --theme auto
 html2apk build --android-platform android@15.0.0
 ```
 
@@ -209,9 +210,21 @@ Exemplo completo:
   "orientation": "default",
   "minSdkVersion": 24,
   "themeColor": "#126fff",
+  "themeMode": "fixed",
+  "oneSignalAppId": "",
   "icon": "",
   "splash": "",
-  "permissions": ["INTERNET", "CAMERA", "POST_NOTIFICATIONS", "VIBRATE"],
+  "deepLinks": {
+    "schemes": ["meuapp"],
+    "appLinks": [
+      {
+        "host": "meusite.com",
+        "paths": ["/produto/*", "/pedido/*"],
+        "autoVerify": false
+      }
+    ]
+  },
+  "permissions": ["INTERNET", "CAMERA", "RECORD_AUDIO", "POST_NOTIFICATIONS", "VIBRATE"],
   "plugins": ["cordova-plugin-camera"],
   "release": false,
   "androidPlatform": "android@15.0.0",
@@ -238,7 +251,10 @@ Campos principais:
 | `mode` | `fullscreen` para tela cheia, `standalone` para modo normal ou `floating` para icone flutuante. |
 | `orientation` | `default`, `vertical`, `horizontal`, `portrait` ou `landscape`. |
 | `minSdkVersion` | Versao minima do Android em API level. Padrao: `24`. |
-| `themeColor` | Cor base do tema/splash Android, em hexadecimal. |
+| `themeColor` | Cor base do tema/splash Android, em hexadecimal. Tambem vira fallback do modo automatico. |
+| `themeMode` | `fixed` usa a cor fixa. `auto` adapta as barras Android a cor visivel na tela do APK. Tambem aceita `theme: "auto"`. |
+| `oneSignalAppId` | Opcional. App ID publico do OneSignal para push remoto. Nao coloque REST API Key no APK. |
+| `deepLinks` | URLs que podem abrir o APK, como `meuapp://rota` ou `https://meusite.com/produto/1`. |
 | `entryFile` | Arquivo HTML inicial. Normalmente `index.html`. |
 | `webRoot` | Pasta onde estao os arquivos web. Normalmente `"."`. |
 | `permissions` | Permissoes Android adicionadas ao app. |
@@ -254,6 +270,33 @@ Prioridade de configuracao:
 2. `app.json` ou `config.json`.
 3. Valores padrao do html2apk.
 
+### Tema Automatico Do APK
+
+Use `themeMode: "auto"` ou `theme: "auto"` para o APK adaptar as barras nativas do Android a cor que esta visivel na tela. O html2apk observa a tela do WebView e ajusta status bar/navigation bar em tempo real.
+
+```json
+{
+  "themeMode": "auto",
+  "themeColor": "#126fff"
+}
+```
+
+`themeColor` continua importante: ela e usada no splash e como fallback quando o app ainda nao conseguiu detectar uma cor visivel.
+
+### OneSignal Opcional
+
+Se quiser receber notificacoes remotas pelo OneSignal, preencha `oneSignalAppId` no `app.json` ou no campo OneSignal App ID da interface grafica:
+
+```json
+{
+  "oneSignalAppId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
+}
+```
+
+Quando esse campo esta vazio, nada do OneSignal e instalado no APK. Quando ele esta preenchido, o html2apk instala `onesignal-cordova-plugin`, injeta a inicializacao no HTML e mantem as notificacoes locais existentes (`notificar`, `agendarNotificacao`, loops etc.).
+
+Importante: o App ID do OneSignal pode ficar no APK. A REST API Key nao deve ir no app, porque e segredo de servidor. Envie pushes pelo painel do OneSignal ou por um backend seu.
+
 ## Exemplo Minimo
 
 Este repositorio ja inclui um exemplo em:
@@ -310,7 +353,59 @@ Retorno:
 
 ## Bridge Nativa
 
-A v0.1 instala um plugin Cordova local com uma API global simples para recursos Android.
+A v0.1 instala um plugin Cordova local com uma API global simples para recursos Android. Todas as funcoes retornam `Promise`, exceto os ouvintes `aoEvento`/atalhos, que retornam uma funcao para cancelar a escuta.
+
+Cada funcao em portugues tambem tem alias em ingles. A interface grafica mostra a sintaxe PT-BR quando o idioma esta em portugues e mostra a sintaxe em ingles quando o usuario troca o idioma para English.
+
+Exemplos de aliases:
+
+| PT-BR | English |
+| --- | --- |
+| `notificar()` | `notify()` |
+| `agendarNotificacao()` | `scheduleNotification()` |
+| `agendarNotificacoes()` | `scheduleNotifications()` |
+| `agendarLoopNotificacoes()` | `scheduleNotificationLoop()` |
+| `cancelarNotificacao()` | `cancelNotification()` |
+| `solicitarPermissaoNotificacoes()` | `requestNotificationPermission()` |
+| `solicitarPermissaoPush()` | `requestPushPermission()` |
+| `aoClicarPush()` | `onPushClick()` |
+| `identificarUsuarioPush()` | `loginPushUser()` |
+| `adicionarTagPush()` | `addPushTag()` |
+| `solicitarPermissaoMicrofone()` | `requestMicrophonePermission()` |
+| `statusMicrofone()` | `microphoneStatus()` |
+| `ouvirMic()` | `listenMic()` / `startMic()` |
+| `pararMic()` | `stopMic()` |
+| `lanterna()` | `flashlight()` |
+| `alternarLanterna()` | `toggleFlashlight()` |
+| `escolherArquivo()` | `pickFile()` |
+| `escolherImagem()` | `pickImage()` |
+| `salvarArquivo()` | `saveFile()` |
+| `compartilhar()` | `share()` |
+| `copiarTexto()` | `copyText()` |
+| `lerTextoCopiado()` | `readText()` |
+| `abrirNoApp()` | `openInApp()` |
+| `abrirForaDoApp()` | `openOutsideApp()` |
+| `abrirUrlExterno()` | `openExternalUrl()` |
+| `manterTelaLigada()` | `keepScreenOn()` |
+| `brilhoTela()` | `setScreenBrightness()` |
+| `definirCorTema()` | `setThemeColor()` |
+| `infoMemoria()` | `memoryInfo()` |
+| `infoArmazenamento()` | `storageInfo()` |
+| `infoDesempenho()` | `performanceInfo()` |
+| `appsAbertos()` | `openAppsMemory()` |
+| `aoEvento()` | `onEvent()` |
+| `aoMinimizar()` | `onMinimize()` |
+| `obterLinkInicial()` | `getInitialLink()` |
+
+Os eventos tambem aceitam aliases em ingles em `onEvent()`: `app:ready`, `app:background`, `app:resumed`, `back:button`, `link:opened`, `network:changed`, `battery:changed`, `notification:received` e `notification:clicked`.
+
+Como tratar retornos:
+
+- Use `await` dentro de `try/catch` quando a acao depender de Android, permissao ou outro app instalado.
+- Seletores de arquivo podem retornar `null`, array vazio ou objeto vazio quando o usuario cancela.
+- APIs de permissao retornam objetos com `granted`; se vier `false`, desative o recurso ou mostre uma etapa de permissao.
+- Eventos retornam uma funcao de cancelamento; guarde essa funcao e chame quando a tela/componente sair.
+- Medidas de memoria, armazenamento e apps abertos sao diagnosticas. Android moderno pode limitar dados de outros apps por privacidade.
 
 No seu JavaScript do app:
 
@@ -323,6 +418,10 @@ vibrar(250);
 notificar({
   titulo: "Pedido aprovado",
   texto: "Toque para abrir os detalhes",
+  acoes: [
+    { id: "abrir", titulo: "Abrir" },
+    { id: "cancelar", titulo: "Cancelar" }
+  ],
   aoClicar: {
     acao: "abrir-rota",
     rota: "/pedido/123",
@@ -340,9 +439,216 @@ agendarNotificacao({
   }
 });
 
+await agendarNotificacoes([
+  { titulo: "Primeiro aviso", texto: "Daqui 1 minuto", quando: Date.now() + 60000 },
+  { titulo: "Segundo aviso", texto: "Daqui 2 minutos", quando: Date.now() + 120000 }
+]);
+
+const loop = await agendarLoopNotificacoes({
+  aCada: "12h",
+  notificacoes: [
+    {
+      titulo: "Hidrate-se",
+      texto: "Beba agua agora",
+      aoClicar: { acao: "abrir-hidratacao" }
+    },
+    {
+      titulo: "Alongamento",
+      texto: "Pausa rapida para alongar",
+      aoClicar: { acao: "abrir-alongamento" }
+    }
+  ]
+});
+
 fullscreen(true);
 ```
 
+`agendarNotificacao()` agenda uma notificacao. Se voce passar um array para ela, ou usar `agendarNotificacoes()`, o html2apk agenda varias em sequencia. Cada item recebe `id` automatico se voce nao informar um.
+
+`agendarLoopNotificacoes()` cria um loop recorrente que funciona com o app fechado. Use `aCada`, `intervalo`, `every` ou `interval` em milissegundos ou como texto (`"30min"`, `"12h"`, `"1d"`). A cada disparo, o Android mostra a proxima notificacao da lista. Para parar:
+
+```js
+await cancelarNotificacao(loop.id);
+```
+
+Cliques continuam chegando normalmente:
+
+```js
+aoClicarNotificacao((evento) => {
+  if ((evento.aoClicar || evento.onClick).acao === "abrir-hidratacao") {
+    abrirNoApp("#/hidratacao");
+  }
+});
+```
+
+As notificacoes usam o icone do APK gerado como icone nativo. No Android, esse icone pode aparecer monocromatico na barra de notificacoes por regra do sistema.
+
+OneSignal, quando `oneSignalAppId` esta preenchido:
+
+```js
+const permitido = await solicitarPermissaoPush();
+
+identificarUsuarioPush("user-123");
+adicionarTagPush("plano", "premium");
+
+const pararPush = aoClicarPush((evento) => {
+  console.log("Push clicado", evento);
+  abrirNoApp("#/notificacoes");
+});
+```
+
+Use OneSignal para pushes enviados remotamente pelo painel/API do OneSignal. Use `notificar()` e `agendarNotificacao()` para notificacoes locais criadas dentro do APK.
+
+Arquivos, galeria e compartilhamento:
+
+```js
+const imagem = await escolherImagem();
+const imagens = await escolherImagens({ multiplo: true });
+const pdf = await escolherArquivo({ tipos: ["application/pdf"] });
+const arquivos = await escolherArquivos({ multiplo: true });
+
+await salvarArquivo({
+  nome: "relatorio.txt",
+  mimeType: "text/plain",
+  conteudo: "Conteudo salvo pelo app"
+});
+
+await compartilhar({ texto: "Veja isso", url: "https://exemplo.com" });
+```
+
+O retorno de arquivos tem este formato:
+
+```json
+{
+  "uri": "content://...",
+  "name": "foto.png",
+  "nome": "foto.png",
+  "size": 12345,
+  "tamanho": 12345,
+  "mimeType": "image/png"
+}
+```
+
+Microfone:
+
+```js
+await solicitarPermissaoMicrofone();
+
+await ouvirMic();
+
+// ... depois, quando quiser parar
+const audio = await pararMic();
+const audioUrl = `data:${audio.mimeType};base64,${audio.base64}`;
+
+const player = new Audio(audioUrl);
+player.play();
+```
+
+`ouvirMic()` comeca a gravar e tambem pede permissao se ela ainda nao foi concedida. Para uma experiencia mais clara, prefira chamar `solicitarPermissaoMicrofone()` antes e explicar ao usuario por que o app precisa do microfone.
+
+`pararMic()` encerra a gravacao e retorna:
+
+```json
+{
+  "base64": "AAAA...",
+  "mimeType": "audio/mp4",
+  "extension": "m4a",
+  "size": 12345,
+  "durationMs": 3200
+}
+```
+
+Para tratar o retorno, use `mimeType` e `base64` juntos em um Data URL quando quiser tocar, baixar ou enviar o audio. Se `pararMic()` for chamado rapido demais, o Android pode nao conseguir finalizar o arquivo; aguarde alguns instantes apos `ouvirMic()`.
+
+Lanterna, tela, clipboard e intents:
+
+```js
+await solicitarPermissaoCamera();
+const lanternaStatus = await lanterna(true);
+await alternarLanterna();
+
+await manterTelaLigada(true);
+await brilhoTela(0.8);
+
+await copiarTexto("codigo123");
+const texto = await lerTextoCopiado();
+
+await abrirNoApp("/sobre.html");
+await abrirNoApp("#/pedido/123", { substituir: true });
+await abrirForaDoApp("https://exemplo.com");
+await abrirWhatsapp("559999999999", "Oi");
+await discar("11999999999");
+await abrirMapa("Avenida Paulista, Sao Paulo");
+```
+
+Use `abrirNoApp()`/`openInApp()` quando a navegacao deve acontecer dentro do proprio APK/WebView. Use `abrirForaDoApp()`/`openOutsideApp()` ou `abrirUrlExterno()`/`openExternalUrl()` quando quer mandar o usuario para navegador, WhatsApp, Maps ou outro app Android.
+
+Informacoes e desempenho:
+
+```js
+const aparelho = await infoDispositivo();
+const rede = await infoRede();
+const bateria = await infoBateria();
+const memoria = await infoMemoria();
+const armazenamento = await infoArmazenamento();
+const desempenho = await infoDesempenho();
+const abertos = await appsAbertos();
+```
+
+`infoDesempenho()` agrupa memoria, armazenamento, bateria, rede e `timestamp`. Valores de memoria e armazenamento retornam bytes.
+
+`appsAbertos()` retorna os processos/apps que o Android permite o APK enxergar:
+
+```json
+{
+  "apps": [
+    {
+      "name": "MeuApp",
+      "packageName": "com.seuapp.meuapp",
+      "ramBytes": 12345678,
+      "ramMb": 11.77,
+      "importanceName": "foreground"
+    }
+  ],
+  "porNome": {
+    "MeuApp": {
+      "ramBytes": 12345678,
+      "ramMb": 11.77
+    }
+  },
+  "limited": true
+}
+```
+
+Por privacidade, Android moderno pode limitar essa lista ao proprio app e alguns processos visiveis ao APK. Entao essa funcao nao deve ser tratada como gerenciador completo de tarefas do sistema.
+
+Eventos nativos:
+
+```js
+const parar = aoEvento("app:background", (evento) => {
+  console.log("App saiu da frente", evento.timestamp);
+});
+
+aoEvento("app:voltou", console.log);
+aoEvento("botao:voltar", console.log);
+aoEvento("link:aberto", (evento) => console.log(evento.url));
+aoEvento("rede:mudou", console.log);
+aoEvento("bateria:mudou", console.log);
+aoEvento("notificacao:clicada", console.log);
+
+parar();
+```
+
+Deep links:
+
+```js
+const linkInicial = await obterLinkInicial();
+
+aoAbrirLink((evento) => {
+  console.log(evento.url, evento.path, evento.query);
+});
+```
+
 Clique em notificacao:
 
 ```js

package/examples/minimal/app.json

@@ -7,6 +7,8 @@
   "orientation": "default",
   "minSdkVersion": 24,
   "themeColor": "#126fff",
+  "themeMode": "fixed",
+  "oneSignalAppId": "",
   "icon": "",
   "splash": "",
   "permissions": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "html2apk",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Node CLI and library to turn an HTML/CSS/JS folder into an Android APK through Cordova.",
   "main": "index.js",
   "bin": {
@@ -71,6 +71,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "cordova": "^13.0.0"
+    "cordova": "^13.0.0",
+    "onesignal-cordova-plugin": "^5.3.10"
   }
 }

package/src/cli/index.js

@@ -10,7 +10,7 @@ function printHelp() {
 
 Usage:
   html2apk init
-  html2apk build [--release] [--debug] [--mode fullscreen|standalone|floating] [--orientation vertical|horizontal] [--min-sdk 24] [--android-platform android@15.0.0]
+  html2apk build [--release] [--debug] [--mode fullscreen|standalone|floating] [--theme fixed|auto] [--orientation vertical|horizontal] [--min-sdk 24] [--android-platform android@15.0.0]
   html2apk doctor
 
 The current working directory is always treated as the user app root.`);
@@ -34,6 +34,9 @@ function parseBuildArgs(args) {
     } else if (arg === "--theme-color") {
       options.themeColor = args[index + 1];
       index += 1;
+    } else if (arg === "--theme" || arg === "--theme-mode") {
+      options.themeMode = args[index + 1];
+      index += 1;
     } else if (arg === "--min-sdk" || arg === "--min-sdk-version" || arg === "--minSdkVersion") {
       options.minSdkVersion = args[index + 1];
       index += 1;
@@ -76,6 +79,12 @@ function createPlaceholderConfig(projectName = "MeuApp") {
     orientation: "default",
     minSdkVersion: 24,
     themeColor: "#126fff",
+    themeMode: "fixed",
+    oneSignalAppId: "",
+    deepLinks: {
+      schemes: [],
+      appLinks: []
+    },
     icon: "",
     splash: "",
     permissions: [

package/src/cordova/config-xml.js

@@ -77,6 +77,59 @@ function renderAndroidSplashPreferences(options) {
   ].filter(Boolean).join("\n");
 }
 
+function renderDeepLinkData(pathItem) {
+  if (!pathItem || pathItem === "*" || pathItem === "/*") {
+    return "";
+  }
+
+  if (pathItem.includes("*")) {
+    return ` android:pathPattern="${xmlEscape(pathItem.replace(/\*/g, ".*"))}"`;
+  }
+
+  return ` android:pathPrefix="${xmlEscape(pathItem)}"`;
+}
+
+function renderDeepLinkIntentFilters(deepLinks = {}) {
+  const filters = [];
+  const schemes = Array.isArray(deepLinks.schemes) ? deepLinks.schemes : [];
+  const appLinks = Array.isArray(deepLinks.appLinks) ? deepLinks.appLinks : [];
+
+  for (const scheme of schemes) {
+    filters.push(`    <config-file target="AndroidManifest.xml" parent="/manifest/application/activity">
+      <intent-filter>
+        <action android:name="android.intent.action.VIEW" />
+        <category android:name="android.intent.category.DEFAULT" />
+        <category android:name="android.intent.category.BROWSABLE" />
+        <data android:scheme="${xmlEscape(scheme)}" />
+      </intent-filter>
+    </config-file>`);
+  }
+
+  for (const link of appLinks) {
+    if (!link || !link.host) {
+      continue;
+    }
+
+    const scheme = link.scheme || "https";
+    const paths = Array.isArray(link.paths) && link.paths.length ? link.paths : [""];
+    const dataItems = paths
+      .map((pathItem) => `        <data android:scheme="${xmlEscape(scheme)}" android:host="${xmlEscape(link.host)}"${renderDeepLinkData(pathItem)} />`)
+      .join("\n");
+    const verify = link.autoVerify ? " android:autoVerify=\"true\"" : "";
+
+    filters.push(`    <config-file target="AndroidManifest.xml" parent="/manifest/application/activity">
+      <intent-filter${verify}>
+        <action android:name="android.intent.action.VIEW" />
+        <category android:name="android.intent.category.DEFAULT" />
+        <category android:name="android.intent.category.BROWSABLE" />
+${dataItems}
+      </intent-filter>
+    </config-file>`);
+  }
+
+  return filters.join("\n");
+}
+
 function renderConfigXml(options) {
   const fullscreen = options.mode === "fullscreen" ? "true" : "false";
   const permissionsList = options.mode === "floating"
@@ -85,8 +138,11 @@ function renderConfigXml(options) {
   const permissions = renderPermissions(permissionsList);
   const icon = renderIcon(options.icon);
   const splashPreferences = renderAndroidSplashPreferences(options);
-  const platformItems = [permissions, icon, splashPreferences].filter(Boolean).join("\n");
+  const deepLinkIntentFilters = renderDeepLinkIntentFilters(options.deepLinks);
+  const platformItems = [permissions, deepLinkIntentFilters, icon, splashPreferences].filter(Boolean).join("\n");
   const backgroundPreference = renderPreference("BackgroundColor", options.themeColor || options.backgroundColor);
+  const themeModePreference = renderPreference("Html2ApkThemeMode", options.themeMode || options.theme || "fixed");
+  const oneSignalPreference = renderPreference("Html2ApkOneSignalAppId", options.oneSignalAppId);
   const modePreference = renderPreference("Html2ApkMode", options.mode || "standalone");
   const minSdkPreference = renderPreference(
     "android-minSdkVersion",
@@ -124,6 +180,8 @@ function renderConfigXml(options) {
   <preference name="GradlePluginKotlinEnabled" value="true" />
 ${minSdkPreference}
 ${modePreference}
+${themeModePreference}
+${oneSignalPreference}
 ${orientationPreference ? `${orientationPreference}\n` : ""}${backgroundPreference ? `${backgroundPreference}\n` : ""}
 
   <platform name="android">

package/src/core/build-apk.js

@@ -8,11 +8,15 @@ const { validateEntryFile, validateRequiredOptions } = require("./validation");
 const { createCordovaProject, addAndroidPlatform, buildAndroid, 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";
+
 function isRemoteAsset(assetPath) {
   return /^https?:\/\//i.test(String(assetPath || ""));
 }
@@ -34,6 +38,141 @@ 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 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;
@@ -136,10 +275,20 @@ async function buildApk(overrides = {}) {
     cordovaOptions.androidSplashScreenAnimatedIcon = toBuildAssetPath(buildDir, cordovaOptions.splash);
     await writeConfigXml(path.join(buildDir, "config.xml"), cordovaOptions);
     await copyWebAssets(webRoot, path.join(buildDir, "www"), options, projectRoot);
+    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);
     }