html2apk 0.9.0 → 12.0.0

package/src/desktop/renderer/renderer.js

@@ -526,6 +526,13 @@ const nativeCodeEntries = [
     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: "aguardar(5000) / loading(5000)", en: "loading(5000)" },
+    java: "JavaScript timer",
+    description: { pt: "Cria uma pausa assincrona entre linhas de codigo usando Promise.", en: "Creates an asynchronous pause between code lines using a Promise." },
+    returns: { pt: "{ ok, ms } depois do intervalo.", en: "{ ok, ms } after the interval." },
+    handling: { pt: "Use com `await` para esperar sem travar a WebView. O tempo e em milissegundos.", en: "Use with `await` to wait without blocking the WebView. The time is in milliseconds." }
+  },
   {
     syntax: { pt: "notificar({ titulo, texto, aoClicar?, acoes?, open? })", en: "notify({ title, text, onClick?, actions?, open? })" },
     java: "notify",
@@ -571,7 +578,7 @@ const nativeCodeEntries = [
   {
     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." },
+    description: { pt: "Escuta eventos nativos: app:pronto, app:background, app:voltou, botao:voltar, link:aberto, rede:mudou, bateria:mudou, usb:conectado, fone:conectado, volume:mudou, teclado:abriu, orientacao:mudou, celular:sacudido, print:tela, nfc:recebido, notificacao:recebida e notificacao:clicada.", en: "Listens to native events: app:ready, app:background, app:resumed, back:button, link:opened, network:changed, battery:changed, usb:connected, headphone:connected, volume:changed, keyboard:opened, orientation:changed, phone:shaken, screenshot:taken, nfc:received, 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." }
   },
@@ -582,6 +589,104 @@ const nativeCodeEntries = [
     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: "aoConectarUSB(fn) / aoDesconectarUSB(fn)", en: "onUSBConnect(fn) / onUSBDisconnect(fn)" },
+    java: "UsbManager + BatteryManager",
+    description: { pt: "Escuta conexão/desconexão USB por energia USB ou dispositivo USB/OTG anexado ao Android.", en: "Listens for USB connect/disconnect from USB power or USB/OTG devices attached to Android." },
+    returns: { pt: "Callback recebe { conectado, origem, dispositivo? }. Retorna função para cancelar.", en: "Callback receives { connected, source, device? }. Returns an unsubscribe function." },
+    handling: { pt: "Para cabo no computador, o evento vem como origem `power`; para OTG, vem com dados do dispositivo quando o Android entregar.", en: "For a computer cable, the event source is `power`; for OTG, device data is included when Android provides it." }
+  },
+  {
+    syntax: { pt: "aoConectarFone(fn) / aoDesconectarFone(fn)", en: "onHeadphoneConnect(fn) / onHeadphoneDisconnect(fn)" },
+    java: "AudioManager",
+    description: { pt: "Escuta fone com fio, Bluetooth, USB headset e aparelhos de áudio reconhecidos pelo Android.", en: "Listens for wired, Bluetooth, USB headset and other Android audio output devices." },
+    returns: { pt: "Callback recebe { conectado, dispositivo? }. Retorna função para cancelar.", en: "Callback receives { connected, device? }. Returns an unsubscribe function." },
+    handling: { pt: "Bluetooth pode chegar pelo callback de áudio quando vira saída de som; pare a escuta ao sair da tela.", en: "Bluetooth may arrive through the audio callback when it becomes an output device; stop listening when the screen unmounts." }
+  },
+  {
+    syntax: { pt: "aoMudarVolume(fn)", en: "onVolumeChange(fn)" },
+    java: "AudioManager + Settings Observer",
+    description: { pt: "Escuta mudanças nos volumes de mídia, toque, notificação, alarme e chamada.", en: "Listens for changes in media, ring, notification, alarm and voice-call volumes." },
+    returns: { pt: "Callback recebe volumes atuais e máximos por stream. Retorna função para cancelar.", en: "Callback receives current and max volumes by stream. Returns an unsubscribe function." },
+    handling: { pt: "O Android pode agrupar streams dependendo do modo de som do aparelho; trate como estado atual, não como histórico completo.", en: "Android may group streams depending on device sound mode; treat it as current state, not complete history." }
+  },
+  {
+    syntax: { pt: "volumeAtual() / definirVolume('midia', 0.5)", en: "getVolume() / setVolume('music', 0.5)" },
+    java: "AudioManager",
+    description: { pt: "Consulta e controla volumes de mídia, toque, notificação, alarme, chamada e sistema.", en: "Reads and controls media, ring, notification, alarm, voice-call and system volumes." },
+    returns: { pt: "`volumeAtual` retorna volumes atuais/máximos por stream. `definirVolume`, `aumentarVolume` e `diminuirVolume` retornam o novo estado.", en: "`getVolume` returns current/max volumes by stream. `setVolume`, `increaseVolume` and `decreaseVolume` return the new state." },
+    handling: { pt: "Use valores entre 0 e 1 para porcentagem ou inteiros para passos absolutos. Passe `{ mostrarUI: true }` se quiser exibir a barra nativa.", en: "Use values from 0 to 1 for percentage or integers for absolute steps. Pass `{ showUi: true }` to show the native volume panel." }
+  },
+  {
+    syntax: { pt: "aoAbrirTeclado(fn) / aoFecharTeclado(fn)", en: "onKeyboardOpen(fn) / onKeyboardClose(fn)" },
+    java: "ViewTreeObserver",
+    description: { pt: "Detecta abertura/fechamento do teclado pela área visível da WebView.", en: "Detects keyboard open/close through the visible WebView area." },
+    returns: { pt: "Callback recebe { aberto, alturaTeclado }. Retorna função para cancelar.", en: "Callback receives { open, keyboardHeight }. Returns an unsubscribe function." },
+    handling: { pt: "É uma heurística visual; modo tela cheia, teclado flutuante ou fabricante podem alterar a altura detectada.", en: "This is a visual heuristic; fullscreen mode, floating keyboards or vendors may change detected height." }
+  },
+  {
+    syntax: { pt: "aoMudarOrientacao(fn)", en: "onOrientationChange(fn)" },
+    java: "ViewTreeObserver + Configuration",
+    description: { pt: "Escuta troca entre portrait e landscape enquanto a WebView muda de tamanho.", en: "Listens for portrait/landscape changes while the WebView changes size." },
+    returns: { pt: "Callback recebe { orientacao, largura, altura }. Retorna função para cancelar.", en: "Callback receives { orientation, width, height }. Returns an unsubscribe function." },
+    handling: { pt: "Se o app travar orientação no config, o evento naturalmente não muda.", en: "If the app locks orientation in config, the event naturally does not change." }
+  },
+  {
+    syntax: { pt: "aoSacudirCelular(fn) / aoVirarCelularParaBaixo(fn)", en: "onPhoneShake(fn) / onPhoneFaceDown(fn)" },
+    java: "SensorManager",
+    description: { pt: "Escuta acelerômetro para detectar sacudida forte e tela virada para baixo.", en: "Uses the accelerometer to detect a strong shake and face-down posture." },
+    returns: { pt: "Callback recebe leituras x/y/z e força quando fizer sentido. Retorna função para cancelar.", en: "Callback receives x/y/z readings and force when relevant. Returns an unsubscribe function." },
+    handling: { pt: "Sensores variam por aparelho; use para interações leves e sempre mantenha um botão alternativo.", en: "Sensors vary by device; use for lightweight interactions and always keep a button fallback." }
+  },
+  {
+    syntax: { pt: "aoAproximarObjeto(fn)", en: "onProximityNear(fn)" },
+    java: "SensorManager",
+    description: { pt: "Escuta o sensor de proximidade quando algo se aproxima da tela.", en: "Listens to the proximity sensor when something gets near the screen." },
+    returns: { pt: "Callback recebe { perto, distancia, alcanceMaximo }. Retorna função para cancelar.", en: "Callback receives { near, distance, maximumRange }. Returns an unsubscribe function." },
+    handling: { pt: "Nem todo aparelho tem sensor de proximidade; trate ausência simplesmente como evento que nunca dispara.", en: "Not every device has a proximity sensor; treat absence as an event that simply never fires." }
+  },
+  {
+    syntax: { pt: "aoTirarPrint(fn)", en: "onScreenshot(fn)" },
+    java: "MediaStore Observer",
+    description: { pt: "Tenta detectar captura de tela observando novas imagens com nome/pasta de screenshot.", en: "Tries to detect screenshots by observing new images with screenshot-like names/folders." },
+    returns: { pt: "Callback recebe { uri, nome, caminho? }. Retorna função para cancelar.", en: "Callback receives { uri, name, path? }. Returns an unsubscribe function." },
+    handling: { pt: "Android moderno limita leitura de midia; alguns fabricantes mudam o nome da pasta, então esse evento é melhor esforço.", en: "Modern Android limits media reads; some vendors rename folders, so this event is best-effort." }
+  },
+  {
+    syntax: { pt: "capturarTela() / tirarPrint()", en: "captureScreen() / takeScreenshot()" },
+    java: "View.draw + Bitmap",
+    description: { pt: "Captura a tela atual do próprio app/WebView e devolve imagem em base64.", en: "Captures the current app/WebView screen and returns a base64 image." },
+    returns: { pt: "{ base64, dataUrl, width, height, mimeType, formato }.", en: "{ base64, dataUrl, width, height, mimeType, format }." },
+    handling: { pt: "Não captura outros apps nem áreas protegidas do sistema. Use depois da tela renderizar para evitar imagem vazia.", en: "Does not capture other apps or protected system areas. Call it after the screen renders to avoid an empty image." }
+  },
+  {
+    syntax: { pt: "aoNFC(fn)", en: "onNFC(fn)" },
+    java: "NfcAdapter",
+    description: { pt: "Escuta tags NFC enquanto o app está aberto em primeiro plano.", en: "Listens for NFC tags while the app is open in the foreground." },
+    returns: { pt: "Callback recebe { id, tecnologias, mensagens }. Retorna função para cancelar.", en: "Callback receives { id, technologies, messages }. Returns an unsubscribe function." },
+    handling: { pt: "Exige aparelho com NFC ligado. Tags que abrem o app enquanto ele estava fechado podem precisar de fluxo inicial em uma evolução futura.", en: "Requires a device with NFC enabled. Tags that launch the app from closed state may need an initial-flow helper in a future iteration." }
+  },
+  {
+    syntax: { pt: "aoReceberNotificacao(fn)", en: "onNotificationReceived(fn)" },
+    java: "dispatchEvent",
+    description: { pt: "Escuta quando uma notificação local do app é emitida pela bridge.", en: "Listens when a local app notification is emitted by the bridge." },
+    returns: { pt: "Callback recebe os dados da notificação. Retorna função para cancelar.", en: "Callback receives the notification data. Returns an unsubscribe function." },
+    handling: { pt: "Use para atualizar tela/estado quando `notificar()` ou uma notificacao agendada passar pela bridge. Para clique, use `aoClicarNotificacao()`.", en: "Use it to update UI/state when `notify()` or a scheduled notification goes through the bridge. For clicks, use `onNotificationClick()`." }
+  },
+  {
+    syntax: { pt: "obterLinkInicial()", en: "getInitialLink()" },
+    java: "Intent / Activity",
+    description: { pt: "Retorna a URL que abriu o aplicativo (Deep Link), se houver.", en: "Returns the URL that opened the application (Deep Link), if any." },
+    returns: { pt: "String (ex: 'meuapp://conteudo/123').", en: "String (e.g. 'myapp://content/123')." },
+    handling: { pt: "Util para repassar campanhas de marketing no inicio do app.", en: "Useful for passing marketing campaigns at app startup." }
+  },
+  {
+    syntax: { pt: "aoLigarDispositivo(callback)", en: "onDeviceBoot(callback)" },
+    java: "Intent / BootReceiver",
+    description: { pt: "Executa uma funcao caso o aplicativo tenha sido aberto silenciosamente pelo boot do celular.", en: "Executes a function if the application was silently opened by the device boot." },
+    returns: { pt: "Nenhum.", en: "None." },
+    handling: { pt: "Depende de `configurarInicioAutomatico(true)` e permissao de sobreposicao no Android 10+.", en: "Depends on `setAutoStartOnBoot(true)` and overlay permission on Android 10+." }
+  },
   {
     syntax: { pt: "obterLinkInicial() / aoAbrirLink(fn)", en: "getInitialLink() / onOpenLink(fn)" },
     java: "getInitialLink",
@@ -619,15 +724,15 @@ const nativeCodeEntries = [
   },
   {
     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." },
+    java: "Photo Picker / ACTION_OPEN_DOCUMENT",
+    description: { pt: "Abre o Photo Picker moderno no Android 13+ e usa SAF automaticamente nos Androids antigos.", en: "Opens the modern Photo Picker on Android 13+ and automatically falls back to SAF on older Android versions." },
     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." }
+    handling: { pt: "Nao pede permissao ampla de armazenamento quando o Photo Picker esta disponivel. Use `uri`, nao caminho absoluto.", en: "Does not request broad storage permission when Photo Picker is available. Use `uri`, not 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." },
+    syntax: { pt: "escolherImagens({ multiplas: true })", en: "pickImages({ multiple: true })" },
+    java: "Photo Picker / ACTION_OPEN_DOCUMENT",
+    description: { pt: "Abre selecao multipla de imagens usando Photo Picker moderno quando possivel.", en: "Opens multiple image selection using the modern Photo Picker when possible." },
     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." }
   },
@@ -656,7 +761,7 @@ const nativeCodeEntries = [
     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." },
+    returns: { pt: "{ uri, nome } ou objeto vazio se cancelar.", en: "{ uri, name } 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." }
   },
   {
@@ -667,11 +772,60 @@ const nativeCodeEntries = [
     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 })" },
+    syntax: { pt: "compartilhar({ texto, url, arquivo, arquivos })", en: "share({ text, url, file, files })" },
     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." }
+    description: { pt: "Abre a folha nativa para texto, link, imagem, video, PDF, arquivo unico ou multiplos arquivos.", en: "Opens the native share sheet for text, link, image, video, PDF, one file or multiple files." },
+    returns: { pt: "{ ok, shared, items, mimeType }.", en: "{ ok, shared, items, mimeType }." },
+    handling: { pt: "Aceita objeto retornado por `escolherArquivo()`, URI ou nome salvo no armazenamento do app.", en: "Accepts an object returned by `pickFile()`, a URI or a file name saved in app storage." }
+  },
+  {
+    syntax: { pt: "aoReceberCompartilhamento(callback)", en: "onShareReceived(callback)" },
+    java: "ACTION_SEND / ACTION_SEND_MULTIPLE",
+    description: { pt: "Permite que o app criado apareca no menu Compartilhar do Android e receba texto, imagem, video, PDF ou arquivo.", en: "Lets the generated app appear in Android's Share menu and receive text, image, video, PDF or file data." },
+    returns: { pt: "Callback recebe { tipo, uri, mimeType, texto, items }.", en: "Callback receives { type, uri, mimeType, text, items }." },
+    handling: { pt: "Use `obterCompartilhamentoInicial()` no boot e `aoReceberCompartilhamento()` para intents recebidas com o app aberto.", en: "Use `getInitialShare()` on boot and `onShareReceived()` for intents received while the app is open." }
+  },
+  {
+    syntax: { pt: "procurarBT() / conectarBT(id) / enviarBT(objeto) / aoDarErroBT(callback)", en: "scanBluetooth() / connectBluetooth(id) / sendBluetooth(object) / onBluetoothError(callback)" },
+    java: "Bluetooth RFCOMM",
+    description: { pt: "Comunica dois apps html2apk por Bluetooth classico usando JSON.", en: "Communicates two html2apk apps over classic Bluetooth using JSON." },
+    returns: { pt: "`procurarBT` retorna lista de dispositivos; `conectarBT` retorna o dispositivo conectado; `enviarBT` retorna { ok, enviado }; `aoDarErroBT` recebe o erro.", en: "`scanBluetooth` returns a device list; `connectBluetooth` returns the connected device; `sendBluetooth` returns { ok, sent }; `onBluetoothError` receives the error." },
+    handling: { pt: "No aparelho que recebe, registre `aoConectarBT()`, `aoReceberDadosBT()` e `aoDarErroBT()`. Para descoberta, o outro aparelho precisa estar pareado ou visivel no Bluetooth do Android.", en: "On the receiving device, register `onBluetoothConnect()`, `onBluetoothData()` and `onBluetoothError()`. For discovery, the other device must be paired or visible in Android Bluetooth." }
+  },
+  {
+    syntax: { pt: "procurarWiFi() / conectarWiFi(id) / enviarWiFi(objeto) / aoDarErroWiFi(callback)", en: "scanWiFi() / connectWiFi(id) / sendWiFi(object) / onWiFiError(callback)" },
+    java: "NSD + Socket TCP local",
+    description: { pt: "Comunica dois apps html2apk pela mesma rede Wi-Fi ou hotspot usando JSON.", en: "Communicates two html2apk apps on the same Wi-Fi network or hotspot using JSON." },
+    returns: { pt: "`procurarWiFi` retorna lista de dispositivos; `conectarWiFi` retorna o dispositivo conectado; `enviarWiFi` retorna { ok, enviado }; `aoDarErroWiFi` recebe o erro.", en: "`scanWiFi` returns a device list; `connectWiFi` returns the connected device; `sendWiFi` returns { ok, sent }; `onWiFiError` receives the error." },
+    handling: { pt: "No aparelho que recebe, registre `aoConectarWiFi()`, `aoReceberDadosWiFi()` e `aoDarErroWiFi()`. Os dois aparelhos precisam estar na mesma rede local ou hotspot.", en: "On the receiving device, register `onWiFiConnect()`, `onWiFiData()` and `onWiFiError()`. Both devices must be on the same local network or hotspot." }
+  },
+  {
+    syntax: { pt: "ocr(imagem)", en: "recognizeText(image)" },
+    java: "ML Kit TextRecognition local",
+    description: { pt: "Reconhece texto em imagem usando ML Kit local, sem enviar dados para servidor.", en: "Recognizes text in an image using local ML Kit, without sending data to a server." },
+    returns: { pt: "{ texto, text, offline, blocks }.", en: "{ texto, text, offline, blocks }." },
+    handling: { pt: "Aceita objeto de `escolherImagem()`, URI, base64 ou nome salvo. O modelo latino atende portugues.", en: "Accepts a `pickImage()` object, URI, base64 or saved file name. The Latin model supports Portuguese." }
+  },
+  {
+    syntax: { pt: "falar('Ola', { idioma: 'pt-BR', velocidade: 1 }) / pararFala()", en: "speak('Hello', { language: 'en-US', speed: 1 }) / stopSpeaking()" },
+    java: "TextToSpeech",
+    description: { pt: "Usa o motor TTS instalado no Android para falar texto.", en: "Uses Android's installed TTS engine to speak text." },
+    returns: { pt: "{ ok, speaking, idioma, velocidade }.", en: "{ ok, speaking, language, speed }." },
+    handling: { pt: "Se o idioma nao estiver instalado/suportado, a Promise rejeita. Use `pararFala()` para interromper.", en: "If the language is not installed/supported, the Promise rejects. Use `stopSpeaking()` to interrupt." }
+  },
+  {
+    syntax: { pt: "ouvir({ idioma: 'pt-BR' })", en: "recognizeSpeech({ language: 'en-US' })" },
+    java: "RecognizerIntent",
+    description: { pt: "Abre o reconhecimento de voz nativo do Android e retorna o texto reconhecido.", en: "Opens Android native speech recognition and returns recognized text." },
+    returns: { pt: "{ texto, resultados, confidence }.", en: "{ text, results, confidence }." },
+    handling: { pt: "Use `idioma: 'auto'` ou omita idioma para deixar o Android escolher. Depende do servico de voz disponivel no aparelho.", en: "Use `language: 'auto'` or omit language to let Android choose. Depends on the voice service available on the device." }
+  },
+  {
+    syntax: { pt: "share_me() / compartilharApp()", en: "share_me() / shareApp()" },
+    java: "shareCurrentApp",
+    description: { pt: "Compartilha o APK do proprio app aberto usando a folha nativa do Android.", en: "Shares the APK of the currently open app through the native Android share sheet." },
+    returns: { pt: "{ shared, name, uri, size, packageName, splitApks, installableAsSingleApk }.", en: "{ shared, name, uri, size, packageName, splitApks, installableAsSingleApk }." },
+    handling: { pt: "Funciona melhor em APK unico gerado pelo html2apk. Se o app veio de AAB/loja com split APKs, o retorno avisa que compartilhar apenas o APK base pode nao reinstalar tudo.", en: "Works best with a single APK generated by html2apk. If the app came from an AAB/store with split APKs, the return warns that sharing only the base APK may not reinstall everything." }
   },
   {
     syntax: { pt: "copiarTexto('texto') / lerTextoCopiado()", en: "copyText('text') / readText()" },
@@ -739,7 +893,7 @@ const nativeCodeEntries = [
   {
     syntax: { pt: "infoRede() / infoBateria()", en: "networkInfo() / batteryInfo()" },
     java: "networkInfo/batteryInfo",
-    description: { pt: "Consulta conexao atual e bateria.", en: "Reads current connection and battery." },
+    description: { pt: "Consulta conexão 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." }
   },
@@ -774,9 +928,16 @@ const nativeCodeEntries = [
   {
     syntax: { pt: "iniciarIconeFlutuante() / pararIconeFlutuante()", en: "startFloatingIcon() / stopFloatingIcon()" },
     java: "FloatingIconService",
-    description: { pt: "Controla o icone flutuante quando a sobreposicao estiver liberada no Android.", en: "Controls the floating icon when draw-over-apps is allowed on Android." },
-    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." }
+    description: { pt: "Controla o ícone flutuante e permite ajustar opacidade quando a sobreposição estiver liberada no Android.", en: "Controls the floating icon and allows opacity changes when draw-over-apps is allowed on Android." },
+    returns: { pt: "{ granted, requiresSettings, opacity } para iniciar/configurar; `pararIconeFlutuante` finaliza o serviço.", en: "{ granted, requiresSettings, opacity } for start/configure; `stopFloatingIcon` stops the service." },
+    handling: { pt: "`iniciarIconeFlutuante()` abre a tela de permissão automaticamente se faltar sobreposição. Use `definirOpacidadeIconeFlutuante(0.6)` para mudar sem recriar outro fluxo.", en: "`startFloatingIcon()` opens the permission screen automatically if draw-over-apps is missing. Use `setFloatingIconOpacity(0.6)` to change it without creating another flow." }
+  },
+  {
+    syntax: { pt: "minimizarApp() / fecharApp()", en: "minimizeApp() / closeApp()" },
+    java: "Activity",
+    description: { pt: "Envia o app para segundo plano ou fecha a Activity atual.", en: "Sends the app to the background or closes the current Activity." },
+    returns: { pt: "`minimizarApp`: { minimizado }. `fecharApp`: { fechado } antes de finalizar.", en: "`minimizeApp`: { minimized }. `closeApp`: { closed } before finishing." },
+    handling: { pt: "Use com uma ação clara do usuário. `fecharApp()` encerra a tela do APK, então salve estado antes.", en: "Use from an explicit user action. `closeApp()` finishes the APK screen, so save state first." }
   },
   {
     syntax: { pt: "tirarFoto() / capturarVideo()", en: "takePhoto() / captureVideo()" },
@@ -800,18 +961,18 @@ const nativeCodeEntries = [
     handling: { pt: "A chamada antiga `salvarArquivo({ nome, conteudo })` continua abrindo o seletor nativo. Use string no primeiro argumento para o CRUD interno.", en: "The old `saveFile({ name, content })` call still opens the native picker. Use a string first argument for internal CRUD." }
   },
   {
-    syntax: { pt: "baixarArquivo(url, 'arquivo.pdf') / abrirArquivo('arquivo.pdf')", en: "downloadFile(url, 'file.pdf') / openFile('file.pdf')" },
+    syntax: { pt: "baixarArquivo(url, 'foto.png', { galeria: true }) / abrirArquivo('foto.png')", en: "downloadFile(url, 'photo.png', { gallery: true }) / openFile('photo.png')" },
     java: "HttpURLConnection + NotificationCompat",
-    description: { pt: "Baixa por URL para o armazenamento persistente e mostra notificacao Android com barra de progresso.", en: "Downloads from a URL to persistent storage and shows an Android progress notification." },
-    returns: { pt: "`baixarArquivo` retorna metadados, tamanho, origem e se a notificacao foi mostrada.", en: "`downloadFile` returns metadata, size, source and whether the notification was shown." },
-    handling: { pt: "Valide URL e tamanho. No Android 13+, se a permissao de notificacao for negada, o download continua e retorna `notificationShown:false`.", en: "Validate URL and size. On Android 13+, if notification permission is denied, the download continues and returns `notificationShown:false`." }
+    description: { pt: "Baixa por URL para o armazenamento persistente do app e mostra notificacao Android com barra de progresso.", en: "Downloads from a URL to the app's persistent storage and shows an Android progress notification." },
+    returns: { pt: "`baixarArquivo` retorna metadados, tamanho, origem, notificacao e, com `{ galeria: true }`, `publicUri`.", en: "`downloadFile` returns metadata, size, source, notification state and, with `{ gallery: true }`, `publicUri`." },
+    handling: { pt: "Sem `{ galeria: true }`, imagens ficam privadas do app e nao aparecem na galeria. No Android 13+, se a permissao de notificacao for negada, o download continua.", en: "Without `{ gallery: true }`, images stay private to the app and do not appear in the gallery. On Android 13+, if notification permission is denied, the download continues." }
   },
   {
-    syntax: { pt: "baixarBase64('foto.png', base64) / baixarArquivoLocal(arquivo, 'copia.pdf')", en: "downloadBase64('photo.png', base64) / downloadLocalFile(file, 'copy.pdf')" },
+    syntax: { pt: "baixarBase64('foto.png', base64, { galeria: true }) / baixarArquivoLocal(arquivo, 'copia.pdf')", en: "downloadBase64('photo.png', base64, { gallery: true }) / downloadLocalFile(file, 'copy.pdf')" },
     java: "InputStream + NotificationCompat",
     description: { pt: "Cria um download a partir de base64, data URL, URI/caminho de arquivo ou objeto retornado por `escolherArquivo()`.", en: "Creates a download from base64, data URL, file URI/path or an object returned by `pickFile()`." },
-    returns: { pt: "Metadados do arquivo salvo, `sourceType`, `notificationShown` e permissao de notificacao.", en: "Saved file metadata, `sourceType`, `notificationShown` and notification permission." },
-    handling: { pt: "Use `baixarBase64` para conteudo em memoria e `baixarArquivoLocal` para copiar arquivo normal com progresso. Para esconder a notificacao, passe `{ notificacao: false }`.", en: "Use `downloadBase64` for in-memory content and `downloadLocalFile` to copy a normal file with progress. To hide the notification, pass `{ notification: false }`." }
+    returns: { pt: "Metadados do arquivo salvo, `sourceType`, `notificationShown`, permissao de notificacao e publicacao opcional.", en: "Saved file metadata, `sourceType`, `notificationShown`, notification permission and optional public publication." },
+    handling: { pt: "Para imagem/video aparecer na galeria, passe `{ galeria: true }`. Para esconder a notificacao, passe `{ notificacao: false }`.", en: "For image/video to appear in the gallery, pass `{ gallery: true }`. To hide the notification, pass `{ notification: false }`." }
   },
   {
     syntax: { pt: "obterLocalizacao() / acompanharLocalizacao()", en: "getLocation() / watchLocation()" },
@@ -827,6 +988,27 @@ const nativeCodeEntries = [
     returns: { pt: "{ supported, authenticated, canceled, message }.", en: "{ supported, authenticated, canceled, message }." },
     handling: { pt: "Funciona em Android 9+. Se `supported` vier falso, use PIN/senha do proprio app como fallback.", en: "Works on Android 9+. If `supported` is false, use your app's own PIN/password fallback." }
   },
+  {
+    syntax: { pt: "solicitarBloqueio({ titulo })", en: "requestDeviceLock({ title })" },
+    java: "KeyguardManager",
+    description: { pt: "Abre a tela de bloqueio do Android (PIN, padrao, senha).", en: "Opens Android device lock screen (PIN, pattern, password)." },
+    returns: { pt: "{ supported, authenticated, canceled, message }.", en: "{ supported, authenticated, canceled, message }." },
+    handling: { pt: "Funciona se o usuario tiver senha cadastrada.", en: "Works if the user has a secure lock screen configured." }
+  },
+  {
+    syntax: { pt: "solicitarSegundoPlano()", en: "requestBackgroundExecution()" },
+    java: "Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS",
+    description: { pt: "Solicita ao sistema que o app funcione ativamente no background e inicie junto com o aparelho.", en: "Requests the system to run the app actively in the background and autostart on boot." },
+    returns: { pt: "{ ok, openedAutoStart, openedBatteryOptimization }.", en: "{ ok, openedAutoStart, openedBatteryOptimization }." },
+    handling: { pt: "Usa permissoes restritas. Play Store pode rejeitar apps sem justificativa valida para manter CPU ligada.", en: "Uses restricted permissions. Play Store might reject apps without a valid reason to keep CPU awake." }
+  },
+  {
+    syntax: { pt: "configurarInicioAutomatico(true/false)", en: "setAutoStartOnBoot(true/false)" },
+    java: "BootReceiver -> Intent",
+    description: { pt: "Define se o aplicativo deve ser aberto automaticamente quando o celular for ligado.", en: "Sets whether the app should automatically open when the device boots." },
+    returns: { pt: "{ ok, enabled }.", en: "{ ok, enabled }." },
+    handling: { pt: "Exige permissao de sobrepor a outros apps no Android 10+.", en: "Requires draw over other apps permission on Android 10+." }
+  },
   {
     syntax: { pt: "salvarSeguro('token', valor) / lerSeguro('token')", en: "saveSecure('token', value) / readSecure('token')" },
     java: "Android Keystore",
@@ -885,6 +1067,7 @@ if (!info.videoSupported) {
 ];
 
 [
+  "feedback",
   "feedback",
   "feedback",
   "notifications",
@@ -909,6 +1092,12 @@ if (!info.videoSupported) {
   "files",
   "share",
   "share",
+  "share",
+  "media",
+  "media",
+  "media",
+  "share",
+  "share",
   "device",
   "device",
   "device",
@@ -962,6 +1151,17 @@ const nativeCodeRecipes = [
       en: `await vibrate(250);`
     }
   },
+  {
+    when: { pt: "Para esperar entre duas linhas sem bloquear a interface.", en: "To wait between two lines without blocking the interface." },
+    example: {
+      pt: `await toast("Comecando");
+await aguardar(5000);
+await toast("Continuando");`,
+      en: `await toast("Starting");
+await loading(5000);
+await toast("Continuing");`
+    }
+  },
   {
     when: { pt: "Para mostrar uma notificacao simples agora. `aoClicar`, `acoes` e `open` sao opcionais.", en: "To show a simple notification now. `onClick`, `actions` and `open` are optional." },
     example: {
@@ -1186,6 +1386,111 @@ console.log(permissions);`
 // stop();`
     }
   },
+  {
+    when: { pt: "Para reagir a cabo/dispositivo USB e notificacoes locais.", en: "To react to USB cable/device changes and local notifications." },
+    example: {
+      pt: `aoConectarUSB((dados) => {
+  console.log("USB conectado", dados.origem, dados.dispositivo);
+});
+
+aoDesconectarUSB(() => {
+  console.log("USB desconectado");
+});
+
+aoReceberNotificacao((dados) => {
+  console.log("Notificação recebida", dados.titulo || dados.title);
+});`,
+      en: `onUSBConnect((data) => {
+  console.log("USB connected", data.source, data.device);
+});
+
+onUSBDisconnect(() => {
+  console.log("USB disconnected");
+});
+
+onNotificationReceived((data) => {
+  console.log("Notification received", data.title);
+});`
+    }
+  },
+  {
+    when: { pt: "Para reagir a fone, volume, teclado e orientação da tela.", en: "To react to headphones, volume, keyboard and screen orientation." },
+    example: {
+      pt: `aoConectarFone((dados) => {
+  console.log("Fone conectado", dados.dispositivo);
+});
+
+aoMudarVolume((dados) => {
+  console.log("Volume de mídia", dados.midia.atual);
+});
+
+aoAbrirTeclado((dados) => {
+  console.log("Teclado abriu", dados.alturaTeclado);
+});
+
+aoMudarOrientacao((dados) => {
+  console.log("Orientação", dados.orientacao);
+});`,
+      en: `onHeadphoneConnect((data) => {
+  console.log("Headphone connected", data.device);
+});
+
+onVolumeChange((data) => {
+  console.log("Media volume", data.music.current);
+});
+
+onKeyboardOpen((data) => {
+  console.log("Keyboard opened", data.keyboardHeight);
+});
+
+onOrientationChange((data) => {
+  console.log("Orientation", data.orientation);
+});`
+    }
+  },
+  {
+    when: { pt: "Para interações legais com sensores, print e NFC.", en: "For playful interactions with sensors, screenshots and NFC." },
+    example: {
+      pt: `aoSacudirCelular((dados) => {
+  console.log("Sacudiu", dados.forca);
+});
+
+aoVirarCelularParaBaixo(() => {
+  console.log("Tela virada para baixo");
+});
+
+aoAproximarObjeto((dados) => {
+  console.log("Algo chegou perto", dados.distancia);
+});
+
+aoTirarPrint((dados) => {
+  console.log("Print detectado", dados.uri);
+});
+
+aoNFC((dados) => {
+  console.log("Tag NFC", dados.id, dados.mensagens);
+});`,
+      en: `onPhoneShake((data) => {
+  console.log("Shaken", data.force);
+});
+
+onPhoneFaceDown(() => {
+  console.log("Phone is face down");
+});
+
+onProximityNear((data) => {
+  console.log("Something is near", data.distance);
+});
+
+onScreenshot((data) => {
+  console.log("Screenshot detected", data.uri);
+});
+
+onNFC((data) => {
+  console.log("NFC tag", data.id, data.messages);
+});`
+    }
+  },
   {
     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: {
@@ -1318,7 +1623,7 @@ if (image) {
   {
     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 });
+      pt: `const imagens = await escolherImagens({ multiplas: true });
 
 for (const imagem of imagens) {
   console.log(imagem.nome, imagem.tamanho);
@@ -1422,18 +1727,141 @@ if (saved.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." },
+    when: { pt: "Para abrir o compartilhamento nativo do Android com texto, link e arquivos.", en: "To open Android native sharing with text, link and files." },
     example: {
-      pt: `await compartilhar({
+      pt: `const imagem = await escolherImagem();
+
+await compartilhar({
   texto: "Veja esse app",
-  url: "https://exemplo.com"
+  url: "https://exemplo.com",
+  arquivo: imagem
 });`,
-      en: `await share({
+      en: `const image = await pickImage();
+
+await share({
   text: "Check this app",
-  url: "https://example.com"
+  url: "https://example.com",
+  file: image
 });`
     }
   },
+  {
+    when: { pt: "Para receber dados enviados pelo menu Compartilhar do Android.", en: "To receive data sent through Android's Share menu." },
+    example: {
+      pt: `aoReceberCompartilhamento((dados) => {
+  console.log(dados.tipo, dados.uri || dados.texto);
+});
+
+const inicial = await obterCompartilhamentoInicial();`,
+      en: `onShareReceived((data) => {
+  console.log(data.type, data.uri || data.text);
+});
+
+const initial = await getInitialShare();`
+    }
+  },
+  {
+    when: { pt: "Para trocar objetos entre dois celulares com apps html2apk abertos.", en: "To exchange objects between two phones running html2apk apps." },
+    example: {
+      pt: `aoConectarBT((dispositivo) => {
+  console.log("Conectado", dispositivo.nome);
+});
+
+aoReceberDadosBT((dados) => {
+  console.log("Recebido", dados);
+});
+
+aoDarErroBT((erro) => {
+  console.log("Erro Bluetooth", erro.mensagem || erro.message);
+});
+
+const lista = await procurarBT();
+await conectarBT(lista[0].id);
+await enviarBT({ mensagem: "Ola" });`,
+      en: `onBluetoothConnect((device) => {
+  console.log("Connected", device.name);
+});
+
+onBluetoothData((data) => {
+  console.log("Received", data);
+});
+
+onBluetoothError((error) => {
+  console.log("Bluetooth error", error.message);
+});
+
+const list = await scanBluetooth();
+await connectBluetooth(list[0].id);
+await sendBluetooth({ message: "Hello" });`
+    }
+  },
+  {
+    when: { pt: "Para trocar objetos entre dois celulares na mesma rede Wi-Fi ou hotspot.", en: "To exchange objects between two phones on the same Wi-Fi network or hotspot." },
+    example: {
+      pt: `aoConectarWiFi((dispositivo) => {
+  console.log("Conectado por Wi-Fi", dispositivo.nome || dispositivo.host);
+});
+
+aoReceberDadosWiFi((dados) => {
+  console.log("Recebido por Wi-Fi", dados);
+});
+
+aoDarErroWiFi((erro) => {
+  console.log("Erro Wi-Fi", erro.mensagem || erro.message);
+});
+
+const lista = await procurarWiFi();
+await conectarWiFi(lista[0].id);
+await enviarWiFi({ mensagem: "Ola por Wi-Fi" });`,
+      en: `onWiFiConnect((device) => {
+  console.log("Connected over Wi-Fi", device.name || device.host);
+});
+
+onWiFiData((data) => {
+  console.log("Received over Wi-Fi", data);
+});
+
+onWiFiError((error) => {
+  console.log("Wi-Fi error", error.message);
+});
+
+const list = await scanWiFi();
+await connectWiFi(list[0].id);
+await sendWiFi({ message: "Hello over Wi-Fi" });`
+    }
+  },
+  {
+    when: { pt: "Para reconhecer texto de uma foto sem enviar a imagem para servidor.", en: "To recognize text from a photo without sending the image to a server." },
+    example: {
+      pt: `const imagem = await escolherImagem();
+const resultado = await ocr(imagem);
+
+console.log(resultado.texto);`,
+      en: `const image = await pickImage();
+const result = await recognizeText(image);
+
+console.log(result.text);`
+    }
+  },
+  {
+    when: { pt: "Para falar texto e ouvir uma frase do usuario.", en: "To speak text and listen to a user phrase." },
+    example: {
+      pt: `await falar("Ola mundo", {
+  idioma: "pt-BR",
+  velocidade: 1
+});
+
+const voz = await ouvir({ idioma: "pt-BR" });
+console.log(voz.texto);`,
+      en: `await speak("Hello world", {
+  language: "en-US",
+  speed: 1
+});
+
+const voice = await recognizeSpeech({ language: "en-US" });
+console.log(voice.text);`
+    }
+  },
   {
     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: {
@@ -1618,23 +2046,46 @@ for (const app of result.apps) {
 }`
     }
   },
+  {
+    when: { pt: "Para ajustar volume e capturar a tela atual do app.", en: "To adjust volume and capture the current app screen." },
+    example: {
+      pt: `const volume = await volumeAtual();
+console.log(volume.midia.atual, volume.midia.maximo);
+
+await definirVolume("midia", 0.5, { mostrarUI: true });
+
+const imagem = await capturarTela();
+document.querySelector("img.preview").src = imagem.dataUrl;`,
+      en: `const volume = await getVolume();
+console.log(volume.music.current, volume.music.max);
+
+await setVolume("music", 0.5, { showUi: true });
+
+const image = await captureScreen();
+document.querySelector("img.preview").src = image.dataUrl;`
+    }
+  },
   {
     when: { pt: "Para apps que precisam mostrar/esconder o icone flutuante.", en: "For apps that need to show/hide the floating icon." },
     example: {
-      pt: `const status = await iniciarIconeFlutuante();
+      pt: `const status = await iniciarIconeFlutuante({ opacidade: 0.85 });
 
 if (status.requiresSettings) {
   console.log("O Android abriu a tela de sobreposicao");
 }
 
+await definirOpacidadeIconeFlutuante(0.55);
+
 // Para desligar:
 // await pararIconeFlutuante();`,
-      en: `const status = await startFloatingIcon();
+      en: `const status = await startFloatingIcon({ opacity: 0.85 });
 
 if (status.requiresSettings) {
   console.log("Android opened the draw-over-apps screen");
 }
 
+await setFloatingIconOpacity(0.55);
+
 // To turn it off:
 // await stopFloatingIcon();`
     }
@@ -1708,6 +2159,12 @@ const files = await listFiles();`
   "relatorio.pdf"
 );
 
+await baixarArquivo(
+  "https://exemplo.com/foto.png",
+  "foto.png",
+  { galeria: true }
+);
+
 await abrirArquivo("relatorio.pdf");
 // await compartilharArquivo("relatorio.pdf");`,
       en: `await downloadFile(
@@ -1715,6 +2172,12 @@ await abrirArquivo("relatorio.pdf");
   "report.pdf"
 );
 
+await downloadFile(
+  "https://example.com/photo.png",
+  "photo.png",
+  { gallery: true }
+);
+
 await openFile("report.pdf");
 // await shareFile("report.pdf");`
     }
@@ -1723,7 +2186,8 @@ await openFile("report.pdf");
     when: { pt: "Para transformar base64 ou um arquivo escolhido em download com barra de progresso.", en: "To turn base64 or a picked file into a download with a progress bar." },
     example: {
       pt: `await baixarBase64("pixel.png", base64, {
-  mimeType: "image/png"
+  mimeType: "image/png",
+  galeria: true
 });
 
 const arquivo = await escolherArquivo();
@@ -1731,7 +2195,8 @@ if (arquivo) {
   await baixarArquivoLocal(arquivo, "copia-" + arquivo.name);
 }`,
       en: `await downloadBase64("pixel.png", base64, {
-  mimeType: "image/png"
+  mimeType: "image/png",
+  gallery: true
 });
 
 const file = await pickFile();
@@ -1796,6 +2261,83 @@ if (bio.authenticated) {
 }`
     }
   },
+  {
+    when: { pt: "Para exigir a senha/PIN/padrao da tela de bloqueio do aparelho.", en: "To require the device's lock screen PIN/pattern/password." },
+    example: {
+      pt: `const auth = await solicitarBloqueio({
+  titulo: "Acesso Restrito",
+  descricao: "Confirme a senha de tela"
+});
+
+if (auth.autenticado) {
+  abrirNoApp("#/area-secreta");
+} else if (!auth.suportado) {
+  toast("Aparelho sem senha configurada");
+}`,
+      en: `const auth = await requestDeviceLock({
+  title: "Restricted Access",
+  description: "Confirm device password"
+});
+
+if (auth.authenticated) {
+  openInApp("#/secret-area");
+} else if (!auth.supported) {
+  toast("Device has no secure lock screen");
+}`
+    }
+  },
+  {
+    when: { pt: "Para manter o app ativo em segundo plano ou inicia-lo ao ligar (alarmes, rastreadores).", en: "To keep the app active in background or start on boot (alarms, trackers)." },
+    example: {
+      pt: `const resultado = await solicitarSegundoPlano();
+
+if (resultado.abriuInicioAutomatico) {
+  toast("Ligue a chave do nosso aplicativo");
+} else if (resultado.abriuOtimizacaoBateria) {
+  toast("Selecione 'Nao Otimizar' ou 'Sem Restricoes'");
+} else {
+  toast("Tudo pronto, permissao ja ativa!");
+}`,
+      en: `const result = await requestBackgroundExecution();
+
+if (result.openedAutoStart) {
+  toast("Turn on the switch for our application");
+} else if (result.openedBatteryOptimization) {
+  toast("Select 'No Restrictions' or 'Don't Optimize'");
+} else {
+  toast("All set, permission already granted!");
+}`
+    }
+  },
+  {
+    when: { pt: "Para fazer o app abrir sozinho na tela do usuario assim que o celular for ligado.", en: "To make the app automatically open on the user's screen as soon as the device boots." },
+    example: {
+      pt: `// 1. Opcional mas recomendado: pedir permissao de sobreposicao
+// para nao ser bloqueado no Android 10+
+await abrirSobreposicao();
+
+// 2. Ligar a chave
+await configurarInicioAutomatico(true);
+
+// 3. Ao iniciar seu app, use o ouvinte para se esconder:
+aoLigarDispositivo(async () => {
+  console.log("App abriu sozinho pelo boot!");
+  await minimizarApp(); // Esconde a tela na mesma hora
+});`,
+      en: `// 1. Optional but recommended: request overlay permission
+// to avoid being blocked on Android 10+
+await openOverlay();
+
+// 2. Turn on the switch
+await setAutoStartOnBoot(true);
+
+// 3. When starting your app, use the listener:
+onDeviceBoot(async () => {
+  console.log("App opened automatically by boot!");
+  await minimizeApp(); // Hides the app silently
+});`
+    }
+  },
   {
     when: { pt: "Para guardar tokens ou preferencias sensiveis cifradas pelo Android Keystore.", en: "To store tokens or sensitive preferences encrypted by Android Keystore." },
     example: {
@@ -2008,6 +2550,9 @@ function appendLogTo(container, line, kind) {
   }
 
   container.scrollTop = container.scrollHeight;
+  requestAnimationFrame(() => {
+    container.scrollTop = container.scrollHeight;
+  });
 }
 
 function appendLog(line, kind = "raw") {
@@ -2437,10 +2982,59 @@ async function createNewProjectFile() {
   }
 }
 
+const nativeCodeRecipeCache = new Map();
+
+function localizedRecipeText(value) {
+  if (!value) {
+    return "";
+  }
+
+  if (typeof value === "string") {
+    return value;
+  }
+
+  return [value.pt, value.en].filter(Boolean).join("\n");
+}
+
+function recipeSearchText(recipe) {
+  return [
+    localizedRecipeText(recipe && recipe.when),
+    localizedRecipeText(recipe && recipe.example)
+  ].join("\n");
+}
+
+function primaryCodeKey(entry) {
+  const syntax = entry && entry.syntax
+    ? entry.syntax.pt || entry.syntax.en || ""
+    : "";
+  const match = String(syntax).match(/([A-Za-z_$][\w$]*)\s*\(/);
+  return match ? match[1] : "";
+}
+
+function findRecipeForEntry(entry) {
+  const key = primaryCodeKey(entry);
+
+  if (!key) {
+    return null;
+  }
+
+  if (nativeCodeRecipeCache.has(key)) {
+    return nativeCodeRecipeCache.get(key);
+  }
+
+  const normalizedKey = key.toLowerCase();
+  const recipe = nativeCodeRecipes.find((item) => {
+    return recipeSearchText(item).toLowerCase().includes(normalizedKey);
+  }) || null;
+
+  nativeCodeRecipeCache.set(key, recipe);
+  return recipe;
+}
+
 function recipeForCode(index) {
   const language = currentLanguage();
   const entry = nativeCodeEntries[index] || {};
-  const recipe = entry.recipe || nativeCodeRecipes[index] || {};
+  const recipe = entry.recipe || findRecipeForEntry(entry) || {};
   return {
     when: recipe.when ? recipe.when[language] || recipe.when.pt : "",
     example: recipe.example ? recipe.example[language] || recipe.example.pt : ""
@@ -3603,7 +4197,7 @@ async function init() {
       elements.iconPreview.src = iconPreviewPath(state.defaultIconPath);
     }
   } catch {
-    elements.appVersion.textContent = "v0.7.0";
+    elements.appVersion.textContent = "v12.0.0";
   }
 
   setTimeout(finishBoot, 1800);