html2apk 0.1.0 → 0.3.0

package/src/desktop/renderer/renderer.js

@@ -10,6 +10,7 @@ const i18n = {
     navSettings: "Configuracoes",
     navAppearance: "Aparencia",
     navBuild: "Build",
+    navCodes: "Codigos",
     navLogs: "Logs",
     navHelp: "Ajuda",
     theme: "Tema",
@@ -33,7 +34,22 @@ const i18n = {
     appVersion: "Versao do app",
     mode: "Modo",
     chooseMode: "Escolha o modo",
+    modeFullscreen: "Tela cheia",
+    modeStandalone: "Normal",
+    modeFloating: "Flutuante",
+    orientation: "Orientacao",
+    orientationDefault: "Automatico",
+    orientationPortrait: "Vertical",
+    orientationLandscape: "Horizontal",
+    minSdkVersion: "Android minimo",
     appIcon: "Icone 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",
     reviewBuild: "Revisar build",
     debugBuild: "Debug tecnico",
@@ -58,6 +74,11 @@ const i18n = {
     showApk: "Mostrar APK",
     logsEyebrow: "Ao vivo",
     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.",
+    returnsLabel: "Retorno",
+    handlingLabel: "Como tratar",
     clearLogs: "Limpar logs",
     helpEyebrow: "Sem misterio",
     helpTitle: "Doctor, build e dependencias",
@@ -65,6 +86,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,6 +116,9 @@ const i18n = {
     missingMode: "Escolha o modo do app.",
     missingIcon: "Escolha o icone do app.",
     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",
     progressIdle: "Aguardando pasta",
@@ -123,6 +150,7 @@ const i18n = {
     navSettings: "Settings",
     navAppearance: "Appearance",
     navBuild: "Build",
+    navCodes: "Code",
     navLogs: "Logs",
     navHelp: "Help",
     theme: "Theme",
@@ -146,7 +174,22 @@ const i18n = {
     appVersion: "App version",
     mode: "Mode",
     chooseMode: "Choose mode",
+    modeFullscreen: "Fullscreen",
+    modeStandalone: "Normal",
+    modeFloating: "Floating",
+    orientation: "Orientation",
+    orientationDefault: "Auto",
+    orientationPortrait: "Portrait",
+    orientationLandscape: "Landscape",
+    minSdkVersion: "Minimum Android",
     appIcon: "App icon",
+    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",
     reviewBuild: "Review build",
     debugBuild: "Technical debug",
@@ -171,6 +214,11 @@ const i18n = {
     showApk: "Show APK",
     logsEyebrow: "Live",
     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.",
+    returnsLabel: "Returns",
+    handlingLabel: "How to handle",
     clearLogs: "Clear logs",
     helpEyebrow: "Plain and simple",
     helpTitle: "Doctor, build and dependencies",
@@ -178,6 +226,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",
@@ -205,6 +256,9 @@ const i18n = {
     missingMode: "Choose the app mode.",
     missingIcon: "Choose the app 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",
     progressIdle: "Waiting for folder",
@@ -241,6 +295,323 @@ const animatedBuildLines = [
   "Procurando APK final / Finding final APK"
 ];
 
+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 = [
+  {
+    value: "INTERNET",
+    label: { pt: "Internet", en: "Internet" },
+    detail: { pt: "Acesso a rede", en: "Network access" }
+  },
+  {
+    value: "POST_NOTIFICATIONS",
+    label: { pt: "Notificacoes", en: "Notifications" },
+    detail: { pt: "Android 13+", en: "Android 13+" }
+  },
+  {
+    value: "VIBRATE",
+    label: { pt: "Vibracao", en: "Vibration" },
+    detail: { pt: "Permite vibrar", en: "Allows vibration" }
+  },
+  {
+    value: "CAMERA",
+    label: { pt: "Camera", en: "Camera" },
+    detail: { pt: "Captura de imagem", en: "Image capture" }
+  },
+  {
+    value: "RECORD_AUDIO",
+    label: { pt: "Microfone", en: "Microphone" },
+    detail: { pt: "Captura de audio", en: "Audio capture" }
+  },
+  {
+    value: "ACCESS_FINE_LOCATION",
+    label: { pt: "Localizacao precisa", en: "Precise location" },
+    detail: { pt: "GPS e rede", en: "GPS and network" }
+  },
+  {
+    value: "ACCESS_COARSE_LOCATION",
+    label: { pt: "Localizacao aproximada", en: "Approximate location" },
+    detail: { pt: "Rede", en: "Network" }
+  },
+  {
+    value: "SYSTEM_ALERT_WINDOW",
+    label: { pt: "Sobrepor apps", en: "Draw over apps" },
+    detail: { pt: "Necessaria no modo flutuante", en: "Required for floating mode" }
+  }
+];
+
+const nativeCodeEntries = [
+  {
+    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: "Antes de usar, chame `solicitarPermissaoNotificacoes()` no Android 13+. Trate o clique pela acao enviada em `aoClicar`/`onClick`.", en: "Before using it, call `requestNotificationPermission()` on Android 13+. Handle clicks using the action sent in `onClick`/`aoClicar`." }
+  },
+  {
+    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 }.", en: "{ permission, required, granted }." },
+    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 antes de liberar recursos sensiveis; quando vier falso, mostre uma etapa de permissao em vez de falhar silenciosamente.", en: "Use it before enabling sensitive features; when false, show a permission step instead of failing silently." }
+  },
+  {
+    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 antes de usar lanterna.", en: "Requests camera permission before using flashlight." },
+    returns: { pt: "{ permission, required, granted }.", en: "{ permission, required, granted }." },
+    handling: { pt: "Chame antes de `lanterna()`. Se `granted` for falso, mostre uma mensagem e mantenha a lanterna desativada.", en: "Call before `flashlight()`. If `granted` is false, show a message and keep the flashlight disabled." }
+  },
+  {
+    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 }. `pararMic`: { base64, mimeType, extension, durationMs, size }.", en: "`listenMic`: { recording, startedAt, granted }. `stopMic`: { base64, mimeType, extension, durationMs, size }." },
+    handling: { pt: "Chame `solicitarPermissaoMicrofone()` ou deixe `ouvirMic()` pedir a permissao. Para tocar/enviar, monte `data:${audio.mimeType};base64,${audio.base64}`; se parar rapido demais, tente aguardar alguns instantes antes de `pararMic()`.", en: "Call `requestMicrophonePermission()` or let `listenMic()` request permission. To play/upload, build `data:${audio.mimeType};base64,${audio.base64}`; if you stop too quickly, wait a little before `stopMic()`." }
+  },
+  {
+    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: "Se `available` for falso, esconda o controle. Se `permissionGranted` for falso, volte para a etapa de permissao.", en: "If `available` is false, hide the control. If `permissionGranted` is false, return to the permission step." }
+  },
+  {
+    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: "Antes de iniciar, confira `statusPermissaoSobreposicao()` e chame `solicitarPermissaoSobreposicao()` se faltar permissao.", en: "Before starting, check `overlayPermissionStatus()` and call `requestOverlayPermission()` when permission is missing." }
+  }
+];
+
 const state = {
   language: localStorage.getItem("html2apk.language") || null,
   theme: localStorage.getItem("html2apk.theme") || "light",
@@ -292,7 +663,14 @@ function collectElements() {
     "packageIdInput",
     "versionInput",
     "modeInput",
+    "orientationInput",
+    "minSdkVersionInput",
     "androidPlatformInput",
+    "themeModeInput",
+    "themeColorInput",
+    "themeColorTextInput",
+    "oneSignalAppIdInput",
+    "permissionGrid",
     "iconPathInput",
     "iconPreview",
     "selectIconButton",
@@ -308,6 +686,7 @@ function collectElements() {
     "progressBar",
     "progressPercent",
     "reviewGrid",
+    "nativeCodeGrid",
     "resultPanel",
     "apkPath",
     "openDistButton",
@@ -322,6 +701,7 @@ function collectElements() {
     "toggleLogsButton",
     "bottomToggleLogsButton",
     "bottomClearLogsButton",
+    "devInstagramButton",
     "minimizeButton",
     "maximizeButton",
     "closeButton",
@@ -349,6 +729,8 @@ function applyLanguage() {
   });
   applyTheme();
   applyLogBarVisibility();
+  renderPermissionOptions(selectedPermissions());
+  renderNativeCodeGrid();
   if (state.project) {
     validateSettings();
     renderReview();
@@ -421,6 +803,15 @@ function toggleLogBar() {
   applyLogBarVisibility();
 }
 
+function showLogBar() {
+  if (state.logsVisible) {
+    return;
+  }
+
+  state.logsVisible = true;
+  applyLogBarVisibility();
+}
+
 function clearLogs() {
   elements.logConsole.innerHTML = "";
   if (elements.bottomLogConsole) {
@@ -492,6 +883,16 @@ function packageSegment(value) {
     .replace(/^[^a-z]+/, "") || "app";
 }
 
+function normalizeHexColor(value, fallback = "#126fff") {
+  const textValue = String(value || "").trim();
+  const normalized = textValue.startsWith("#") ? textValue : `#${textValue}`;
+  return /^#[0-9a-fA-F]{6}$/.test(normalized) ? normalized.toLowerCase() : fallback;
+}
+
+function currentLanguage() {
+  return state.language || "pt";
+}
+
 function toFileUrl(filePath) {
   if (!filePath) {
     return "../../../html2apk.png";
@@ -521,13 +922,142 @@ function escapeHtml(value) {
     .replace(/"/g, "&quot;");
 }
 
+function selectedOptionText(select) {
+  if (!select || !select.selectedOptions || !select.selectedOptions.length) {
+    return select ? select.value : "";
+  }
+  return select.selectedOptions[0].textContent || select.value;
+}
+
+function selectedPermissions() {
+  if (!elements.permissionGrid) {
+    return DEFAULT_PERMISSIONS.slice();
+  }
+
+  const inputs = Array.from(elements.permissionGrid.querySelectorAll("input[data-permission-option]"));
+  if (!inputs.length) {
+    return DEFAULT_PERMISSIONS.slice();
+  }
+
+  const selected = inputs
+    .filter((input) => input.checked)
+    .map((input) => input.value);
+
+  if (elements.modeInput && elements.modeInput.value === "floating" && !selected.includes("SYSTEM_ALERT_WINDOW")) {
+    selected.push("SYSTEM_ALERT_WINDOW");
+  }
+
+  return Array.from(new Set(selected));
+}
+
+function renderPermissionOptions(selected = DEFAULT_PERMISSIONS) {
+  if (!elements.permissionGrid) {
+    return;
+  }
+
+  const selectedSet = new Set(selected);
+  if (elements.modeInput && elements.modeInput.value === "floating") {
+    selectedSet.add("SYSTEM_ALERT_WINDOW");
+  }
+  const language = currentLanguage();
+
+  elements.permissionGrid.innerHTML = permissionOptions.map((permission) => {
+    const checked = selectedSet.has(permission.value) ? " checked" : "";
+    const disabled = elements.modeInput && elements.modeInput.value === "floating" && permission.value === "SYSTEM_ALERT_WINDOW"
+      ? " disabled"
+      : "";
+
+    return `
+      <label class="permission-option">
+        <input type="checkbox" data-permission-option value="${escapeHtml(permission.value)}"${checked}${disabled}>
+        <span>
+          <strong>${escapeHtml(permission.label[language] || permission.label.pt)}</strong>
+          <small>${escapeHtml(permission.detail[language] || permission.detail.pt)}</small>
+        </span>
+      </label>
+    `;
+  }).join("");
+}
+
+function normalizeOrientationInputValue(value) {
+  if (value === "vertical") {
+    return "portrait";
+  }
+  if (value === "horizontal") {
+    return "landscape";
+  }
+  return ["portrait", "landscape"].includes(value) ? value : "default";
+}
+
+function normalizeMinSdkVersion(value) {
+  const parsed = Number.parseInt(value, 10);
+  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();
+  const returnsLabel = text("returnsLabel");
+  const handlingLabel = text("handlingLabel");
+  elements.nativeCodeGrid.innerHTML = nativeCodeEntries.map((entry) => {
+    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;
+
+    return `
+    <article class="code-card">
+      <code>${escapeHtml(syntax)}</code>
+      <span>Java: ${escapeHtml(entry.java)}</span>
+      <p>${escapeHtml(description)}</p>
+      <small><strong>${escapeHtml(returnsLabel)}:</strong> ${escapeHtml(returns)}</small>
+      <small class="handling"><strong>${escapeHtml(handlingLabel)}:</strong> ${escapeHtml(handling)}</small>
+    </article>
+  `;
+  }).join("");
+}
+
 function populateSettings(config = {}, project = state.project) {
   const projectName = project ? project.name : "MeuApp";
   elements.appNameInput.value = config.appName || projectName || "";
   elements.packageIdInput.value = config.packageId || `com.html2apk.${packageSegment(projectName)}`;
   elements.versionInput.value = config.version || "1.0.0";
   elements.modeInput.value = config.mode || "fullscreen";
+  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 || "");
   elements.debugInput.checked = Boolean(config.debug);
@@ -554,6 +1084,15 @@ function validateSettings() {
   if (!elements.modeInput.value) {
     errors.push(text("missingMode"));
   }
+  if (!MIN_SDK_OPTIONS.includes(Number.parseInt(elements.minSdkVersionInput.value, 10))) {
+    errors.push(text("invalidMinSdkVersion"));
+  }
+  if (!/^#[0-9a-fA-F]{6}$/.test(elements.themeColorTextInput.value.trim())) {
+    errors.push(text("invalidThemeColor"));
+  }
+  if (!isValidOptionalOneSignalAppId(elements.oneSignalAppIdInput.value)) {
+    errors.push(text("invalidOneSignalAppId"));
+  }
   if (!elements.iconPathInput.value.trim()) {
     errors.push(text("missingIcon"));
   } else if (!/\.png$/i.test(elements.iconPathInput.value.trim())) {
@@ -596,7 +1135,13 @@ function renderReview() {
     [text("appName"), elements.appNameInput.value.trim()],
     [text("packageId"), elements.packageIdInput.value.trim()],
     [text("appVersion"), elements.versionInput.value.trim()],
-    [text("mode"), elements.modeInput.value],
+    [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()]
   ];
 
@@ -830,6 +1375,13 @@ function buildOptions() {
     packageId: elements.packageIdInput.value.trim(),
     version: elements.versionInput.value.trim(),
     mode: elements.modeInput.value,
+    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(),
     debug: elements.debugInput.checked,
@@ -862,6 +1414,7 @@ async function runBuildFlow() {
     return;
   }
 
+  showLogBar();
   state.buildRunning = true;
   updateActionButtons();
   elements.resultPanel.classList.add("hidden");
@@ -980,12 +1533,35 @@ function bindEvents() {
     appendLog(`${text("iconSelected")}: ${iconPath}`, "system");
     validateSettings();
   });
+  elements.themeColorInput.addEventListener("input", () => {
+    elements.themeColorTextInput.value = elements.themeColorInput.value;
+    validateSettings();
+  });
+  elements.themeColorTextInput.addEventListener("input", () => {
+    if (/^#[0-9a-fA-F]{6}$/.test(elements.themeColorTextInput.value.trim())) {
+      elements.themeColorInput.value = elements.themeColorTextInput.value.trim();
+    }
+    validateSettings();
+  });
+  elements.modeInput.addEventListener("change", () => {
+    const overlayInput = elements.permissionGrid.querySelector("input[value='SYSTEM_ALERT_WINDOW']");
+    const selected = selectedPermissions();
+    const nextPermissions = elements.modeInput.value === "floating" || !overlayInput || !overlayInput.disabled
+      ? selected
+      : selected.filter((permission) => permission !== "SYSTEM_ALERT_WINDOW");
+    renderPermissionOptions(nextPermissions);
+    validateSettings();
+  });
+  elements.permissionGrid.addEventListener("change", validateSettings);
   [
     elements.appNameInput,
     elements.packageIdInput,
     elements.versionInput,
-    elements.modeInput,
+    elements.orientationInput,
+    elements.minSdkVersionInput,
     elements.androidPlatformInput,
+    elements.themeModeInput,
+    elements.oneSignalAppIdInput,
     elements.debugInput,
     elements.releaseInput
   ].forEach((input) => {
@@ -1021,6 +1597,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();