html2apk 0.2.0 → 0.4.0

package/src/desktop/renderer/renderer.js

@@ -43,9 +43,14 @@ const i18n = {
     orientationLandscape: "Horizontal",
     minSdkVersion: "Android minimo",
     appIcon: "Icone do app",
-    appThemeColor: "Cor do tema do app",
+    appThemeColor: "Cor do tema/fallback",
+    themeMode: "Tema do APK",
+    themeModeFixed: "Cor fixa",
+    themeModeAuto: "Automatico pela tela",
+    oneSignalAppId: "OneSignal App ID",
+    oneSignalAppIdHint: "Opcional. Use o App ID do OneSignal, nao a REST API Key.",
     androidPermissions: "Permissoes Android",
-    chooseIcon: "Escolher icone PNG",
+    chooseIcon: "Trocar icone PNG",
     reviewBuild: "Revisar build",
     debugBuild: "Debug tecnico",
     debugBuildText: "Mantem a pasta Cordova temporaria para inspecao.",
@@ -60,6 +65,7 @@ const i18n = {
     buildEyebrow: "Revisao",
     buildTitle: "Confirme as informacoes e gere o APK",
     startBuild: "Gerar APK",
+    startUsbDebug: "Testar no USB",
     stepFolder: "Pasta recebida",
     stepSettings: "Configuracoes completas",
     stepDoctor: "Ambiente verificado",
@@ -71,7 +77,16 @@ const i18n = {
     logsTitle: "Logs do processo",
     codesEyebrow: "Bridge nativa",
     codesTitle: "Codigos interpretados",
-    codesIntro: "Estas funcoes chamadas no JavaScript do app sao interpretadas pelo plugin Cordova e executadas no Java Android.",
+    codesIntro: "Use estes blocos no JavaScript do seu projeto. O html2apk espera o Android ficar pronto, pede permissoes quando precisar e abre a configuracao certa quando o Android bloquear o pop-up.",
+    javaLabel: "Motor nativo",
+    doesLabel: "O que faz",
+    whenUseLabel: "Quando usar",
+    returnsLabel: "Retorno",
+    handlingLabel: "Como tratar",
+    exampleLabel: "Exemplo copiavel",
+    copyCode: "Copiar",
+    copiedCode: "Copiado",
+    copyFailed: "Nao foi possivel copiar",
     clearLogs: "Limpar logs",
     helpEyebrow: "Sem misterio",
     helpTitle: "Doctor, build e dependencias",
@@ -79,6 +94,9 @@ const i18n = {
     helpBuild: "Cria um projeto Cordova temporario, copia seu app web e gera o arquivo APK em dist.",
     helpDepsTitle: "Dependencias no EXE",
     helpDeps: "O executavel empacota html2apk, a interface e dependencias Node/Cordova. Se faltarem pacotes Android, ele pede permissao e tenta instalar; JDK/Gradle podem exigir instalacao do sistema.",
+    helpCreatorTitle: "Criador",
+    helpCreatorText: "Conheca o Dev Caio Multiversando, criador desta linda aplicacao html2apk.",
+    openInstagram: "Conhecer o dev",
     ready: "Pronto",
     selected: "Selecionado",
     missing: "Nao encontrado",
@@ -92,9 +110,15 @@ const i18n = {
     buildRunning: "Gerando APK",
     buildOk: "APK gerado com sucesso",
     buildFail: "Build falhou",
+    usbDebugRunning: "Gerando e instalando no celular USB",
+    usbDebugOk: "APK instalado no celular USB",
+    usbDebugFail: "Teste USB falhou",
     droppedFolder: "Pasta recebida",
     noFolderDrop: "Solte uma pasta do projeto",
     projectLoaded: "Projeto carregado",
+    projectAutoUpdated: "Projeto atualizado automaticamente",
+    projectConfigReloaded: "Configuracoes recarregadas do projeto",
+    projectWatcherFail: "Nao foi possivel acompanhar alteracoes da pasta",
     logsCleared: "Logs limpos",
     settingsOk: "Configuracoes completas",
     settingsMissing: "Complete as configuracoes obrigatorias",
@@ -104,9 +128,10 @@ const i18n = {
     invalidPackageId: "Informe um Package ID valido, exemplo: com.seuapp.meuapp.",
     invalidVersion: "Informe a versao no formato 1.0.0.",
     missingMode: "Escolha o modo do app.",
-    missingIcon: "Escolha o icone do app.",
+    defaultIcon: "Icone padrao do html2apk",
     invalidIconType: "Use um icone PNG para evitar falhas no Android.",
     invalidThemeColor: "Use uma cor hexadecimal valida, exemplo: #126fff.",
+    invalidOneSignalAppId: "Use um OneSignal App ID valido ou deixe vazio.",
     invalidMinSdkVersion: "Escolha uma versao minima do Android entre API 24 e API 36.",
     iconSelected: "Icone selecionado",
     progressLabel: "Progresso",
@@ -130,6 +155,8 @@ const i18n = {
     successEyebrow: "Concluido",
     successTitle: "APK gerado com sucesso",
     successText: "Seu arquivo Android esta pronto na pasta dist.",
+    usbSuccessTitle: "APK instalado no celular",
+    usbSuccessText: "O build debug foi enviado por USB. O app deve abrir no aparelho conectado.",
     newBuild: "Novo build"
   },
   en: {
@@ -172,9 +199,14 @@ const i18n = {
     orientationLandscape: "Landscape",
     minSdkVersion: "Minimum Android",
     appIcon: "App icon",
-    appThemeColor: "App theme color",
+    appThemeColor: "Theme/fallback color",
+    themeMode: "APK theme",
+    themeModeFixed: "Fixed color",
+    themeModeAuto: "Auto from screen",
+    oneSignalAppId: "OneSignal App ID",
+    oneSignalAppIdHint: "Optional. Use the OneSignal App ID, not the REST API Key.",
     androidPermissions: "Android permissions",
-    chooseIcon: "Choose PNG icon",
+    chooseIcon: "Change PNG icon",
     reviewBuild: "Review build",
     debugBuild: "Technical debug",
     debugBuildText: "Keeps the temporary Cordova folder for inspection.",
@@ -189,6 +221,7 @@ const i18n = {
     buildEyebrow: "Review",
     buildTitle: "Confirm the information and build the APK",
     startBuild: "Build APK",
+    startUsbDebug: "Test on USB",
     stepFolder: "Folder received",
     stepSettings: "Settings complete",
     stepDoctor: "Environment checked",
@@ -200,7 +233,16 @@ const i18n = {
     logsTitle: "Process logs",
     codesEyebrow: "Native bridge",
     codesTitle: "Interpreted code",
-    codesIntro: "These functions called in your app JavaScript are interpreted by the Cordova plugin and executed in Android Java.",
+    codesIntro: "Use these blocks in your project JavaScript. html2apk waits for Android to be ready, asks permissions when needed and opens the right settings screen when Android blocks the prompt.",
+    javaLabel: "Native engine",
+    doesLabel: "What it does",
+    whenUseLabel: "When to use",
+    returnsLabel: "Returns",
+    handlingLabel: "How to handle",
+    exampleLabel: "Copyable example",
+    copyCode: "Copy",
+    copiedCode: "Copied",
+    copyFailed: "Could not copy",
     clearLogs: "Clear logs",
     helpEyebrow: "Plain and simple",
     helpTitle: "Doctor, build and dependencies",
@@ -208,6 +250,9 @@ const i18n = {
     helpBuild: "Creates a temporary Cordova project, copies your web app and generates the APK in dist.",
     helpDepsTitle: "Dependencies in the EXE",
     helpDeps: "The executable bundles html2apk, the interface and Node/Cordova dependencies. If Android packages are missing, it asks permission and tries to install them; JDK/Gradle may still require system installation.",
+    helpCreatorTitle: "Creator",
+    helpCreatorText: "Meet Dev Caio Multiversando, creator of this lovely html2apk app.",
+    openInstagram: "Meet the dev",
     ready: "Ready",
     selected: "Selected",
     missing: "Missing",
@@ -221,9 +266,15 @@ const i18n = {
     buildRunning: "Building APK",
     buildOk: "APK generated successfully",
     buildFail: "Build failed",
+    usbDebugRunning: "Building and installing on USB phone",
+    usbDebugOk: "APK installed on USB phone",
+    usbDebugFail: "USB test failed",
     droppedFolder: "Folder received",
     noFolderDrop: "Drop a project folder",
     projectLoaded: "Project loaded",
+    projectAutoUpdated: "Project updated automatically",
+    projectConfigReloaded: "Settings reloaded from project",
+    projectWatcherFail: "Could not watch folder changes",
     logsCleared: "Logs cleared",
     settingsOk: "Settings complete",
     settingsMissing: "Complete the required settings",
@@ -233,9 +284,10 @@ const i18n = {
     invalidPackageId: "Enter a valid Package ID, example: com.yourapp.name.",
     invalidVersion: "Enter the version as 1.0.0.",
     missingMode: "Choose the app mode.",
-    missingIcon: "Choose the app icon.",
+    defaultIcon: "Default html2apk icon",
     invalidIconType: "Use a PNG icon to avoid Android build failures.",
     invalidThemeColor: "Use a valid hex color, example: #126fff.",
+    invalidOneSignalAppId: "Use a valid OneSignal App ID or leave it empty.",
     invalidMinSdkVersion: "Choose a minimum Android version between API 24 and API 36.",
     iconSelected: "Icon selected",
     progressLabel: "Progress",
@@ -259,6 +311,8 @@ const i18n = {
     successEyebrow: "Complete",
     successTitle: "APK generated successfully",
     successText: "Your Android file is ready in the dist folder.",
+    usbSuccessTitle: "APK installed on phone",
+    usbSuccessText: "The debug build was sent over USB. The app should open on the connected device.",
     newBuild: "New build"
   }
 };
@@ -276,6 +330,7 @@ const animatedBuildLines = [
 const DEFAULT_PERMISSIONS = ["INTERNET", "POST_NOTIFICATIONS", "VIBRATE"];
 const DEFAULT_MIN_SDK_VERSION = 24;
 const MIN_SDK_OPTIONS = [24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36];
+const DEVELOPER_INSTAGRAM_URL = "https://www.instagram.com/caiomutiversando?igsh=MWFpcmYzZDB3YTNzZQ==";
 
 const permissionOptions = [
   {
@@ -321,19 +376,889 @@ const permissionOptions = [
 ];
 
 const nativeCodeEntries = [
-  { js: "toast('Mensagem')", java: "toast", description: { pt: "Mostra uma mensagem rapida nativa.", en: "Shows a native short message." } },
-  { js: "vibrar(250)", java: "vibrate", description: { pt: "Aciona a vibracao do aparelho.", en: "Triggers device vibration." } },
-  { js: "notificar({ titulo, texto })", java: "notify", description: { pt: "Cria uma notificacao Android imediata.", en: "Creates an immediate Android notification." } },
-  { js: "agendarNotificacao({ titulo, texto, quando })", java: "scheduleNotification", description: { pt: "Agenda notificacao mesmo com o app fechado.", en: "Schedules a notification even when the app is closed." } },
-  { js: "fullscreen(true)", java: "fullscreen", description: { pt: "Liga ou desliga o modo imersivo.", en: "Toggles immersive mode." } },
-  { js: "solicitarPermissaoSobreposicao()", java: "requestOverlayPermission", description: { pt: "Abre a permissao para sobrepor outros apps.", en: "Opens draw-over-apps permission." } },
-  { js: "iniciarIconeFlutuante()", java: "startFloatingIcon", description: { pt: "Mostra o icone flutuante nativo.", en: "Shows the native floating icon." } },
-  { js: "pararIconeFlutuante()", java: "stopFloatingIcon", description: { pt: "Remove o icone flutuante.", en: "Removes the floating icon." } },
-  { js: "manterTelaAcordada(true)", java: "keepScreenAwake", description: { pt: "Impede a tela de apagar enquanto o app esta aberto.", en: "Keeps the screen awake while the app is open." } },
-  { js: "brilhoTela(0.8)", java: "setScreenBrightness", description: { pt: "Ajusta o brilho da janela do app.", en: "Adjusts this app window brightness." } },
-  { js: "copiarTexto('texto')", java: "copyText", description: { pt: "Copia texto para a area de transferencia.", en: "Copies text to the clipboard." } },
-  { js: "compartilharTexto('texto')", java: "shareText", description: { pt: "Abre o compartilhamento nativo do Android.", en: "Opens the native Android share sheet." } },
-  { js: "abrirUrl('https://...')", java: "openUrl", description: { pt: "Abre um link em outro app Android.", en: "Opens a link in another Android app." } }
+  {
+    syntax: { pt: "toast('Mensagem')", en: "toast('Message')" },
+    java: "toast",
+    description: { pt: "Mostra uma mensagem rapida nativa.", en: "Shows a native short message." },
+    returns: { pt: "Promise<void>.", en: "Promise<void>." },
+    handling: { pt: "Use com `await` quando a proxima acao depender do feedback; coloque em `try/catch` se quiser mostrar erro ao usuario.", en: "Use `await` when the next action depends on the feedback; wrap in `try/catch` if you want to show an error to the user." }
+  },
+  {
+    syntax: { pt: "vibrar(250)", en: "vibrate(250)" },
+    java: "vibrate",
+    description: { pt: "Aciona a vibracao do aparelho por milissegundos.", en: "Vibrates the device for milliseconds." },
+    returns: { pt: "Promise<void>.", en: "Promise<void>." },
+    handling: { pt: "Limite duracoes longas e deixe a permissao `VIBRATE` no app; se falhar, siga sem bloquear o fluxo principal.", en: "Keep long durations under control and include the `VIBRATE` permission; if it fails, continue without blocking the main flow." }
+  },
+  {
+    syntax: { pt: "notificar({ titulo, texto, acoes })", en: "notify({ title, text, actions })" },
+    java: "notify",
+    description: { pt: "Cria notificacao Android imediata. `acoes` ou `actions` viram botoes clicaveis.", en: "Creates an immediate Android notification. `actions` or `acoes` become clickable buttons." },
+    returns: { pt: "Promise<void>; cliques chegam em `aoEvento('notificacao:clicada')` ou `aoClicarNotificacao()`.", en: "Promise<void>; clicks arrive through `onEvent('notification:clicked')` or `onNotificationClick()`." },
+    handling: { pt: "Ao chamar, o html2apk pede permissao automaticamente no Android 13+. Se o Android nao puder mostrar o pop-up, ele abre as configuracoes e retorna `settingsOpened`.", en: "When called, html2apk automatically requests permission on Android 13+. If Android cannot show the prompt, it opens settings and returns `settingsOpened`." }
+  },
+  {
+    syntax: { pt: "agendarNotificacao({ titulo, texto, quando }) / agendarNotificacoes([...])", en: "scheduleNotification({ title, text, when }) / scheduleNotifications([...])" },
+    java: "scheduleNotification",
+    description: { pt: "Agenda uma notificacao ou uma lista de notificacoes mesmo com o app fechado.", en: "Schedules one notification or a list of notifications even when the app is closed." },
+    returns: { pt: "Uma notificacao retorna { id, when }; varias retornam Promise<Array> com esses objetos.", en: "One notification returns { id, when }; multiple notifications return Promise<Array> with those objects." },
+    handling: { pt: "`quando`/`when` deve ser timestamp em ms. Para varias, passe array; cada item ganha `id` automatico se voce nao informar. Se precisar de horario exato, confira `podeAgendarNotificacaoExata()`.", en: "`when`/`quando` must be a millisecond timestamp. For multiple, pass an array; each item gets an automatic `id` if you do not provide one. For exact timing, check `canScheduleExactAlarms()`." }
+  },
+  {
+    syntax: { pt: "agendarLoopNotificacoes({ aCada: '12h', notificacoes: [...] })", en: "scheduleNotificationLoop({ every: '12h', notifications: [...] })" },
+    java: "AlarmManager + NotificationStore",
+    description: { pt: "Cria um loop de notificacoes que continua funcionando com o app fechado e alterna os itens da lista.", en: "Creates a notification loop that keeps working with the app closed and rotates through the list items." },
+    returns: { pt: "{ id, when, repeating, loop }. Guarde o `id` para cancelar depois.", en: "{ id, when, repeating, loop }. Store the `id` to cancel later." },
+    handling: { pt: "Use `aoClicarNotificacao()` ou `aoEvento('notificacao:clicada')` para chamar funcoes conforme `aoClicar`. Cancele com `cancelarNotificacao(id)`.", en: "Use `onNotificationClick()` or `onEvent('notification:clicked')` to call functions from `onClick`. Cancel with `cancelNotification(id)`." }
+  },
+  {
+    syntax: { pt: "solicitarPermissaoNotificacoes()", en: "requestNotificationPermission()" },
+    java: "requestNotificationPermission",
+    description: { pt: "Pede permissao para mostrar notificacoes quando o Android exigir.", en: "Requests permission to show notifications when Android requires it." },
+    returns: { pt: "{ permission, required, granted, requiresSettings, settingsOpened }.", en: "{ permission, required, granted, requiresSettings, settingsOpened }." },
+    handling: { pt: "Se `granted` for falso, desative botoes de notificacao ou explique ao usuario como habilitar depois.", en: "If `granted` is false, disable notification buttons or explain how the user can enable it later." }
+  },
+  {
+    syntax: { pt: "solicitarPermissaoPush() / aoClicarPush(fn)", en: "requestPushPermission() / onPushClick(fn)" },
+    java: "onesignal-cordova-plugin",
+    description: { pt: "Ativa push remoto via OneSignal quando o OneSignal App ID foi preenchido nas configuracoes.", en: "Enables remote push through OneSignal when the OneSignal App ID was filled in settings." },
+    returns: { pt: "`solicitarPermissaoPush` retorna boolean. `aoClicarPush` retorna funcao para parar de escutar.", en: "`requestPushPermission` returns boolean. `onPushClick` returns an unsubscribe function." },
+    handling: { pt: "Use esse caminho para notificacoes enviadas pelo painel/API do OneSignal. Nao coloque REST API Key dentro do APK; use `identificarUsuarioPush(id)` e `adicionarTagPush(chave, valor)` para segmentar usuarios.", en: "Use this path for notifications sent from the OneSignal dashboard/API. Do not put a REST API Key inside the APK; use `loginPushUser(id)` and `addPushTag(key, value)` to target users." }
+  },
+  {
+    syntax: { pt: "statusPermissoes(['CAMERA'])", en: "permissionStatus(['CAMERA'])" },
+    java: "permissionStatus",
+    description: { pt: "Consulta se permissoes Android estao liberadas.", en: "Checks whether Android permissions are granted." },
+    returns: { pt: "Objeto com permissao Android como chave e boolean como valor.", en: "Object with Android permission names as keys and booleans as values." },
+    handling: { pt: "Use apenas para consultar. Para pedir permissao, chame a funcao real (`lanterna`, `ouvirMic`, `notificar`) ou a API manual correspondente.", en: "Use only to check. To request permission, call the real function (`flashlight`, `listenMic`, `notify`) or the matching manual API." }
+  },
+  {
+    syntax: { pt: "aoEvento('app:background', fn)", en: "onEvent('app:background', fn)" },
+    java: "dispatchEvent",
+    description: { pt: "Escuta eventos nativos: app:pronto, app:background, app:voltou, botao:voltar, link:aberto, rede:mudou, bateria:mudou, notificacao:recebida e notificacao:clicada.", en: "Listens to native events: app:ready, app:background, app:resumed, back:button, link:opened, network:changed, battery:changed, notification:received and notification:clicked." },
+    returns: { pt: "Funcao para cancelar a escuta.", en: "Unsubscribe function." },
+    handling: { pt: "Guarde o retorno em `parar` e chame quando a tela/componente for desmontado para evitar escutas duplicadas.", en: "Store the return value as `stop` and call it when the screen/component unmounts to avoid duplicate listeners." }
+  },
+  {
+    syntax: { pt: "aoMinimizar(fn) / aoVoltarParaApp(fn)", en: "onMinimize(fn) / onAppResume(fn)" },
+    java: "lifecycle",
+    description: { pt: "Atalhos para saber quando o app saiu da frente ou voltou.", en: "Shortcuts for knowing when the app left the foreground or resumed." },
+    returns: { pt: "Funcao para cancelar a escuta.", en: "Unsubscribe function." },
+    handling: { pt: "Pause timers, audio ou leitura pesada ao minimizar; ao voltar, confira se dados precisam ser recarregados.", en: "Pause timers, audio or heavy reads on minimize; on resume, check whether data should be refreshed." }
+  },
+  {
+    syntax: { pt: "obterLinkInicial() / aoAbrirLink(fn)", en: "getInitialLink() / onOpenLink(fn)" },
+    java: "getInitialLink",
+    description: { pt: "Lida com deep links/app links que abriram o APK.", en: "Handles deep links/app links that opened the APK." },
+    returns: { pt: "{ url, scheme, host, path, query } ou null; o listener recebe o mesmo objeto.", en: "{ url, scheme, host, path, query } or null; the listener receives the same object." },
+    handling: { pt: "No inicio do app, leia `obterLinkInicial()` e tambem registre `aoAbrirLink()` para links recebidos com o app ja aberto.", en: "At app startup, read `getInitialLink()` and also register `onOpenLink()` for links received while the app is already open." }
+  },
+  {
+    syntax: { pt: "solicitarPermissaoCamera()", en: "requestCameraPermission()" },
+    java: "requestCameraPermission",
+    description: { pt: "Pede permissao de camera manualmente, se voce quiser preparar a experiencia antes da lanterna.", en: "Requests camera permission manually, if you want to prepare the experience before flashlight." },
+    returns: { pt: "{ permission, required, granted, requiresSettings, settingsOpened }.", en: "{ permission, required, granted, requiresSettings, settingsOpened }." },
+    handling: { pt: "`lanterna()` ja pede permissao sozinha. Use esta funcao apenas se quiser explicar antes e controlar a UI pelo `granted`.", en: "`flashlight()` already requests permission by itself. Use this only if you want to explain first and control the UI from `granted`." }
+  },
+  {
+    syntax: { pt: "await ouvirMic(); const audio = await pararMic()", en: "await listenMic(); const audio = await stopMic()" },
+    java: "MediaRecorder",
+    description: { pt: "Comeca a gravar pelo microfone e finaliza retornando o audio em base64.", en: "Starts recording from the microphone and finishes by returning the audio as base64." },
+    returns: { pt: "`ouvirMic`: { recording, startedAt, granted, settingsOpened }. `pararMic`: { base64, mimeType, extension, durationMs, size }.", en: "`listenMic`: { recording, startedAt, granted, settingsOpened }. `stopMic`: { base64, mimeType, extension, durationMs, size }." },
+    handling: { pt: "`ouvirMic()` pede microfone sozinho. Se `settingsOpened` vier true, o Android abriu as configuracoes; quando o usuario voltar, chame `ouvirMic()` de novo.", en: "`listenMic()` requests the microphone by itself. If `settingsOpened` is true, Android opened settings; when the user returns, call `listenMic()` again." }
+  },
+  {
+    syntax: { pt: "lanterna(true) / statusLanterna()", en: "flashlight(true) / flashlightStatus()" },
+    java: "flashlight",
+    description: { pt: "Liga, desliga e consulta a lanterna do aparelho.", en: "Turns the device flashlight on/off and reads its status." },
+    returns: { pt: "{ available, enabled, permissionGranted }.", en: "{ available, enabled, permissionGranted }." },
+    handling: { pt: "Ao chamar, o html2apk pede CAMERA automaticamente. Se `settingsOpened` vier true, o Android abriu as configuracoes porque o pop-up estava bloqueado.", en: "When called, html2apk automatically requests CAMERA. If `settingsOpened` is true, Android opened settings because the prompt was blocked." }
+  },
+  {
+    syntax: { pt: "alternarLanterna()", en: "toggleFlashlight()" },
+    java: "toggleFlashlight",
+    description: { pt: "Inverte o estado atual da lanterna.", en: "Toggles the current flashlight state." },
+    returns: { pt: "{ available, enabled, permissionGranted }.", en: "{ available, enabled, permissionGranted }." },
+    handling: { pt: "Atualize o botao usando `enabled` retornado, sem assumir que o toggle sempre conseguiu mudar o estado.", en: "Update the button from the returned `enabled` value instead of assuming the toggle always succeeded." }
+  },
+  {
+    syntax: { pt: "escolherImagem()", en: "pickImage()" },
+    java: "pickFile",
+    description: { pt: "Abre o seletor nativo para o usuario escolher uma imagem.", en: "Opens the native picker for one image." },
+    returns: { pt: "{ uri, name, nome, size, tamanho, mimeType } ou null.", en: "{ uri, name, nome, size, tamanho, mimeType } or null." },
+    handling: { pt: "Se vier `null`, o usuario cancelou. Use `uri` em `<img>`/upload; nao espere caminho absoluto de arquivo.", en: "If it returns `null`, the user canceled. Use `uri` for `<img>`/upload; do not expect an absolute file path." }
+  },
+  {
+    syntax: { pt: "escolherImagens({ multiplo: true })", en: "pickImages({ multiple: true })" },
+    java: "pickFile",
+    description: { pt: "Abre galeria/seletor para varias imagens.", en: "Opens gallery/picker for multiple images." },
+    returns: { pt: "Array de arquivos; vazio se o usuario cancelar.", en: "Array of files; empty when the user cancels." },
+    handling: { pt: "Sempre trate como array. Limite quantidade/tamanho antes de enviar ou processar.", en: "Always handle it as an array. Limit quantity/size before uploading or processing." }
+  },
+  {
+    syntax: { pt: "escolherArquivo({ tipos: ['application/pdf'] })", en: "pickFile({ types: ['application/pdf'] })" },
+    java: "pickFile",
+    description: { pt: "Abre o seletor nativo para PDF, ZIP, TXT ou qualquer MIME.", en: "Opens the native picker for PDF, ZIP, TXT or any MIME." },
+    returns: { pt: "{ uri, name, nome, size, tamanho, mimeType } ou null.", en: "{ uri, name, nome, size, tamanho, mimeType } or null." },
+    handling: { pt: "Valide `mimeType` e `size` antes de aceitar. Cancelamento retorna `null` na funcao de arquivo unico.", en: "Validate `mimeType` and `size` before accepting. Cancel returns `null` for the single-file function." }
+  },
+  {
+    syntax: { pt: "escolherArquivos({ multiplo: true })", en: "pickFiles({ multiple: true })" },
+    java: "pickFile",
+    description: { pt: "Seleciona varios arquivos de qualquer tipo ou dos MIME informados.", en: "Selects multiple files of any type or the MIME types you provide." },
+    returns: { pt: "Array de arquivos.", en: "Array of files." },
+    handling: { pt: "Itere sobre o array e trate item por item; nao bloqueie a UI se muitos arquivos forem escolhidos.", en: "Iterate over the array and handle each item; avoid blocking the UI if many files are selected." }
+  },
+  {
+    syntax: { pt: "escolherVideo()", en: "pickVideo()" },
+    java: "pickFile",
+    description: { pt: "Abre o seletor nativo filtrando videos.", en: "Opens the native picker filtered to videos." },
+    returns: { pt: "{ uri, name, size, mimeType } ou null.", en: "{ uri, name, size, mimeType } or null." },
+    handling: { pt: "Videos podem ser grandes: confira `size` e mostre progresso se for fazer upload.", en: "Videos can be large: check `size` and show progress if you upload them." }
+  },
+  {
+    syntax: { pt: "escolherPasta()", en: "pickFolder()" },
+    java: "pickFolder",
+    description: { pt: "Abre o seletor nativo de pasta quando o Android permitir.", en: "Opens the native folder picker when Android allows it." },
+    returns: { pt: "{ uri } ou objeto vazio se cancelar.", en: "{ uri } or an empty object when canceled." },
+    handling: { pt: "Confira se `uri` existe antes de salvar. Android moderno entrega URI de documento, nao caminho real.", en: "Check that `uri` exists before saving. Modern Android returns a document URI, not a real path." }
+  },
+  {
+    syntax: { pt: "salvarArquivo({ nome, conteudo })", en: "saveFile({ name, content })" },
+    java: "saveFile",
+    description: { pt: "Abre o modal nativo para o usuario escolher onde salvar.", en: "Opens the native modal so the user chooses where to save." },
+    returns: { pt: "{ uri, name, size, mimeType, saved } ou objeto vazio se cancelar.", en: "{ uri, name, size, mimeType, saved } or an empty object when canceled." },
+    handling: { pt: "Depois do retorno, confira `saved === true`. Para binario, envie `base64`; para texto, use `conteudo`/`content`.", en: "After the return, check `saved === true`. For binary data, send `base64`; for text, use `content`/`conteudo`." }
+  },
+  {
+    syntax: { pt: "compartilhar({ texto, url })", en: "share({ text, url })" },
+    java: "share",
+    description: { pt: "Abre a folha nativa de compartilhamento.", en: "Opens the native share sheet." },
+    returns: { pt: "Promise<void>.", en: "Promise<void>." },
+    handling: { pt: "Monte mensagens curtas e trate erro quando nao houver app capaz de compartilhar.", en: "Build short messages and handle errors when no app can share the content." }
+  },
+  {
+    syntax: { pt: "copiarTexto('texto') / lerTextoCopiado()", en: "copyText('text') / readText()" },
+    java: "copyText/readText",
+    description: { pt: "Escreve e le a area de transferencia.", en: "Writes and reads the clipboard." },
+    returns: { pt: "`copiarTexto` retorna void; `lerTextoCopiado` retorna string.", en: "`copyText` returns void; `readText` returns string." },
+    handling: { pt: "Apos copiar, confirme com um toast. Ao ler, aceite string vazia porque a area de transferencia pode estar vazia.", en: "After copying, confirm with a toast. When reading, accept an empty string because the clipboard may be empty." }
+  },
+  {
+    syntax: { pt: "manterTelaLigada(true)", en: "keepScreenOn(true)" },
+    java: "keepScreenAwake",
+    description: { pt: "Impede a tela de apagar enquanto o app esta aberto.", en: "Keeps the screen awake while the app is open." },
+    returns: { pt: "Promise<void>.", en: "Promise<void>." },
+    handling: { pt: "Ative so em telas de leitura, video ou monitoramento; desligue com `false` ao sair da tela.", en: "Enable only on reading, video or monitoring screens; turn it off with `false` when leaving the screen." }
+  },
+  {
+    syntax: { pt: "brilhoTela(0.8)", en: "setScreenBrightness(0.8)" },
+    java: "setScreenBrightness",
+    description: { pt: "Ajusta o brilho apenas da janela do app.", en: "Adjusts only this app window brightness." },
+    returns: { pt: "Promise<void>.", en: "Promise<void>." },
+    handling: { pt: "Use valor entre 0 e 1. Guarde o valor anterior se quiser restaurar a experiencia do usuario.", en: "Use a value between 0 and 1. Store the previous value if you want to restore the user experience." }
+  },
+  {
+    syntax: { pt: "definirCorTema({ statusBarColor, navigationBarColor })", en: "setThemeColor({ statusBarColor, navigationBarColor })" },
+    java: "setSystemBarsColor",
+    description: { pt: "Muda as cores da barra de status e navegacao Android em tempo real.", en: "Changes Android status and navigation bar colors at runtime." },
+    returns: { pt: "{ statusBarColor, navigationBarColor, darkIcons, applied }.", en: "{ statusBarColor, navigationBarColor, darkIcons, applied }." },
+    handling: { pt: "Use quando quiser controlar manualmente. Com `themeMode: 'auto'`, o html2apk chama isso sozinho conforme a cor visivel na tela.", en: "Use when you want manual control. With `themeMode: 'auto'`, html2apk calls this automatically from the visible screen color." }
+  },
+  {
+    syntax: { pt: "abrirNoApp('/pagina.html')", en: "openInApp('/page.html')" },
+    java: "window.location",
+    description: { pt: "Navega dentro do proprio APK/WebView, bom para rotas locais, hashes ou paginas do app.", en: "Navigates inside the APK/WebView, useful for local routes, hashes or app pages." },
+    returns: { pt: "{ url, target: 'app', opened, replace }.", en: "{ url, target: 'app', opened, replace }." },
+    handling: { pt: "Use para telas internas. Passe `{ substituir: true }` se nao quiser manter a pagina anterior no historico.", en: "Use for internal screens. Pass `{ replace: true }` if you do not want to keep the previous page in history." }
+  },
+  {
+    syntax: { pt: "abrirForaDoApp('https://...')", en: "openOutsideApp('https://...')" },
+    java: "openUrl",
+    description: { pt: "Abre URL fora do APK, em navegador ou outro app Android. `abrirUrlExterno()` continua como alias.", en: "Opens a URL outside the APK, in a browser or another Android app. `openExternalUrl()` remains an alias." },
+    returns: { pt: "Promise<void>.", en: "Promise<void>." },
+    handling: { pt: "Valide a URL antes de chamar e trate erro caso nenhum app consiga abrir o endereco.", en: "Validate the URL before calling and handle errors if no app can open the address." }
+  },
+  {
+    syntax: { pt: "abrirWhatsapp('559999999999')", en: "openWhatsapp('559999999999')" },
+    java: "openWhatsapp",
+    description: { pt: "Abre conversa do WhatsApp pelo numero.", en: "Opens a WhatsApp conversation by phone number." },
+    returns: { pt: "Promise<void>.", en: "Promise<void>." },
+    handling: { pt: "Envie numero com DDI e apenas digitos. Tenha fallback para navegador se WhatsApp nao estiver disponivel.", en: "Send the phone number with country code and digits only. Keep a browser fallback if WhatsApp is unavailable." }
+  },
+  {
+    syntax: { pt: "discar('11999999999') / abrirMapa('Sao Paulo')", en: "dial('11999999999') / openMap('Sao Paulo')" },
+    java: "dial/openMap",
+    description: { pt: "Abre discador ou mapa nativo sem executar acao sensivel sozinho.", en: "Opens dialer or native map without performing sensitive action alone." },
+    returns: { pt: "Promise<void>.", en: "Promise<void>." },
+    handling: { pt: "O usuario ainda confirma chamada/rota. Mostre erro se nao houver app de telefone ou mapa.", en: "The user still confirms the call/route. Show an error if no phone or map app is available." }
+  },
+  {
+    syntax: { pt: "infoDispositivo()", en: "deviceInfo()" },
+    java: "deviceInfo",
+    description: { pt: "Retorna fabricante, modelo, Android, SDK e package name.", en: "Returns manufacturer, model, Android, SDK and package name." },
+    returns: { pt: "{ manufacturer, fabricante, model, modelo, androidVersion, sdkInt, packageName }.", en: "{ manufacturer, fabricante, model, modelo, androidVersion, sdkInt, packageName }." },
+    handling: { pt: "Use para diagnostico e ajustes de compatibilidade; nao dependa de modelo especifico para liberar recurso essencial.", en: "Use for diagnostics and compatibility tweaks; do not depend on a specific model for essential features." }
+  },
+  {
+    syntax: { pt: "infoRede() / infoBateria()", en: "networkInfo() / batteryInfo()" },
+    java: "networkInfo/batteryInfo",
+    description: { pt: "Consulta conexao atual e bateria.", en: "Reads current connection and battery." },
+    returns: { pt: "rede: { online, tipo/type }; bateria: { level, charging }.", en: "network: { online, tipo/type }; battery: { level, charging }." },
+    handling: { pt: "Combine com `aoEvento('rede:mudou')` e `aoEvento('bateria:mudou')` para atualizar a tela sem ficar consultando em loop.", en: "Combine with `onEvent('network:changed')` and `onEvent('battery:changed')` to update the UI without polling." }
+  },
+  {
+    syntax: { pt: "infoMemoria()", en: "memoryInfo()" },
+    java: "memoryInfo",
+    description: { pt: "Monitora RAM disponivel, total, baixa memoria e heap do app.", en: "Monitors available RAM, total RAM, low-memory state and app heap." },
+    returns: { pt: "{ availableBytes, totalBytes, lowMemory, appUsedBytes, appMaxBytes }.", en: "{ availableBytes, totalBytes, lowMemory, appUsedBytes, appMaxBytes }." },
+    handling: { pt: "Converta bytes para MB/GB na UI. Se `lowMemory` vier true, reduza cache, imagens grandes ou tarefas em segundo plano.", en: "Convert bytes to MB/GB in the UI. If `lowMemory` is true, reduce cache, large images or background tasks." }
+  },
+  {
+    syntax: { pt: "infoArmazenamento()", en: "storageInfo()" },
+    java: "storageInfo",
+    description: { pt: "Retorna armazenamento interno/cache disponivel e usado.", en: "Returns available and used internal/cache storage." },
+    returns: { pt: "{ internal, cache, appExternal } com bytes.", en: "{ internal, cache, appExternal } in bytes." },
+    handling: { pt: "Antes de salvar arquivos grandes, compare o tamanho com `availableBytes` e mostre aviso se faltar espaco.", en: "Before saving large files, compare size with `availableBytes` and warn when there is not enough space." }
+  },
+  {
+    syntax: { pt: "infoDesempenho()", en: "performanceInfo()" },
+    java: "performanceInfo",
+    description: { pt: "Agrupa memoria, armazenamento, bateria, rede e timestamp.", en: "Groups memory, storage, battery, network and timestamp." },
+    returns: { pt: "{ timestamp, memory, storage, battery, network }.", en: "{ timestamp, memory, storage, battery, network }." },
+    handling: { pt: "Ideal para uma tela de diagnostico. Atualize com intervalo moderado, por exemplo a cada 5 ou 10 segundos.", en: "Ideal for a diagnostics screen. Refresh at a moderate interval, for example every 5 or 10 seconds." }
+  },
+  {
+    syntax: { pt: "appsAbertos()", en: "openAppsMemory()" },
+    java: "openAppsMemory",
+    description: { pt: "Lista processos/apps que o Android permite ver e estima RAM por app. Android moderno pode retornar apenas o proprio app por privacidade.", en: "Lists processes/apps Android allows this app to see and estimates RAM per app. Modern Android may only return this app for privacy." },
+    returns: { pt: "{ apps: [{ name, packageName, ramBytes, ramMb }], porNome, limited, observacao }.", en: "{ apps: [{ name, packageName, ramBytes, ramMb }], byName, limited, note }." },
+    handling: { pt: "Use como diagnostico aproximado. Se `limited` vier true ou `apps` vier pequeno, explique que o Android bloqueou visao completa.", en: "Use it as approximate diagnostics. If `limited` is true or `apps` is small, explain that Android blocked full visibility." }
+  },
+  {
+    syntax: { pt: "iniciarIconeFlutuante() / pararIconeFlutuante()", en: "startFloatingIcon() / stopFloatingIcon()" },
+    java: "FloatingIconService",
+    description: { pt: "Controla o icone flutuante quando o app foi gerado em modo floating.", en: "Controls the floating icon when the app was generated in floating mode." },
+    returns: { pt: "Promise<void>.", en: "Promise<void>." },
+    handling: { pt: "`iniciarIconeFlutuante()` abre a tela de permissao automaticamente se faltar sobreposicao. Quando o usuario voltar, chame novamente para iniciar.", en: "`startFloatingIcon()` opens the permission screen automatically if draw-over-apps is missing. When the user comes back, call it again to start." }
+  }
+];
+
+const nativeCodeRecipes = [
+  {
+    when: { pt: "Para avisos curtos dentro do app, como sucesso, erro simples ou confirmacao.", en: "For short in-app feedback such as success, simple errors or confirmations." },
+    example: {
+      pt: `try {
+  await toast("Salvo com sucesso");
+} catch (erro) {
+  console.error("Toast falhou", erro);
+}`,
+      en: `try {
+  await toast("Saved successfully");
+} catch (error) {
+  console.error("Toast failed", error);
+}`
+    }
+  },
+  {
+    when: { pt: "Para dar feedback fisico em botoes, alertas ou acoes importantes.", en: "For physical feedback on buttons, alerts or important actions." },
+    example: {
+      pt: `await vibrar(250);`,
+      en: `await vibrate(250);`
+    }
+  },
+  {
+    when: { pt: "Para mostrar uma notificacao agora. A permissao aparece automaticamente se o Android exigir.", en: "To show a notification now. Permission appears automatically if Android requires it." },
+    example: {
+      pt: `await notificar({
+  titulo: "Pedido aprovado",
+  texto: "Toque para abrir os detalhes",
+  aoClicar: { acao: "abrir-pedido", id: 123 }
+});`,
+      en: `await notify({
+  title: "Order approved",
+  text: "Tap to open details",
+  onClick: { action: "open-order", id: 123 }
+});`
+    }
+  },
+  {
+    when: { pt: "Para lembrar o usuario depois, mesmo se o app nao estiver aberto.", en: "To remind the user later, even if the app is not open." },
+    example: {
+      pt: `const aviso = await agendarNotificacao({
+  titulo: "Lembrete",
+  texto: "Volte ao app daqui 1 minuto",
+  quando: Date.now() + 60 * 1000
+});
+
+console.log("ID para cancelar depois:", aviso.id);`,
+      en: `const reminder = await scheduleNotification({
+  title: "Reminder",
+  text: "Come back in 1 minute",
+  when: Date.now() + 60 * 1000
+});
+
+console.log("ID to cancel later:", reminder.id);`
+    }
+  },
+  {
+    when: { pt: "Para uma sequencia recorrente de notificacoes, como a cada 12 horas.", en: "For a repeating sequence of notifications, such as every 12 hours." },
+    example: {
+      pt: `const loop = await agendarLoopNotificacoes({
+  aCada: "12h",
+  notificacoes: [
+    { titulo: "Agua", texto: "Beba agua agora" },
+    { titulo: "Alongar", texto: "Faca uma pausa rapida" }
+  ]
+});
+
+// Depois, se quiser parar:
+// await cancelarNotificacao(loop.id);`,
+      en: `const loop = await scheduleNotificationLoop({
+  every: "12h",
+  notifications: [
+    { title: "Water", text: "Drink water now" },
+    { title: "Stretch", text: "Take a quick break" }
+  ]
+});
+
+// Later, to stop it:
+// await cancelNotification(loop.id);`
+    }
+  },
+  {
+    when: { pt: "Opcional: use se quiser pedir a permissao antes de chamar notificacoes.", en: "Optional: use it if you want to ask permission before calling notifications." },
+    example: {
+      pt: `const permissao = await solicitarPermissaoNotificacoes();
+
+if (!permissao.granted) {
+  if (permissao.settingsOpened) {
+    console.log("O Android abriu as configuracoes do app");
+  }
+}`,
+      en: `const permission = await requestNotificationPermission();
+
+if (!permission.granted) {
+  if (permission.settingsOpened) {
+    console.log("Android opened the app settings");
+  }
+}`
+    }
+  },
+  {
+    when: { pt: "Para push remoto enviado pelo painel/API do OneSignal. Requer OneSignal App ID no build.", en: "For remote push sent by the OneSignal dashboard/API. Requires OneSignal App ID in the build." },
+    example: {
+      pt: `const permitido = await solicitarPermissaoPush();
+
+if (permitido) {
+  await identificarUsuarioPush("usuario-123");
+  await adicionarTagPush("plano", "premium");
+}
+
+const parar = aoClicarPush((evento) => {
+  abrirNoApp("#/notificacoes");
+});`,
+      en: `const allowed = await requestPushPermission();
+
+if (allowed) {
+  await loginPushUser("user-123");
+  await addPushTag("plan", "premium");
+}
+
+const stop = onPushClick((event) => {
+  openInApp("#/notifications");
+});`
+    }
+  },
+  {
+    when: { pt: "Para consultar permissoes sem abrir uma solicitacao na tela.", en: "To check permissions without opening a permission prompt." },
+    example: {
+      pt: `const permissoes = await statusPermissoes([
+  "CAMERA",
+  "RECORD_AUDIO",
+  "POST_NOTIFICATIONS"
+]);
+
+console.log(permissoes);`,
+      en: `const permissions = await permissionStatus([
+  "CAMERA",
+  "RECORD_AUDIO",
+  "POST_NOTIFICATIONS"
+]);
+
+console.log(permissions);`
+    }
+  },
+  {
+    when: { pt: "Para reagir a eventos do Android, como app indo para segundo plano ou clique em notificacao.", en: "To react to Android events, such as backgrounding or notification clicks." },
+    example: {
+      pt: `const parar = aoEvento("app:background", (evento) => {
+  console.log("Saiu da frente", evento.timestamp);
+});
+
+// Quando nao precisar mais:
+// parar();`,
+      en: `const stop = onEvent("app:background", (event) => {
+  console.log("Moved to background", event.timestamp);
+});
+
+// When you no longer need it:
+// stop();`
+    }
+  },
+  {
+    when: { pt: "Para pausar/resumir tarefas quando o usuario minimiza ou volta para o app.", en: "To pause/resume work when the user minimizes or returns to the app." },
+    example: {
+      pt: `const pararMinimizar = aoMinimizar(() => {
+  console.log("Pause videos, timers ou leituras pesadas");
+});
+
+const pararVoltar = aoVoltarParaApp(() => {
+  console.log("Atualize dados se precisar");
+});`,
+      en: `const stopMinimize = onMinimize(() => {
+  console.log("Pause videos, timers or heavy reads");
+});
+
+const stopResume = onAppResume(() => {
+  console.log("Refresh data if needed");
+});`
+    }
+  },
+  {
+    when: { pt: "Para abrir uma tela especifica quando o APK foi chamado por link.", en: "To open a specific screen when the APK was launched from a link." },
+    example: {
+      pt: `const linkInicial = await obterLinkInicial();
+if (linkInicial) {
+  abrirNoApp("#" + linkInicial.path);
+}
+
+aoAbrirLink((link) => {
+  console.log("Link recebido", link.url);
+});`,
+      en: `const initialLink = await getInitialLink();
+if (initialLink) {
+  openInApp("#" + initialLink.path);
+}
+
+onOpenLink((link) => {
+  console.log("Link received", link.url);
+});`
+    }
+  },
+  {
+    when: { pt: "Opcional: use antes da lanterna se quiser explicar a permissao ao usuario.", en: "Optional: use it before flashlight if you want to explain the permission." },
+    example: {
+      pt: `const camera = await solicitarPermissaoCamera();
+
+if (camera.granted) {
+  await lanterna(true);
+} else if (camera.settingsOpened) {
+  console.log("Libere Camera nas configuracoes e volte ao app");
+}`,
+      en: `const camera = await requestCameraPermission();
+
+if (camera.granted) {
+  await flashlight(true);
+} else if (camera.settingsOpened) {
+  console.log("Allow Camera in settings and return to the app");
+}`
+    }
+  },
+  {
+    when: { pt: "Para gravar audio curto pelo microfone e receber o arquivo em base64.", en: "To record short audio from the microphone and receive the file as base64." },
+    example: {
+      pt: `const inicio = await ouvirMic();
+if (inicio.settingsOpened) {
+  console.log("Libere Microfone nas configuracoes e tente de novo");
+  return;
+}
+
+setTimeout(async () => {
+  const audio = await pararMic();
+  const url = "data:" + audio.mimeType + ";base64," + audio.base64;
+  new Audio(url).play();
+}, 3000);`,
+      en: `const start = await listenMic();
+if (start.settingsOpened) {
+  console.log("Allow Microphone in settings and try again");
+  return;
+}
+
+setTimeout(async () => {
+  const audio = await stopMic();
+  const url = "data:" + audio.mimeType + ";base64," + audio.base64;
+  new Audio(url).play();
+}, 3000);`
+    }
+  },
+  {
+    when: { pt: "Para ligar ou desligar a lanterna. A permissao de camera e pedida automaticamente.", en: "To turn the flashlight on or off. Camera permission is requested automatically." },
+    example: {
+      pt: `const status = await lanterna(true);
+
+if (status.settingsOpened) {
+  console.log("Libere Camera nas configuracoes e chame lanterna(true) de novo");
+} else if (!status.available) {
+  await toast("Este aparelho nao tem lanterna");
+}`,
+      en: `const status = await flashlight(true);
+
+if (status.settingsOpened) {
+  console.log("Allow Camera in settings and call flashlight(true) again");
+} else if (!status.available) {
+  await toast("This device has no flashlight");
+}`
+    }
+  },
+  {
+    when: { pt: "Para um botao que liga/desliga a lanterna sem guardar estado manualmente.", en: "For a button that toggles flashlight without tracking state manually." },
+    example: {
+      pt: `const status = await alternarLanterna();
+console.log("Lanterna ligada?", status.enabled);`,
+      en: `const status = await toggleFlashlight();
+console.log("Flashlight on?", status.enabled);`
+    }
+  },
+  {
+    when: { pt: "Para deixar o usuario escolher uma foto da galeria ou arquivos de imagem.", en: "To let the user choose a photo from gallery or image files." },
+    example: {
+      pt: `const imagem = await escolherImagem();
+
+if (imagem) {
+  document.querySelector("img.preview").src = imagem.uri;
+}`,
+      en: `const image = await pickImage();
+
+if (image) {
+  document.querySelector("img.preview").src = image.uri;
+}`
+    }
+  },
+  {
+    when: { pt: "Para galeria com selecao multipla, como anexar varias fotos.", en: "For multiple gallery selection, such as attaching many photos." },
+    example: {
+      pt: `const imagens = await escolherImagens({ multiplo: true });
+
+for (const imagem of imagens) {
+  console.log(imagem.nome, imagem.tamanho);
+}`,
+      en: `const images = await pickImages({ multiple: true });
+
+for (const image of images) {
+  console.log(image.name, image.size);
+}`
+    }
+  },
+  {
+    when: { pt: "Para escolher PDF, ZIP, TXT ou qualquer tipo de documento.", en: "To choose PDF, ZIP, TXT or any document type." },
+    example: {
+      pt: `const pdf = await escolherArquivo({
+  tipos: ["application/pdf"]
+});
+
+if (pdf) {
+  console.log("PDF escolhido:", pdf.nome);
+}`,
+      en: `const pdf = await pickFile({
+  types: ["application/pdf"]
+});
+
+if (pdf) {
+  console.log("Chosen PDF:", pdf.name);
+}`
+    }
+  },
+  {
+    when: { pt: "Para anexar varios arquivos de uma vez.", en: "To attach multiple files at once." },
+    example: {
+      pt: `const arquivos = await escolherArquivos({ multiplo: true });
+
+const total = arquivos.reduce((soma, arquivo) => {
+  return soma + (arquivo.tamanho || 0);
+}, 0);
+
+console.log("Total em bytes:", total);`,
+      en: `const files = await pickFiles({ multiple: true });
+
+const total = files.reduce((sum, file) => {
+  return sum + (file.size || 0);
+}, 0);
+
+console.log("Total bytes:", total);`
+    }
+  },
+  {
+    when: { pt: "Para pedir um video do usuario sem mostrar documentos que nao sejam video.", en: "To ask the user for a video without showing non-video documents." },
+    example: {
+      pt: `const video = await escolherVideo();
+
+if (video && video.tamanho > 50 * 1024 * 1024) {
+  await toast("Video muito grande");
+}`,
+      en: `const video = await pickVideo();
+
+if (video && video.size > 50 * 1024 * 1024) {
+  await toast("Video is too large");
+}`
+    }
+  },
+  {
+    when: { pt: "Para o usuario escolher uma pasta quando o Android permitir acesso por URI.", en: "To let the user choose a folder when Android allows URI access." },
+    example: {
+      pt: `const pasta = await escolherPasta();
+
+if (pasta.uri) {
+  console.log("Pasta escolhida:", pasta.uri);
+}`,
+      en: `const folder = await pickFolder();
+
+if (folder.uri) {
+  console.log("Chosen folder:", folder.uri);
+}`
+    }
+  },
+  {
+    when: { pt: "Para salvar texto ou base64 em um arquivo escolhido pelo usuario.", en: "To save text or base64 to a file chosen by the user." },
+    example: {
+      pt: `const salvo = await salvarArquivo({
+  nome: "relatorio.txt",
+  mimeType: "text/plain",
+  conteudo: "Conteudo do relatorio"
+});
+
+if (salvo.saved) {
+  await toast("Arquivo salvo");
+}`,
+      en: `const saved = await saveFile({
+  name: "report.txt",
+  mimeType: "text/plain",
+  content: "Report content"
+});
+
+if (saved.saved) {
+  await toast("File saved");
+}`
+    }
+  },
+  {
+    when: { pt: "Para abrir o compartilhamento nativo do Android com texto e/ou link.", en: "To open Android native sharing with text and/or link." },
+    example: {
+      pt: `await compartilhar({
+  texto: "Veja esse app",
+  url: "https://exemplo.com"
+});`,
+      en: `await share({
+  text: "Check this app",
+  url: "https://example.com"
+});`
+    }
+  },
+  {
+    when: { pt: "Para copiar dados para a area de transferencia ou ler o que esta copiado.", en: "To copy data to the clipboard or read what is copied." },
+    example: {
+      pt: `await copiarTexto("ABC-123");
+await toast("Codigo copiado");
+
+const copiado = await lerTextoCopiado();
+console.log(copiado);`,
+      en: `await copyText("ABC-123");
+await toast("Code copied");
+
+const copied = await readText();
+console.log(copied);`
+    }
+  },
+  {
+    when: { pt: "Para impedir que a tela apague em leitura, video, mapa ou monitoramento.", en: "To keep screen awake during reading, video, maps or monitoring." },
+    example: {
+      pt: `await manterTelaLigada(true);
+
+// Ao sair da tela:
+await manterTelaLigada(false);`,
+      en: `await keepScreenOn(true);
+
+// When leaving the screen:
+await keepScreenOn(false);`
+    }
+  },
+  {
+    when: { pt: "Para controlar o brilho so dentro do APK, sem mudar o brilho do sistema todo.", en: "To control brightness only inside the APK, without changing the whole system brightness." },
+    example: {
+      pt: `await brilhoTela(0.8);
+
+// Restaurar comportamento padrao:
+await brilhoTela(-1);`,
+      en: `await setScreenBrightness(0.8);
+
+// Restore default behavior:
+await setScreenBrightness(-1);`
+    }
+  },
+  {
+    when: { pt: "Para combinar status bar/navigation bar com uma tela especifica do app.", en: "To match status/navigation bars with a specific app screen." },
+    example: {
+      pt: `await definirCorTema({
+  statusBarColor: "#126fff",
+  navigationBarColor: "#101827"
+});`,
+      en: `await setThemeColor({
+  statusBarColor: "#126fff",
+  navigationBarColor: "#101827"
+});`
+    }
+  },
+  {
+    when: { pt: "Para navegar dentro do proprio WebView do APK.", en: "To navigate inside the APK WebView itself." },
+    example: {
+      pt: `await abrirNoApp("#/perfil");
+
+// Sem deixar voltar para a tela anterior:
+await abrirNoApp("#/login", { substituir: true });`,
+      en: `await openInApp("#/profile");
+
+// Without keeping the previous screen:
+await openInApp("#/login", { replace: true });`
+    }
+  },
+  {
+    when: { pt: "Para abrir navegador, outro app ou link externo fora do APK.", en: "To open browser, another app or external link outside the APK." },
+    example: {
+      pt: `await abrirForaDoApp("https://exemplo.com");`,
+      en: `await openOutsideApp("https://example.com");`
+    }
+  },
+  {
+    when: { pt: "Para abrir uma conversa do WhatsApp com numero e mensagem opcional.", en: "To open a WhatsApp conversation with phone number and optional message." },
+    example: {
+      pt: `await abrirWhatsapp(
+  "559999999999",
+  "Oi, vim pelo app"
+);`,
+      en: `await openWhatsapp(
+  "559999999999",
+  "Hi, I came from the app"
+);`
+    }
+  },
+  {
+    when: { pt: "Para abrir o discador ou o app de mapas sem fazer a acao sozinho.", en: "To open dialer or maps without performing the action automatically." },
+    example: {
+      pt: `await discar("11999999999");
+await abrirMapa("Avenida Paulista, Sao Paulo");`,
+      en: `await dial("11999999999");
+await openMap("Avenida Paulista, Sao Paulo");`
+    }
+  },
+  {
+    when: { pt: "Para diagnostico, suporte ou pequenas adaptacoes por versao do Android.", en: "For diagnostics, support or small adaptations by Android version." },
+    example: {
+      pt: `const aparelho = await infoDispositivo();
+
+console.log(aparelho.modelo, aparelho.androidVersion);`,
+      en: `const device = await deviceInfo();
+
+console.log(device.model, device.androidVersion);`
+    }
+  },
+  {
+    when: { pt: "Para adaptar a UI quando ficar offline ou quando a bateria estiver baixa.", en: "To adapt the UI when offline or when battery is low." },
+    example: {
+      pt: `const rede = await infoRede();
+const bateria = await infoBateria();
+
+if (!rede.online) {
+  await toast("Sem internet");
+}`,
+      en: `const network = await networkInfo();
+const battery = await batteryInfo();
+
+if (!network.online) {
+  await toast("No internet");
+}`
+    }
+  },
+  {
+    when: { pt: "Para saber se o app deve reduzir imagens, cache ou tarefas pesadas.", en: "To know whether the app should reduce images, cache or heavy tasks." },
+    example: {
+      pt: `const memoria = await infoMemoria();
+const mbLivre = memoria.availableBytes / 1024 / 1024;
+
+if (memoria.lowMemory) {
+  console.log("Reduza cache. MB livre:", mbLivre);
+}`,
+      en: `const memory = await memoryInfo();
+const freeMb = memory.availableBytes / 1024 / 1024;
+
+if (memory.lowMemory) {
+  console.log("Reduce cache. Free MB:", freeMb);
+}`
+    }
+  },
+  {
+    when: { pt: "Para conferir espaco antes de baixar ou salvar arquivos grandes.", en: "To check space before downloading or saving large files." },
+    example: {
+      pt: `const armazenamento = await infoArmazenamento();
+const livre = armazenamento.internal.availableBytes;
+
+console.log("Livre em MB:", Math.round(livre / 1024 / 1024));`,
+      en: `const storage = await storageInfo();
+const free = storage.internal.availableBytes;
+
+console.log("Free MB:", Math.round(free / 1024 / 1024));`
+    }
+  },
+  {
+    when: { pt: "Para uma tela de diagnostico com memoria, armazenamento, bateria e rede juntos.", en: "For a diagnostics screen with memory, storage, battery and network together." },
+    example: {
+      pt: `const desempenho = await infoDesempenho();
+
+console.log(desempenho.memory);
+console.log(desempenho.storage);
+console.log(desempenho.battery);`,
+      en: `const performance = await performanceInfo();
+
+console.log(performance.memory);
+console.log(performance.storage);
+console.log(performance.battery);`
+    }
+  },
+  {
+    when: { pt: "Para diagnostico aproximado de processos que o Android deixa o APK enxergar.", en: "For approximate diagnostics of processes Android lets the APK see." },
+    example: {
+      pt: `const resultado = await appsAbertos();
+
+for (const app of resultado.apps) {
+  console.log(app.nome, app.ramMb + " MB");
+}`,
+      en: `const result = await openAppsMemory();
+
+for (const app of result.apps) {
+  console.log(app.name, app.ramMb + " MB");
+}`
+    }
+  },
+  {
+    when: { pt: "Para apps em modo floating que precisam mostrar/esconder o icone flutuante.", en: "For floating-mode apps that need to show/hide the floating icon." },
+    example: {
+      pt: `const status = await iniciarIconeFlutuante();
+
+if (status.requiresSettings) {
+  console.log("O Android abriu a tela de sobreposicao");
+}
+
+// Para desligar:
+// await pararIconeFlutuante();`,
+      en: `const status = await startFloatingIcon();
+
+if (status.requiresSettings) {
+  console.log("Android opened the draw-over-apps screen");
+}
+
+// To turn it off:
+// await stopFloatingIcon();`
+    }
+  }
 ];
 
 const state = {
@@ -348,6 +1273,7 @@ const state = {
   buildRunning: false,
   lastApkPath: null,
   lastDistPath: null,
+  defaultIconPath: "",
   animationTimer: null,
   progress: 0,
   logsVisible: localStorage.getItem("html2apk.logsVisible") === "true"
@@ -383,6 +1309,7 @@ function collectElements() {
     "entryPath",
     "doctorButton",
     "buildButton",
+    "usbDebugButton",
     "appNameInput",
     "packageIdInput",
     "versionInput",
@@ -390,8 +1317,10 @@ function collectElements() {
     "orientationInput",
     "minSdkVersionInput",
     "androidPlatformInput",
+    "themeModeInput",
     "themeColorInput",
     "themeColorTextInput",
+    "oneSignalAppIdInput",
     "permissionGrid",
     "iconPathInput",
     "iconPreview",
@@ -413,6 +1342,8 @@ function collectElements() {
     "apkPath",
     "openDistButton",
     "showApkButton",
+    "successTitle",
+    "successText",
     "successApkPath",
     "successOpenDistButton",
     "successShowApkButton",
@@ -423,6 +1354,7 @@ function collectElements() {
     "toggleLogsButton",
     "bottomToggleLogsButton",
     "bottomClearLogsButton",
+    "devInstagramButton",
     "minimizeButton",
     "maximizeButton",
     "closeButton",
@@ -524,6 +1456,15 @@ function toggleLogBar() {
   applyLogBarVisibility();
 }
 
+function showLogBar() {
+  if (state.logsVisible) {
+    return;
+  }
+
+  state.logsVisible = true;
+  applyLogBarVisibility();
+}
+
 function clearLogs() {
   elements.logConsole.innerHTML = "";
   if (elements.bottomLogConsole) {
@@ -586,6 +1527,7 @@ function updateActionButtons() {
 
 function setBuildButtons(enabled) {
   elements.buildButton.disabled = !enabled;
+  elements.usbDebugButton.disabled = !enabled;
 }
 
 function packageSegment(value) {
@@ -612,12 +1554,16 @@ function toFileUrl(filePath) {
   return `file:///${String(filePath).replace(/\\/g, "/").replace(/^\/+/, "")}`;
 }
 
+function defaultIconPath() {
+  return state.defaultIconPath || "";
+}
+
 function isAbsolutePath(filePath) {
   return /^[a-zA-Z]:[\\/]/.test(String(filePath || "")) || String(filePath || "").startsWith("/");
 }
 
 function iconPreviewPath(iconPath) {
-  if (!iconPath || !state.project) {
+  if (!iconPath) {
     return "../../../html2apk.png";
   }
   if (isAbsolutePath(iconPath)) {
@@ -626,6 +1572,18 @@ function iconPreviewPath(iconPath) {
   return toFileUrl(`${state.project.projectRoot}\\${iconPath}`);
 }
 
+function displayIconValue(iconPath) {
+  const value = String(iconPath || "").trim();
+  if (!value || (state.defaultIconPath && value === state.defaultIconPath)) {
+    return text("defaultIcon");
+  }
+  return value;
+}
+
+function isConfigFilePath(filePath) {
+  return /(^|[\\/])(app|config)\.json$/i.test(String(filePath || ""));
+}
+
 function escapeHtml(value) {
   return String(value || "")
     .replace(/&/g, "&amp;")
@@ -634,6 +1592,61 @@ function escapeHtml(value) {
     .replace(/"/g, "&quot;");
 }
 
+function recipeForCode(index) {
+  const language = currentLanguage();
+  const recipe = nativeCodeRecipes[index] || {};
+  return {
+    when: recipe.when ? recipe.when[language] || recipe.when.pt : "",
+    example: recipe.example ? recipe.example[language] || recipe.example.pt : ""
+  };
+}
+
+async function copyToClipboard(value) {
+  const textValue = String(value || "");
+  if (navigator.clipboard && navigator.clipboard.writeText) {
+    await navigator.clipboard.writeText(textValue);
+    return;
+  }
+
+  const textarea = document.createElement("textarea");
+  textarea.value = textValue;
+  textarea.setAttribute("readonly", "");
+  textarea.style.position = "fixed";
+  textarea.style.left = "-9999px";
+  document.body.appendChild(textarea);
+  textarea.select();
+  document.execCommand("copy");
+  textarea.remove();
+}
+
+async function handleNativeCodeCopy(event) {
+  const button = event.target.closest("[data-copy-code]");
+  if (!button) {
+    return;
+  }
+
+  const index = Number.parseInt(button.dataset.copyCode, 10);
+  const recipe = recipeForCode(index);
+  if (!recipe.example) {
+    return;
+  }
+
+  const originalText = button.textContent;
+  try {
+    await copyToClipboard(recipe.example);
+    button.textContent = text("copiedCode");
+    button.classList.add("copied");
+  } catch (error) {
+    button.textContent = text("copyFailed");
+    button.classList.add("copy-error");
+  }
+
+  setTimeout(() => {
+    button.textContent = originalText || text("copyCode");
+    button.classList.remove("copied", "copy-error");
+  }, 1400);
+}
+
 function selectedOptionText(select) {
   if (!select || !select.selectedOptions || !select.selectedOptions.length) {
     return select ? select.value : "";
@@ -706,19 +1719,69 @@ function normalizeMinSdkVersion(value) {
   return MIN_SDK_OPTIONS.includes(parsed) ? parsed : DEFAULT_MIN_SDK_VERSION;
 }
 
+function normalizeThemeMode(value) {
+  return String(value || "").trim().toLowerCase() === "auto" ? "auto" : "fixed";
+}
+
+function normalizeOneSignalAppId(value) {
+  return String(value || "").trim();
+}
+
+function oneSignalAppIdFromConfig(config = {}) {
+  return normalizeOneSignalAppId(
+    config.oneSignalAppId
+      || config.onesignalAppId
+      || (config.oneSignal && config.oneSignal.appId)
+      || (config.onesignal && config.onesignal.appId)
+      || ""
+  );
+}
+
+function isValidOptionalOneSignalAppId(value) {
+  const appId = normalizeOneSignalAppId(value);
+  return appId.length === 0 || /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(appId);
+}
+
 function renderNativeCodeGrid() {
   if (!elements.nativeCodeGrid) {
     return;
   }
 
   const language = currentLanguage();
-  elements.nativeCodeGrid.innerHTML = nativeCodeEntries.map((entry) => `
+  const javaLabel = text("javaLabel");
+  const doesLabel = text("doesLabel");
+  const whenUseLabel = text("whenUseLabel");
+  const returnsLabel = text("returnsLabel");
+  const handlingLabel = text("handlingLabel");
+  const exampleLabel = text("exampleLabel");
+  const copyCodeLabel = text("copyCode");
+  elements.nativeCodeGrid.innerHTML = nativeCodeEntries.map((entry, index) => {
+    const syntax = entry.syntax ? entry.syntax[language] || entry.syntax.pt : entry.js;
+    const description = entry.description[language] || entry.description.pt;
+    const returns = entry.returns[language] || entry.returns.pt;
+    const handling = entry.handling[language] || entry.handling.pt;
+    const recipe = recipeForCode(index);
+
+    return `
     <article class="code-card">
-      <code>${escapeHtml(entry.js)}</code>
-      <span>Java: ${escapeHtml(entry.java)}</span>
-      <p>${escapeHtml(entry.description[language] || entry.description.pt)}</p>
+      <div class="code-card-top">
+        <code>${escapeHtml(syntax)}</code>
+        <span>${escapeHtml(javaLabel)}: ${escapeHtml(entry.java)}</span>
+      </div>
+      <p><strong>${escapeHtml(doesLabel)}:</strong> ${escapeHtml(description)}</p>
+      <small><strong>${escapeHtml(whenUseLabel)}:</strong> ${escapeHtml(recipe.when)}</small>
+      <small><strong>${escapeHtml(returnsLabel)}:</strong> ${escapeHtml(returns)}</small>
+      <small class="handling"><strong>${escapeHtml(handlingLabel)}:</strong> ${escapeHtml(handling)}</small>
+      <div class="copy-example">
+        <div class="copy-example-header">
+          <strong>${escapeHtml(exampleLabel)}</strong>
+          <button type="button" class="copy-code-button" data-copy-code="${index}">${escapeHtml(copyCodeLabel)}</button>
+        </div>
+        <pre><code>${escapeHtml(recipe.example)}</code></pre>
+      </div>
     </article>
-  `).join("");
+  `;
+  }).join("");
 }
 
 function populateSettings(config = {}, project = state.project) {
@@ -730,12 +1793,15 @@ function populateSettings(config = {}, project = state.project) {
   elements.orientationInput.value = normalizeOrientationInputValue(config.orientation);
   elements.minSdkVersionInput.value = String(normalizeMinSdkVersion(config.minSdkVersion || config.androidMinSdkVersion));
   elements.androidPlatformInput.value = config.androidPlatform || "android@15.0.0";
+  elements.themeModeInput.value = normalizeThemeMode(config.themeMode || config.theme || (String(config.themeColor || "").toLowerCase() === "auto" ? "auto" : "fixed"));
   const themeColor = normalizeHexColor(config.themeColor || config.splashBackgroundColor || config.backgroundColor);
   elements.themeColorInput.value = themeColor;
   elements.themeColorTextInput.value = themeColor;
+  elements.oneSignalAppIdInput.value = oneSignalAppIdFromConfig(config);
   renderPermissionOptions(Array.isArray(config.permissions) && config.permissions.length ? config.permissions : DEFAULT_PERMISSIONS);
-  elements.iconPathInput.value = config.icon || "";
-  elements.iconPreview.src = iconPreviewPath(config.icon || "");
+  const iconPath = String(config.icon || "").trim() || defaultIconPath();
+  elements.iconPathInput.value = iconPath;
+  elements.iconPreview.src = iconPreviewPath(iconPath);
   elements.debugInput.checked = Boolean(config.debug);
   elements.releaseInput.checked = Boolean(config.release);
 }
@@ -766,9 +1832,10 @@ function validateSettings() {
   if (!/^#[0-9a-fA-F]{6}$/.test(elements.themeColorTextInput.value.trim())) {
     errors.push(text("invalidThemeColor"));
   }
-  if (!elements.iconPathInput.value.trim()) {
-    errors.push(text("missingIcon"));
-  } else if (!/\.png$/i.test(elements.iconPathInput.value.trim())) {
+  if (!isValidOptionalOneSignalAppId(elements.oneSignalAppIdInput.value)) {
+    errors.push(text("invalidOneSignalAppId"));
+  }
+  if (elements.iconPathInput.value.trim() && !/\.png$/i.test(elements.iconPathInput.value.trim())) {
     errors.push(text("invalidIconType"));
   }
 
@@ -811,9 +1878,11 @@ function renderReview() {
     [text("mode"), selectedOptionText(elements.modeInput)],
     [text("orientation"), selectedOptionText(elements.orientationInput)],
     [text("minSdkVersion"), selectedOptionText(elements.minSdkVersionInput)],
+    [text("themeMode"), selectedOptionText(elements.themeModeInput)],
     [text("appThemeColor"), elements.themeColorTextInput.value.trim()],
+    [text("oneSignalAppId"), elements.oneSignalAppIdInput.value.trim() || "-"],
     [text("androidPermissions"), selectedPermissions().join(", ")],
-    [text("appIcon"), elements.iconPathInput.value.trim()]
+    [text("appIcon"), displayIconValue(elements.iconPathInput.value.trim())]
   ];
 
   elements.reviewGrid.innerHTML = items.map(([label, value]) => `
@@ -976,22 +2045,67 @@ async function ensureEnvironmentBeforeSettings() {
   return ready;
 }
 
-async function summarizeProject(project) {
+function renderProjectSnapshot(project) {
   state.project = project;
-  state.doctorOk = false;
-  state.environmentOk = false;
-  state.environmentChecking = false;
-  state.environmentFailed = false;
-  state.settingsValid = false;
-  state.lastApkPath = null;
   state.lastDistPath = project.distPath;
-
   elements.projectSummary.classList.remove("hidden");
   elements.projectName.textContent = project.name;
   elements.projectPath.textContent = project.projectRoot;
   elements.configStatus.textContent = project.hasAppJson || project.hasConfigJson ? text("detected") : text("notDetected");
   elements.entryStatus.textContent = project.hasEntryFile ? text("detected") : text("missing");
   elements.entryPath.textContent = project.entryPath;
+}
+
+async function watchCurrentProject() {
+  if (!state.project || !api.watchProject) {
+    return;
+  }
+
+  try {
+    const result = await api.watchProject(state.project.projectRoot);
+    if (result && !result.ok) {
+      appendLog(`${text("projectWatcherFail")}: ${result.message}`, "error");
+    }
+  } catch (error) {
+    appendLog(`${text("projectWatcherFail")}: ${error.message}`, "error");
+  }
+}
+
+function applyProjectChange(payload) {
+  if (!payload || !payload.project || !state.project) {
+    return;
+  }
+
+  if (payload.project.projectRoot !== state.project.projectRoot) {
+    return;
+  }
+
+  renderProjectSnapshot(payload.project);
+
+  const reloadSettings = isConfigFilePath(payload.changedPath);
+  if (reloadSettings && !state.buildRunning) {
+    populateSettings(payload.project.config || {}, payload.project);
+    appendLog(text("projectConfigReloaded"), "system");
+  } else {
+    appendLog(`${text("projectAutoUpdated")}: ${payload.changedPath || payload.project.projectRoot}`, "system");
+  }
+
+  setStep("folder", payload.project.hasEntryFile ? "done" : "active", payload.project.hasEntryFile ? text("folderReady") : text("missing"));
+  validateSettings();
+  if (document.querySelector(".nav-item.active")?.dataset.view === "build") {
+    renderReview();
+  }
+}
+
+async function summarizeProject(project) {
+  renderProjectSnapshot(project);
+  state.doctorOk = false;
+  state.environmentOk = false;
+  state.environmentChecking = false;
+  state.environmentFailed = false;
+  state.settingsValid = false;
+  state.lastApkPath = null;
+
   elements.nextSettingsButton.disabled = false;
   elements.doctorButton.disabled = true;
   setBuildButtons(false);
@@ -1005,6 +2119,7 @@ async function summarizeProject(project) {
   appendLog(`${text("droppedFolder")}: ${project.projectRoot}`, "system");
   validateSettings();
   setProgress(project.hasEntryFile ? 25 : 15, project.hasEntryFile ? text("progressFolder") : text("missing"), project.hasEntryFile ? "" : "error");
+  await watchCurrentProject();
   await ensureEnvironmentBeforeSettings();
 }
 
@@ -1049,6 +2164,9 @@ function buildOptions() {
     orientation: elements.orientationInput.value,
     minSdkVersion: normalizeMinSdkVersion(elements.minSdkVersionInput.value),
     themeColor: normalizeHexColor(elements.themeColorTextInput.value),
+    themeMode: normalizeThemeMode(elements.themeModeInput.value),
+    theme: normalizeThemeMode(elements.themeModeInput.value),
+    oneSignalAppId: normalizeOneSignalAppId(elements.oneSignalAppIdInput.value),
     permissions: selectedPermissions(),
     icon: elements.iconPathInput.value.trim(),
     androidPlatform: elements.androidPlatformInput.value.trim(),
@@ -1082,6 +2200,7 @@ async function runBuildFlow() {
     return;
   }
 
+  showLogBar();
   state.buildRunning = true;
   updateActionButtons();
   elements.resultPanel.classList.add("hidden");
@@ -1118,6 +2237,8 @@ async function runBuildFlow() {
     state.lastApkPath = result.apkPath;
     state.lastDistPath = state.project.distPath;
     elements.apkPath.textContent = result.apkPath;
+    elements.successTitle.textContent = text("successTitle");
+    elements.successText.textContent = text("successText");
     elements.successApkPath.textContent = result.apkPath;
     elements.resultPanel.classList.remove("hidden");
     setStep("build", "done", text("buildOk"));
@@ -1137,6 +2258,74 @@ async function runBuildFlow() {
   }
 }
 
+async function runUsbDebugFlow() {
+  if (!state.project || state.buildRunning) {
+    setStatus("error", state.project ? text("usbDebugRunning") : text("chooseProjectFirst"));
+    return;
+  }
+  if (!goToReview()) {
+    return;
+  }
+
+  showLogBar();
+  state.buildRunning = true;
+  updateActionButtons();
+  elements.resultPanel.classList.add("hidden");
+  setView("build");
+  setStep("folder", "done", text("folderReady"));
+
+  const doctorOk = await runDoctorOnly();
+  if (!doctorOk) {
+    state.buildRunning = false;
+    updateActionButtons();
+    return;
+  }
+
+  setStatus("busy", text("usbDebugRunning"));
+  setStep("build", "active", text("usbDebugRunning"));
+  setProgress(90, text("progressBuild"), "active");
+  startAnimatedLogs();
+
+  try {
+    const response = await api.runUsbDebugBuild(buildOptions());
+    stopAnimatedLogs();
+    if (!response.ok) {
+      setStep("build", "error", text("usbDebugFail"));
+      setStatus("error", text("usbDebugFail"));
+      setProgress(90, text("progressError"), "error");
+      appendLog(response.message || text("usbDebugFail"), "error");
+      if (response.buildDir) {
+        appendLog(`Build directory kept: ${response.buildDir}`, "system");
+      }
+      return;
+    }
+
+    const result = response.result;
+    state.lastApkPath = result.apkPath;
+    state.lastDistPath = state.project.distPath;
+    elements.apkPath.textContent = result.apkPath;
+    elements.successTitle.textContent = text("usbSuccessTitle");
+    elements.successText.textContent = text("usbSuccessText");
+    elements.successApkPath.textContent = result.apkPath;
+    elements.resultPanel.classList.remove("hidden");
+    setStep("build", "done", text("usbDebugOk"));
+    setStatus("ready", text("usbDebugOk"));
+    setProgress(100, text("progressDone"));
+    appendLog(`${text("usbDebugOk")}: ${result.device && result.device.id ? result.device.id : "Android USB"}`, "success");
+    appendLog(`${text("buildOk")}: ${result.apkPath}`, "success");
+    setView("success");
+  } catch (error) {
+    stopAnimatedLogs();
+    setStep("build", "error", text("usbDebugFail"));
+    setStatus("error", error.message);
+    setProgress(90, text("progressError"), "error");
+    appendLog(error.message, "error");
+  } finally {
+    state.buildRunning = false;
+    updateActionButtons();
+  }
+}
+
 function toggleTheme() {
   state.theme = state.theme === "dark" ? "light" : "dark";
   applyTheme();
@@ -1186,6 +2375,7 @@ function bindEvents() {
   elements.settingsNextButton.addEventListener("click", goToReview);
   elements.doctorButton.addEventListener("click", runDoctorOnly);
   elements.buildButton.addEventListener("click", runBuildFlow);
+  elements.usbDebugButton.addEventListener("click", runUsbDebugFlow);
   elements.clearLogsButton.addEventListener("click", clearLogs);
   elements.toggleLogsButton.addEventListener("click", toggleLogBar);
   elements.bottomToggleLogsButton.addEventListener("click", toggleLogBar);
@@ -1220,6 +2410,7 @@ function bindEvents() {
     validateSettings();
   });
   elements.permissionGrid.addEventListener("change", validateSettings);
+  elements.nativeCodeGrid.addEventListener("click", handleNativeCodeCopy);
   [
     elements.appNameInput,
     elements.packageIdInput,
@@ -1227,6 +2418,8 @@ function bindEvents() {
     elements.orientationInput,
     elements.minSdkVersionInput,
     elements.androidPlatformInput,
+    elements.themeModeInput,
+    elements.oneSignalAppIdInput,
     elements.debugInput,
     elements.releaseInput
   ].forEach((input) => {
@@ -1262,6 +2455,11 @@ function bindEvents() {
     elements.resultPanel.classList.add("hidden");
     goToReview();
   });
+  elements.devInstagramButton.addEventListener("click", () => {
+    api.openExternalUrl(DEVELOPER_INSTAGRAM_URL).catch(() => {
+      setStatus("error", "Nao foi possivel abrir o Instagram.");
+    });
+  });
 
   elements.dropZone.addEventListener("dragover", (event) => {
     event.preventDefault();
@@ -1289,6 +2487,16 @@ function bindEvents() {
   api.onInstallLog((payload) => {
     appendLog(payload.line, payload.kind || "raw");
   });
+
+  if (api.onProjectChanged) {
+    api.onProjectChanged(applyProjectChange);
+  }
+
+  if (api.onProjectWatchError) {
+    api.onProjectWatchError((payload) => {
+      appendLog(`${text("projectWatcherFail")}: ${payload.message}`, "error");
+    });
+  }
 }
 
 async function init() {
@@ -1305,6 +2513,11 @@ async function init() {
   try {
     const info = await api.appInfo();
     elements.appVersion.textContent = `v${info.version}`;
+    state.defaultIconPath = info.iconPath || "";
+    if (elements.iconPathInput && !elements.iconPathInput.value.trim() && state.defaultIconPath) {
+      elements.iconPathInput.value = state.defaultIconPath;
+      elements.iconPreview.src = iconPreviewPath(state.defaultIconPath);
+    }
   } catch {
     elements.appVersion.textContent = "v0.1.0";
   }