html2apk 0.8.0 → 0.11.0

package/src/desktop/renderer/renderer.js

@@ -105,6 +105,35 @@ const i18n = {
     codesEyebrow: "Bridge nativa",
     codesTitle: "Codigos interpretados",
     codesIntro: "Use estes blocos no JavaScript do seu projeto. O html2apk espera o Android ficar pronto, pede permissoes quando precisar e abre a configuracao certa quando o Android bloquear o pop-up.",
+    testNativeFunctions: "Testar funcoes",
+    functionLabRunning: "Gerando app de teste e abrindo no USB",
+    functionLabOk: "App de teste aberto no celular",
+    functionLabFail: "Nao foi possivel testar as funcoes",
+    functionLabProject: "App de teste criado",
+    functionLabSettings: "Configuracao de teste pronta",
+    functionLabUsbCheck: "Conferindo celular USB",
+    functionLabSuccessTitle: "App de teste aberto no celular",
+    functionLabSuccessText: "Use o celular conectado para experimentar as funcoes interpretadas e ver os retornos no proprio app.",
+    codesAll: "Tudo",
+    codesAllText: "Todas as funcoes interpretadas disponiveis no APK.",
+    codesFeedback: "Feedback",
+    codesFeedbackText: "Mensagens rapidas, vibracao e retornos simples.",
+    codesNotifications: "Notificacoes",
+    codesNotificationsText: "Notificacoes locais, agendamentos, loops e push remoto.",
+    codesPermissionsEvents: "Permissoes e eventos",
+    codesPermissionsEventsText: "Permissoes manuais, ciclo de vida, deep links e listeners nativos.",
+    codesMedia: "Midia e hardware",
+    codesMediaText: "Camera, QR Code, microfone, lanterna, imagens e videos.",
+    codesFiles: "Arquivos e dados",
+    codesFilesText: "Seletores, salvamento, CRUD interno, downloads e abertura de arquivos.",
+    codesShareNav: "Compartilhar e abrir",
+    codesShareNavText: "Compartilhamento, clipboard, URLs, WhatsApp, discador e mapas.",
+    codesDevice: "Tela e diagnostico",
+    codesDeviceText: "Tela ligada, brilho, tema, aparelho, rede, bateria, memoria e modo flutuante.",
+    codesSecurity: "Localizacao e seguranca",
+    codesSecurityText: "GPS, biometria e dados cifrados pelo Android Keystore.",
+    codesShowing: "Mostrando",
+    codesItems: "funcoes",
     javaLabel: "Motor nativo",
     doesLabel: "O que faz",
     whenUseLabel: "Quando usar",
@@ -291,6 +320,35 @@ const i18n = {
     codesEyebrow: "Native bridge",
     codesTitle: "Interpreted code",
     codesIntro: "Use these blocks in your project JavaScript. html2apk waits for Android to be ready, asks permissions when needed and opens the right settings screen when Android blocks the prompt.",
+    testNativeFunctions: "Test functions",
+    functionLabRunning: "Generating test app and opening it over USB",
+    functionLabOk: "Test app opened on the phone",
+    functionLabFail: "Could not test the functions",
+    functionLabProject: "Test app created",
+    functionLabSettings: "Test settings ready",
+    functionLabUsbCheck: "Checking USB phone",
+    functionLabSuccessTitle: "Test app opened on the phone",
+    functionLabSuccessText: "Use the connected phone to try the interpreted functions and see the results inside the app.",
+    codesAll: "All",
+    codesAllText: "All interpreted functions available in the APK.",
+    codesFeedback: "Feedback",
+    codesFeedbackText: "Short messages, vibration and simple native feedback.",
+    codesNotifications: "Notifications",
+    codesNotificationsText: "Local notifications, schedules, loops and remote push.",
+    codesPermissionsEvents: "Permissions and events",
+    codesPermissionsEventsText: "Manual permissions, lifecycle, deep links and native listeners.",
+    codesMedia: "Media and hardware",
+    codesMediaText: "Camera, QR Code, microphone, flashlight, images and videos.",
+    codesFiles: "Files and data",
+    codesFilesText: "Pickers, saving, internal CRUD, downloads and file opening.",
+    codesShareNav: "Share and open",
+    codesShareNavText: "Sharing, clipboard, URLs, WhatsApp, dialer and maps.",
+    codesDevice: "Screen and diagnostics",
+    codesDeviceText: "Keep awake, brightness, theme, device, network, battery, memory and floating mode.",
+    codesSecurity: "Location and security",
+    codesSecurityText: "GPS, biometrics and Android Keystore encrypted data.",
+    codesShowing: "Showing",
+    codesItems: "functions",
     javaLabel: "Native engine",
     doesLabel: "What it does",
     whenUseLabel: "When to use",
@@ -408,6 +466,11 @@ const permissionOptions = [
     label: { pt: "Vibracao", en: "Vibration" },
     detail: { pt: "Permite vibrar", en: "Allows vibration" }
   },
+  {
+    value: "SET_WALLPAPER",
+    label: { pt: "Papel de parede", en: "Wallpaper" },
+    detail: { pt: "Permite definir imagem estatica", en: "Allows setting a static image" }
+  },
   {
     value: "CAMERA",
     label: { pt: "Camera", en: "Camera" },
@@ -431,10 +494,23 @@ const permissionOptions = [
   {
     value: "SYSTEM_ALERT_WINDOW",
     label: { pt: "Sobrepor apps", en: "Draw over apps" },
-    detail: { pt: "Necessaria no modo flutuante", en: "Required for floating mode" }
+    detail: { pt: "Necessaria para icone flutuante", en: "Required for floating icon" }
   }
 ];
 
+const nativeCodeCategories = [
+  { id: "all", title: { pt: "Tudo", en: "All" }, description: { pt: "Todas as funcoes interpretadas disponiveis no APK.", en: "All interpreted functions available in the APK." } },
+  { id: "feedback", title: { pt: "Feedback", en: "Feedback" }, description: { pt: "Mensagens rapidas, vibracao e retornos simples.", en: "Short messages, vibration and simple native feedback." } },
+  { id: "notifications", title: { pt: "Notificacoes", en: "Notifications" }, description: { pt: "Notificacoes locais, agendamentos, loops e push remoto.", en: "Local notifications, schedules, loops and remote push." } },
+  { id: "permissions", title: { pt: "Permissoes e eventos", en: "Permissions and events" }, description: { pt: "Permissoes manuais, ciclo de vida, deep links e listeners nativos.", en: "Manual permissions, lifecycle, deep links and native listeners." } },
+  { id: "media", title: { pt: "Midia e hardware", en: "Media and hardware" }, description: { pt: "Camera, QR Code, microfone, lanterna, imagens e videos.", en: "Camera, QR Code, microphone, flashlight, images and videos." } },
+  { id: "wallpaper", title: { pt: "Papel de parede", en: "Wallpaper" }, description: { pt: "Imagem estatica na tela inicial/bloqueio e atalho para ajustes nativos.", en: "Static images for home/lock screen and shortcut to native settings." } },
+  { id: "files", title: { pt: "Arquivos e dados", en: "Files and data" }, description: { pt: "Seletores, salvamento, CRUD interno, downloads e abertura de arquivos.", en: "Pickers, saving, internal CRUD, downloads and file opening." } },
+  { id: "share", title: { pt: "Compartilhar e abrir", en: "Share and open" }, description: { pt: "Compartilhamento, clipboard, URLs, WhatsApp, discador e mapas.", en: "Sharing, clipboard, URLs, WhatsApp, dialer and maps." } },
+  { id: "device", title: { pt: "Tela e diagnostico", en: "Screen and diagnostics" }, description: { pt: "Tela ligada, brilho, tema, aparelho, rede, bateria, memoria e modo flutuante.", en: "Keep awake, brightness, theme, device, network, battery, memory and floating mode." } },
+  { id: "security", title: { pt: "Localizacao e seguranca", en: "Location and security" }, description: { pt: "GPS, biometria e dados cifrados pelo Android Keystore.", en: "GPS, biometrics and Android Keystore encrypted data." } }
+];
+
 const nativeCodeEntries = [
   {
     syntax: { pt: "toast('Mensagem')", en: "toast('Message')" },
@@ -450,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",
@@ -495,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." }
   },
@@ -506,6 +589,90 @@ 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() / aoAbrirLink(fn)", en: "getInitialLink() / onOpenLink(fn)" },
     java: "getInitialLink",
@@ -543,15 +710,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." }
   },
@@ -580,7 +747,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." }
   },
   {
@@ -591,11 +758,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()" },
@@ -663,7 +879,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." }
   },
@@ -698,12 +914,185 @@ const nativeCodeEntries = [
   {
     syntax: { pt: "iniciarIconeFlutuante() / pararIconeFlutuante()", en: "startFloatingIcon() / stopFloatingIcon()" },
     java: "FloatingIconService",
-    description: { pt: "Controla o icone flutuante quando o app foi gerado em modo floating.", en: "Controls the floating icon when the app was generated in floating mode." },
-    returns: { pt: "Promise<void>.", en: "Promise<void>." },
-    handling: { pt: "`iniciarIconeFlutuante()` abre a tela de permissao automaticamente se faltar sobreposicao. Quando o usuario voltar, chame novamente para iniciar.", en: "`startFloatingIcon()` opens the permission screen automatically if draw-over-apps is missing. When the user comes back, call it again to start." }
+    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()" },
+    java: "ACTION_IMAGE_CAPTURE / ACTION_VIDEO_CAPTURE",
+    description: { pt: "Abre a camera nativa para capturar foto ou video e retorna um arquivo app-scoped.", en: "Opens the native camera to capture a photo or video and returns an app-scoped file." },
+    returns: { pt: "{ uri, name, size, mimeType, kind }. Com `{ base64: true }`, tambem retorna base64.", en: "{ uri, name, size, mimeType, kind }. With `{ base64: true }`, it also returns base64." },
+    handling: { pt: "A permissao de camera e pedida automaticamente. Trate objeto vazio como cancelamento do usuario.", en: "Camera permission is requested automatically. Treat an empty object as user cancellation." }
+  },
+  {
+    syntax: { pt: "escanearQRCode()", en: "scanQRCode()" },
+    java: "BarcodeDetector + camera",
+    description: { pt: "Tira uma foto e tenta ler QR Code pelo WebView quando `BarcodeDetector` estiver disponivel.", en: "Takes a photo and tries to read a QR code through the WebView when `BarcodeDetector` is available." },
+    returns: { pt: "{ text, rawValue, format, photo } ou null se nenhum QR for encontrado.", en: "{ text, rawValue, format, photo } or null when no QR is found." },
+    handling: { pt: "Se o WebView do aparelho nao tiver `BarcodeDetector`, a Promise rejeita; mantenha fallback para digitar/colar o codigo.", en: "If the device WebView does not have `BarcodeDetector`, the Promise rejects; keep a fallback to type/paste the code." }
+  },
+  {
+    syntax: { pt: "salvarArquivo('nome.json', minhaVariavel) / lerArquivo('nome.json')", en: "saveFile('name.json', myValue) / readFile('name.json')" },
+    java: "app-scoped external files",
+    description: { pt: "CRUD de arquivos persistentes no armazenamento app-scoped, sem abrir seletor de documento.", en: "Persistent file CRUD in app-scoped storage, without opening a document picker." },
+    returns: { pt: "`salvarArquivo` retorna metadados; `lerArquivo` retorna o valor salvo; `listarArquivos` retorna a lista.", en: "`saveFile` returns metadata; `readFile` returns the saved value; `listFiles` returns the list." },
+    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, '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 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, { 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`, 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()" },
+    java: "LocationManager",
+    description: { pt: "Le a localizacao atual ou inicia acompanhamento por evento `localizacao:mudou`.", en: "Reads current location or starts watching through the `location:changed` event." },
+    returns: { pt: "{ latitude, longitude, accuracy, provider } ou { watchId }.", en: "{ latitude, longitude, accuracy, provider } or { watchId }." },
+    handling: { pt: "A permissao e pedida automaticamente. Pare acompanhamento com `pararLocalizacao(watchId)` quando sair da tela.", en: "Permission is requested automatically. Stop watching with `stopLocationWatch(watchId)` when leaving the screen." }
+  },
+  {
+    syntax: { pt: "autenticarBiometria({ titulo })", en: "authenticateBiometric({ title })" },
+    java: "BiometricPrompt",
+    description: { pt: "Abre a biometria/tela segura do Android para confirmar identidade.", en: "Opens Android biometric/secure prompt to confirm identity." },
+    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: "salvarSeguro('token', valor) / lerSeguro('token')", en: "saveSecure('token', value) / readSecure('token')" },
+    java: "Android Keystore",
+    description: { pt: "Guarda pequenos segredos cifrados com chave do Android Keystore.", en: "Stores small secrets encrypted with an Android Keystore key." },
+    returns: { pt: "`lerSeguro` retorna o valor salvo; `listarSeguro` retorna chaves; `removerSeguro` apaga.", en: "`readSecure` returns the saved value; `listSecureKeys` returns keys; `deleteSecure` removes." },
+    handling: { pt: "Use para tokens e dados pequenos. Nao use para arquivos grandes; para isso, use o CRUD de arquivos.", en: "Use it for tokens and small data. Do not use it for large files; use file CRUD for that." }
+  },
+  {
+    syntax: { pt: "definirPapelParede('foto.jpg', { alvo: 'inicio' })", en: "setWallpaper('photo.jpg', { target: 'home' })" },
+    java: "WallpaperManager",
+    description: { pt: "Define imagem estatica como papel de parede da tela inicial, bloqueio ou ambas.", en: "Sets a static image as home, lock or both wallpapers." },
+    returns: { pt: "{ applied, systemApplied, lockApplied, lockSupported, mimeType }.", en: "{ applied, systemApplied, lockApplied, lockSupported, mimeType }." },
+    handling: { pt: "Aceita nome salvo por `salvarArquivo`, `content://`/`file://` ou `{ base64, mimeType }`. Video retorna aviso e deve seguir pelo ajuste/live wallpaper do Android.", en: "Accepts a name saved by `saveFile`, `content://`/`file://` or `{ base64, mimeType }`. Video returns a warning and must use Android settings/live wallpaper flow." },
+    recipe: {
+      when: { pt: "Para aplicar uma imagem ja salva no armazenamento do app como papel de parede inicial.", en: "To apply an image already saved in app storage as the home wallpaper." },
+      example: {
+        pt: `const resultado = await definirPapelParede("foto.jpg", {
+  alvo: "inicio"
+});
+
+if (!resultado.applied) {
+  console.log(resultado);
+}`,
+        en: `const result = await setWallpaper("photo.jpg", {
+  target: "home"
+});
+
+if (!result.applied) {
+  console.log(result);
+}`
+      }
+    }
+  },
+  {
+    syntax: { pt: "infoPapelParede() / abrirConfiguracaoPapelParede()", en: "wallpaperInfo() / openWallpaperSettings()" },
+    java: "android.settings.WALLPAPER_SETTINGS",
+    description: { pt: "Consulta capacidades do aparelho e abre a tela nativa para escolhas manuais.", en: "Checks device capabilities and opens the native screen for manual choices." },
+    returns: { pt: "`infoPapelParede` retorna suporte a imagem/bloqueio/video. `abrirConfiguracaoPapelParede` retorna se a tela abriu.", en: "`wallpaperInfo` returns image/lock/video support. `openWallpaperSettings` returns whether the screen opened." },
+    handling: { pt: "Use para casos fora do caminho simples, como video wallpaper ou aparelhos que exigem confirmacao do usuario.", en: "Use it for cases outside the simple path, such as video wallpaper or devices that require user confirmation." },
+    recipe: {
+      when: { pt: "Para lidar com video wallpaper ou aparelhos que pedem escolha manual do usuario.", en: "To handle video wallpaper or devices that require a manual user choice." },
+      example: {
+        pt: `const info = await infoPapelParede();
+
+if (!info.videoSupported) {
+  await abrirConfiguracaoPapelParede();
+}`,
+        en: `const info = await wallpaperInfo();
+
+if (!info.videoSupported) {
+  await openWallpaperSettings();
+}`
+      }
+    }
   }
 ];
 
+[
+  "feedback",
+  "feedback",
+  "feedback",
+  "notifications",
+  "notifications",
+  "notifications",
+  "notifications",
+  "notifications",
+  "permissions",
+  "permissions",
+  "permissions",
+  "permissions",
+  "permissions",
+  "media",
+  "media",
+  "media",
+  "media",
+  "media",
+  "files",
+  "files",
+  "media",
+  "files",
+  "files",
+  "share",
+  "share",
+  "share",
+  "media",
+  "media",
+  "media",
+  "share",
+  "share",
+  "device",
+  "device",
+  "device",
+  "share",
+  "share",
+  "share",
+  "share",
+  "device",
+  "device",
+  "device",
+  "device",
+  "device",
+  "device",
+  "device",
+  "media",
+  "media",
+  "files",
+  "files",
+  "files",
+  "security",
+  "security",
+  "security",
+  "wallpaper",
+  "wallpaper"
+].forEach((category, index) => {
+  if (nativeCodeEntries[index]) {
+    nativeCodeEntries[index].category = category;
+  }
+});
+
 const nativeCodeRecipes = [
   {
     when: { pt: "Para avisos curtos dentro do app, como sucesso, erro simples ou confirmacao.", en: "For short in-app feedback such as success, simple errors or confirmations." },
@@ -727,6 +1116,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: {
@@ -951,6 +1351,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: {
@@ -1083,7 +1588,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);
@@ -1187,18 +1692,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: {
@@ -1384,25 +2012,236 @@ for (const app of result.apps) {
     }
   },
   {
-    when: { pt: "Para apps em modo floating que precisam mostrar/esconder o icone flutuante.", en: "For floating-mode apps that need to show/hide the floating icon." },
+    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 status = await iniciarIconeFlutuante();
+      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({ 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();`
     }
+  },
+  {
+    when: { pt: "Para capturar uma imagem ou video feito na hora pelo usuario.", en: "To capture an image or video made by the user right now." },
+    example: {
+      pt: `const foto = await tirarFoto({ base64: true });
+
+if (foto.base64) {
+  document.querySelector("img.preview").src =
+    "data:" + foto.mimeType + ";base64," + foto.base64;
+}`,
+      en: `const photo = await takePhoto({ base64: true });
+
+if (photo.base64) {
+  document.querySelector("img.preview").src =
+    "data:" + photo.mimeType + ";base64," + photo.base64;
+}`
+    }
+  },
+  {
+    when: { pt: "Para ler um QR Code quando o WebView do aparelho oferecer BarcodeDetector.", en: "To read a QR code when the device WebView provides BarcodeDetector." },
+    example: {
+      pt: `try {
+  const qr = await escanearQRCode();
+  if (qr) {
+    console.log("QR:", qr.text);
+  }
+} catch (erro) {
+  await toast("Digite ou cole o codigo");
+}`,
+      en: `try {
+  const qr = await scanQRCode();
+  if (qr) {
+    console.log("QR:", qr.text);
+  }
+} catch (error) {
+  await toast("Type or paste the code");
+}`
+    }
+  },
+  {
+    when: { pt: "Para gravar e recuperar uma variavel pelo nome, sem abrir seletor de arquivo.", en: "To save and recover a variable by name, without opening a file picker." },
+    example: {
+      pt: `await salvarArquivo("perfil.json", {
+  nome: "Ana",
+  plano: "premium"
+});
+
+const perfil = await lerArquivo("perfil.json");
+console.log(perfil.nome);
+
+const arquivos = await listarArquivos();`,
+      en: `await saveFile("profile.json", {
+  name: "Ana",
+  plan: "premium"
+});
+
+const profile = await readFile("profile.json");
+console.log(profile.name);
+
+const files = await listFiles();`
+    }
+  },
+  {
+    when: { pt: "Para baixar um PDF ou imagem e abrir/compartilhar depois.", en: "To download a PDF or image and open/share it later." },
+    example: {
+      pt: `await baixarArquivo(
+  "https://exemplo.com/relatorio.pdf",
+  "relatorio.pdf"
+);
+
+await baixarArquivo(
+  "https://exemplo.com/foto.png",
+  "foto.png",
+  { galeria: true }
+);
+
+await abrirArquivo("relatorio.pdf");
+// await compartilharArquivo("relatorio.pdf");`,
+      en: `await downloadFile(
+  "https://example.com/report.pdf",
+  "report.pdf"
+);
+
+await downloadFile(
+  "https://example.com/photo.png",
+  "photo.png",
+  { gallery: true }
+);
+
+await openFile("report.pdf");
+// await shareFile("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",
+  galeria: true
+});
+
+const arquivo = await escolherArquivo();
+if (arquivo) {
+  await baixarArquivoLocal(arquivo, "copia-" + arquivo.name);
+}`,
+      en: `await downloadBase64("pixel.png", base64, {
+  mimeType: "image/png",
+  gallery: true
+});
+
+const file = await pickFile();
+if (file) {
+  await downloadLocalFile(file, "copy-" + file.name);
+}`
+    }
+  },
+  {
+    when: { pt: "Para preencher mapa, check-in ou entrega usando localizacao atual.", en: "To fill maps, check-ins or delivery flows using current location." },
+    example: {
+      pt: `const local = await obterLocalizacao({
+  altaPrecisao: true,
+  timeoutMs: 10000
+});
+
+if (local.latitude) {
+  console.log(local.latitude, local.longitude);
+}
+
+const watch = await acompanharLocalizacao();
+const parar = aoMudarLocalizacao(console.log);
+
+// Ao sair da tela:
+await pararLocalizacao(watch.watchId);
+parar();`,
+      en: `const location = await getLocation({
+  highAccuracy: true,
+  timeoutMs: 10000
+});
+
+if (location.latitude) {
+  console.log(location.latitude, location.longitude);
+}
+
+const watch = await watchLocation();
+const stopEvent = onLocationChange(console.log);
+
+// When leaving the screen:
+await stopLocationWatch(watch.watchId);
+stopEvent();`
+    }
+  },
+  {
+    when: { pt: "Para confirmar uma acao sensivel antes de abrir dados ou finalizar pagamento.", en: "To confirm a sensitive action before opening data or finishing payment." },
+    example: {
+      pt: `const bio = await autenticarBiometria({
+  titulo: "Confirmar acesso",
+  descricao: "Use a biometria do aparelho"
+});
+
+if (bio.authenticated) {
+  abrirNoApp("#/seguro");
+}`,
+      en: `const bio = await authenticateBiometric({
+  title: "Confirm access",
+  description: "Use this device biometrics"
+});
+
+if (bio.authenticated) {
+  openInApp("#/secure");
+}`
+    }
+  },
+  {
+    when: { pt: "Para guardar tokens ou preferencias sensiveis cifradas pelo Android Keystore.", en: "To store tokens or sensitive preferences encrypted by Android Keystore." },
+    example: {
+      pt: `await salvarSeguro("token", "abc123");
+
+const token = await lerSeguro("token");
+console.log(token);
+
+await removerSeguro("token");`,
+      en: `await saveSecure("token", "abc123");
+
+const token = await readSecure("token");
+console.log(token);
+
+await deleteSecure("token");`
+    }
   }
 ];
 
@@ -1425,6 +2264,7 @@ const state = {
   currentFileDirty: false,
   animationTimer: null,
   progress: 0,
+  nativeCodeCategory: localStorage.getItem("html2apk.nativeCodeCategory") || "all",
   logsVisible: localStorage.getItem("html2apk.logsVisible") === "true"
 };
 
@@ -1493,7 +2333,10 @@ function collectElements() {
     "progressBar",
     "progressPercent",
     "reviewGrid",
+    "nativeCodeCategories",
+    "nativeCodeSummary",
     "nativeCodeGrid",
+    "nativeFunctionLabButton",
     "resultPanel",
     "apkPath",
     "openDistButton",
@@ -1595,6 +2438,9 @@ function appendLogTo(container, line, kind) {
   }
 
   container.scrollTop = container.scrollHeight;
+  requestAnimationFrame(() => {
+    container.scrollTop = container.scrollHeight;
+  });
 }
 
 function appendLog(line, kind = "raw") {
@@ -1692,6 +2538,7 @@ function updateActionButtons() {
   elements.doctorButton.disabled = !hasProject || isBusy;
   elements.settingsNextButton.disabled = !hasProject || !state.settingsValid || !state.environmentOk || isBusy;
   elements.newFileButton.disabled = !hasProject;
+  elements.nativeFunctionLabButton.disabled = isBusy;
   setBuildButtons(hasProject && state.settingsValid && state.environmentOk && !isBusy);
 }
 
@@ -1762,51 +2609,134 @@ function escapeHtml(value) {
     .replace(/"/g, "&quot;");
 }
 
+function syntaxToken(type, value) {
+  return `<span class="syntax-token-${type}">${escapeHtml(value)}</span>`;
+}
+
+function highlightByRegex(value, regex, classify) {
+  const source = String(value || "");
+  let html = "";
+  let cursor = 0;
+
+  source.replace(regex, (match, ...args) => {
+    const index = args[args.length - 2];
+    const tokenType = classify(match, index, source);
+    html += escapeHtml(source.slice(cursor, index));
+    html += tokenType ? syntaxToken(tokenType, match) : escapeHtml(match);
+    cursor = index + match.length;
+    return match;
+  });
+
+  html += escapeHtml(source.slice(cursor));
+  return html;
+}
+
+function highlightJavaScript(value) {
+  const keywordList = [
+    "await", "async", "break", "case", "catch", "class", "const", "continue", "default", "delete",
+    "do", "else", "export", "extends", "false", "finally", "for", "from", "function", "if",
+    "import", "in", "instanceof", "let", "new", "null", "return", "super", "switch", "this",
+    "throw", "true", "try", "typeof", "undefined", "var", "void", "while", "yield"
+  ];
+  const keywords = new Set(keywordList);
+  const keywordPattern = keywordList.join("|");
+  const regex = new RegExp("\\/\\*[\\s\\S]*?\\*\\/|\\/\\/[^\\n\\r]*|\"(?:\\\\.|[^\"\\\\])*\"|'(?:\\\\.|[^'\\\\])*'|`(?:\\\\.|[^`\\\\])*`|\\b\\d+(?:\\.\\d+)?\\b|\\b(?:" + keywordPattern + ")\\b|\\b[A-Za-z_$][\\w$]*(?=\\s*\\()", "g");
+
+  return highlightByRegex(value, regex, (match) => {
+    if (match.startsWith("//") || match.startsWith("/*")) {
+      return "comment";
+    }
+    if (match.startsWith("\"") || match.startsWith("'") || match.startsWith("`")) {
+      return "string";
+    }
+    if (/^\d/.test(match)) {
+      return "number";
+    }
+    if (keywords.has(match)) {
+      return "keyword";
+    }
+    return "function";
+  });
+}
+
+function highlightHtmlLike(value) {
+  return highlightByRegex(value, /<!--[\s\S]*?-->|<!doctype[^>]*>|<\/?[a-zA-Z][^>]*?>/gi, (match) => {
+    if (match.startsWith("<!--")) {
+      return "comment";
+    }
+    return "tag";
+  });
+}
+
+function highlightCss(value) {
+  const regex = /\/\*[\s\S]*?\*\/|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|#[0-9a-fA-F]{3,8}\b|\b\d+(?:\.\d+)?(?:px|rem|em|%|vh|vw|s|ms)?\b|[a-zA-Z-]+(?=\s*:)|[.#]?[a-zA-Z0-9_-]+(?=[^{;]*\{)/g;
+  return highlightByRegex(value, regex, (match) => {
+    if (match.startsWith("/*")) {
+      return "comment";
+    }
+    if (match.startsWith("\"") || match.startsWith("'")) {
+      return "string";
+    }
+    if (match.startsWith("#") || /^\d/.test(match)) {
+      return "number";
+    }
+    if (/^[a-zA-Z-]+$/.test(match)) {
+      return "keyword";
+    }
+    return "tag";
+  });
+}
+
+function highlightJson(value) {
+  const regex = /"(?:\\.|[^"\\])*"(?=\s*:)|"(?:\\.|[^"\\])*"|-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b|\b(?:true|false|null)\b/gi;
+  return highlightByRegex(value, regex, (match, index, source) => {
+    if (match.startsWith("\"")) {
+      return /^\s*:/.test(source.slice(index + match.length)) ? "keyword" : "string";
+    }
+    if (/^(true|false|null)$/i.test(match)) {
+      return "keyword";
+    }
+    return "number";
+  });
+}
+
 function highlightSource(value, language) {
-  let html = escapeHtml(value);
   const lang = String(language || "").toLowerCase();
 
   if (["html", "xml", "svg"].includes(lang)) {
-    html = html
-      .replace(/(&lt;!--[\s\S]*?--&gt;)/g, "<span class=\"syntax-token-comment\">$1</span>")
-      .replace(/(&lt;\/?[a-zA-Z][^&]*?&gt;)/g, "<span class=\"syntax-token-tag\">$1</span>");
-    return html;
+    return highlightHtmlLike(value);
   }
-
   if (["js", "mjs", "cjs", "ts", "tsx", "jsx"].includes(lang)) {
-    html = html
-      .replace(/\b(await|async|const|let|var|function|return|if|else|for|while|try|catch|throw|new|class|import|export|from|true|false|null|undefined)\b/g, "<span class=\"syntax-token-keyword\">$1</span>")
-      .replace(/\b(\d+(?:\.\d+)?)\b/g, "<span class=\"syntax-token-number\">$1</span>")
-      .replace(/(\/\*[\s\S]*?\*\/|\/\/[^\n\r]*)/g, "<span class=\"syntax-token-comment\">$1</span>")
-      .replace(/(&quot;.*?&quot;|'.*?'|`[\s\S]*?`)/g, "<span class=\"syntax-token-string\">$1</span>");
-    return html;
+    return highlightJavaScript(value);
   }
-
   if (lang === "css") {
-    html = html
-      .replace(/(\/\*[\s\S]*?\*\/)/g, "<span class=\"syntax-token-comment\">$1</span>")
-      .replace(/([.#]?[a-zA-Z0-9_-]+)(\s*\{)/g, "<span class=\"syntax-token-tag\">$1</span>$2")
-      .replace(/(:\s*)([^;\n]+)(;?)/g, "$1<span class=\"syntax-token-string\">$2</span>$3");
-    return html;
+    return highlightCss(value);
   }
-
   if (lang === "json") {
-    html = html
-      .replace(/(&quot;[^&]+&quot;)(\s*:)/g, "<span class=\"syntax-token-keyword\">$1</span>$2")
-      .replace(/(:\s*)(&quot;.*?&quot;)/g, "$1<span class=\"syntax-token-string\">$2</span>")
-      .replace(/\b(true|false|null)\b/g, "<span class=\"syntax-token-keyword\">$1</span>")
-      .replace(/\b(\d+(?:\.\d+)?)\b/g, "<span class=\"syntax-token-number\">$1</span>");
+    return highlightJson(value);
   }
 
-  return html;
+  return escapeHtml(value);
 }
 
 function updateFilePreview() {
-  if (!elements.fileHighlight) {
+  if (!elements.fileHighlight || !elements.fileEditorInput) {
     return;
   }
 
-  elements.fileHighlight.innerHTML = `<code>${highlightSource(elements.fileEditorInput.value, state.currentFileLanguage)}</code>`;
+  const value = elements.fileEditorInput.value || "";
+  const highlighted = highlightSource(value.length ? value : " ", state.currentFileLanguage);
+  elements.fileHighlight.innerHTML = `<code>${highlighted}</code>`;
+  syncFileEditorHighlightScroll();
+}
+
+function syncFileEditorHighlightScroll() {
+  if (!elements.fileHighlight || !elements.fileEditorInput) {
+    return;
+  }
+
+  elements.fileHighlight.scrollTop = elements.fileEditorInput.scrollTop;
+  elements.fileHighlight.scrollLeft = elements.fileEditorInput.scrollLeft;
 }
 
 function setCurrentFileDirty(value) {
@@ -1891,6 +2821,8 @@ async function openProjectFile(relativePath) {
     elements.fileLanguageBadge.textContent = state.currentFileLanguage;
     elements.fileEditorInput.disabled = false;
     elements.fileEditorInput.value = file.content || "";
+    elements.fileEditorInput.scrollTop = 0;
+    elements.fileEditorInput.scrollLeft = 0;
     setCurrentFileDirty(false);
     updateFilePreview();
     renderFileTree();
@@ -1938,9 +2870,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 recipe = nativeCodeRecipes[index] || {};
+  const entry = nativeCodeEntries[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 : ""
@@ -1966,6 +2948,14 @@ async function copyToClipboard(value) {
 }
 
 async function handleNativeCodeCopy(event) {
+  const categoryButton = event.target.closest("[data-code-category]");
+  if (categoryButton) {
+    state.nativeCodeCategory = categoryButton.dataset.codeCategory || "all";
+    localStorage.setItem("html2apk.nativeCodeCategory", state.nativeCodeCategory);
+    renderNativeCodeGrid();
+    return;
+  }
+
   const button = event.target.closest("[data-copy-code]");
   if (!button) {
     return;
@@ -2125,6 +3115,20 @@ function renderNativeCodeGrid() {
   }
 
   const language = currentLanguage();
+  const activeCategory = nativeCodeCategories.some((category) => category.id === state.nativeCodeCategory)
+    ? state.nativeCodeCategory
+    : "all";
+  state.nativeCodeCategory = activeCategory;
+  const categoryCounts = nativeCodeEntries.reduce((counts, entry) => {
+    const category = entry.category || "device";
+    counts[category] = (counts[category] || 0) + 1;
+    counts.all = (counts.all || 0) + 1;
+    return counts;
+  }, {});
+  const activeCategoryMeta = nativeCodeCategories.find((category) => category.id === activeCategory) || nativeCodeCategories[0];
+  const visibleEntries = nativeCodeEntries
+    .map((entry, index) => ({ entry, index }))
+    .filter((item) => activeCategory === "all" || item.entry.category === activeCategory);
   const javaLabel = text("javaLabel");
   const doesLabel = text("doesLabel");
   const whenUseLabel = text("whenUseLabel");
@@ -2132,17 +3136,45 @@ function renderNativeCodeGrid() {
   const handlingLabel = text("handlingLabel");
   const exampleLabel = text("exampleLabel");
   const copyCodeLabel = text("copyCode");
-  elements.nativeCodeGrid.innerHTML = nativeCodeEntries.map((entry, index) => {
+
+  if (elements.nativeCodeCategories) {
+    elements.nativeCodeCategories.innerHTML = nativeCodeCategories.map((category) => {
+      const title = category.title[language] || category.title.pt;
+      const description = category.description[language] || category.description.pt;
+      const count = categoryCounts[category.id] || 0;
+      const active = category.id === activeCategory ? " active" : "";
+      return `
+        <button type="button" class="code-category-button${active}" data-code-category="${escapeHtml(category.id)}" aria-pressed="${category.id === activeCategory}">
+          <strong>${escapeHtml(title)}</strong>
+          <span class="code-category-count">${count}</span>
+          <small>${escapeHtml(description)}</small>
+        </button>
+      `;
+    }).join("");
+  }
+
+  if (elements.nativeCodeSummary) {
+    const title = activeCategoryMeta.title[language] || activeCategoryMeta.title.pt;
+    const description = activeCategoryMeta.description[language] || activeCategoryMeta.description.pt;
+    elements.nativeCodeSummary.innerHTML = `
+      <strong>${escapeHtml(title)} · ${escapeHtml(text("codesShowing"))} ${visibleEntries.length} ${escapeHtml(text("codesItems"))}</strong>
+      <p>${escapeHtml(description)}</p>
+    `;
+  }
+
+  elements.nativeCodeGrid.innerHTML = visibleEntries.map(({ entry, index }) => {
     const syntax = entry.syntax ? entry.syntax[language] || entry.syntax.pt : entry.js;
     const description = entry.description[language] || entry.description.pt;
     const returns = entry.returns[language] || entry.returns.pt;
     const handling = entry.handling[language] || entry.handling.pt;
     const recipe = recipeForCode(index);
+    const highlightedSyntax = highlightSource(syntax, "js");
+    const highlightedExample = recipe.example ? highlightSource(recipe.example, "js") : "";
 
     return `
     <article class="code-card">
       <div class="code-card-top">
-        <code>${escapeHtml(syntax)}</code>
+        <code class="syntax-inline">${highlightedSyntax}</code>
         <span>${escapeHtml(javaLabel)}: ${escapeHtml(entry.java)}</span>
       </div>
       <p><strong>${escapeHtml(doesLabel)}:</strong> ${escapeHtml(description)}</p>
@@ -2154,7 +3186,7 @@ function renderNativeCodeGrid() {
           <strong>${escapeHtml(exampleLabel)}</strong>
           <button type="button" class="copy-code-button" data-copy-code="${index}">${escapeHtml(copyCodeLabel)}</button>
         </div>
-        <pre><code>${escapeHtml(recipe.example)}</code></pre>
+        <pre><code>${highlightedExample}</code></pre>
       </div>
     </article>
   `;
@@ -2521,7 +3553,9 @@ async function summarizeProject(project) {
   elements.fileLanguageBadge.textContent = "text";
   elements.fileEditorInput.value = "";
   elements.fileEditorInput.disabled = true;
-  elements.fileHighlight.innerHTML = "<code></code>";
+  elements.fileEditorInput.scrollTop = 0;
+  elements.fileEditorInput.scrollLeft = 0;
+  updateFilePreview();
   elements.saveFileButton.disabled = true;
   populateSettings(project.config || {}, project);
   setStep("folder", project.hasEntryFile ? "done" : "active", project.hasEntryFile ? text("folderReady") : text("missing"));
@@ -2751,6 +3785,74 @@ async function runUsbDebugFlow() {
   }
 }
 
+async function runNativeFunctionLabFlow() {
+  if (state.buildRunning) {
+    setStatus("error", text("functionLabRunning"));
+    return;
+  }
+  if (!api.runNativeFunctionLab) {
+    setStatus("error", text("functionLabFail"));
+    return;
+  }
+
+  showLogBar();
+  state.buildRunning = true;
+  updateActionButtons();
+  elements.resultPanel.classList.add("hidden");
+  setView("build");
+  setStatus("busy", text("functionLabRunning"));
+  setStep("folder", "done", text("functionLabProject"));
+  setStep("settings", "done", text("functionLabSettings"));
+  setStep("doctor", "active", text("functionLabUsbCheck"));
+  setStep("build", "active", text("functionLabRunning"));
+  setProgress(20, text("functionLabUsbCheck"), "active");
+  startAnimatedLogs();
+
+  try {
+    const response = await api.runNativeFunctionLab();
+    stopAnimatedLogs();
+    if (!response.ok) {
+      setStep("doctor", "error", text("functionLabUsbCheck"));
+      setStep("build", "error", text("functionLabFail"));
+      setStatus("error", text("functionLabFail"));
+      setProgress(90, text("progressError"), "error");
+      appendLog(response.message || text("functionLabFail"), "error");
+      if (response.projectRoot) {
+        appendLog(`${text("functionLabProject")}: ${response.projectRoot}`, "system");
+      }
+      if (response.buildDir) {
+        appendLog(`Build directory kept: ${response.buildDir}`, "system");
+      }
+      return;
+    }
+
+    const result = response.result;
+    state.lastApkPath = result.apkPath;
+    state.lastDistPath = result.distPath || "";
+    elements.apkPath.textContent = result.apkPath;
+    elements.successTitle.textContent = text("functionLabSuccessTitle");
+    elements.successText.textContent = text("functionLabSuccessText");
+    elements.successApkPath.textContent = result.apkPath;
+    elements.resultPanel.classList.remove("hidden");
+    setStep("doctor", "done", text("functionLabUsbCheck"));
+    setStep("build", "done", text("functionLabOk"));
+    setStatus("ready", text("functionLabOk"));
+    setProgress(100, text("progressDone"));
+    appendLog(`${text("functionLabOk")}: ${result.device && result.device.id ? result.device.id : "Android USB"}`, "success");
+    appendLog(`${text("buildOk")}: ${result.apkPath}`, "success");
+    setView("success");
+  } catch (error) {
+    stopAnimatedLogs();
+    setStep("build", "error", text("functionLabFail"));
+    setStatus("error", error.message);
+    setProgress(90, text("progressError"), "error");
+    appendLog(error.message, "error");
+  } finally {
+    state.buildRunning = false;
+    updateActionButtons();
+  }
+}
+
 function toggleTheme() {
   state.theme = state.theme === "dark" ? "light" : "dark";
   applyTheme();
@@ -2804,6 +3906,7 @@ function bindEvents() {
   elements.doctorButton.addEventListener("click", runDoctorOnly);
   elements.buildButton.addEventListener("click", runBuildFlow);
   elements.usbDebugButton.addEventListener("click", runUsbDebugFlow);
+  elements.nativeFunctionLabButton.addEventListener("click", runNativeFunctionLabFlow);
   elements.newFileButton.addEventListener("click", createNewProjectFile);
   elements.saveFileButton.addEventListener("click", saveCurrentFile);
   elements.fileTree.addEventListener("click", (event) => {
@@ -2816,6 +3919,7 @@ function bindEvents() {
     setCurrentFileDirty(true);
     updateFilePreview();
   });
+  elements.fileEditorInput.addEventListener("scroll", syncFileEditorHighlightScroll);
   elements.clearLogsButton.addEventListener("click", clearLogs);
   elements.toggleLogsButton.addEventListener("click", toggleLogBar);
   elements.bottomToggleLogsButton.addEventListener("click", toggleLogBar);
@@ -2866,6 +3970,7 @@ function bindEvents() {
   });
   elements.permissionGrid.addEventListener("change", validateSettings);
   elements.nativeCodeGrid.addEventListener("click", handleNativeCodeCopy);
+  elements.nativeCodeCategories.addEventListener("click", handleNativeCodeCopy);
   [
     elements.appNameInput,
     elements.packageIdInput,
@@ -2980,7 +4085,7 @@ async function init() {
       elements.iconPreview.src = iconPreviewPath(state.defaultIconPath);
     }
   } catch {
-    elements.appVersion.textContent = "v0.7.0";
+    elements.appVersion.textContent = "v0.11.0";
   }
 
   setTimeout(finishBoot, 1800);