html2apk 0.3.0 → 0.5.0

package/src/desktop/renderer/renderer.js

@@ -50,7 +50,7 @@ const i18n = {
     oneSignalAppId: "OneSignal App ID",
     oneSignalAppIdHint: "Opcional. Use o App ID do OneSignal, nao a REST API Key.",
     androidPermissions: "Permissoes Android",
-    chooseIcon: "Escolher icone PNG",
+    chooseIcon: "Trocar icone PNG",
     reviewBuild: "Revisar build",
     debugBuild: "Debug tecnico",
     debugBuildText: "Mantem a pasta Cordova temporaria para inspecao.",
@@ -65,6 +65,7 @@ const i18n = {
     buildEyebrow: "Revisao",
     buildTitle: "Confirme as informacoes e gere o APK",
     startBuild: "Gerar APK",
+    startUsbDebug: "Testar no USB",
     stepFolder: "Pasta recebida",
     stepSettings: "Configuracoes completas",
     stepDoctor: "Ambiente verificado",
@@ -76,9 +77,16 @@ const i18n = {
     logsTitle: "Logs do processo",
     codesEyebrow: "Bridge nativa",
     codesTitle: "Codigos interpretados",
-    codesIntro: "Estas funcoes chamadas no JavaScript do app sao interpretadas pelo plugin Cordova e executadas no Java Android.",
+    codesIntro: "Use estes blocos no JavaScript do seu projeto. O html2apk espera o Android ficar pronto, pede permissoes quando precisar e abre a configuracao certa quando o Android bloquear o pop-up.",
+    javaLabel: "Motor nativo",
+    doesLabel: "O que faz",
+    whenUseLabel: "Quando usar",
     returnsLabel: "Retorno",
     handlingLabel: "Como tratar",
+    exampleLabel: "Exemplo copiavel",
+    copyCode: "Copiar",
+    copiedCode: "Copiado",
+    copyFailed: "Nao foi possivel copiar",
     clearLogs: "Limpar logs",
     helpEyebrow: "Sem misterio",
     helpTitle: "Doctor, build e dependencias",
@@ -102,9 +110,15 @@ const i18n = {
     buildRunning: "Gerando APK",
     buildOk: "APK gerado com sucesso",
     buildFail: "Build falhou",
+    usbDebugRunning: "Gerando e instalando no celular USB",
+    usbDebugOk: "APK instalado no celular USB",
+    usbDebugFail: "Teste USB falhou",
     droppedFolder: "Pasta recebida",
     noFolderDrop: "Solte uma pasta do projeto",
     projectLoaded: "Projeto carregado",
+    projectAutoUpdated: "Projeto atualizado automaticamente",
+    projectConfigReloaded: "Configuracoes recarregadas do projeto",
+    projectWatcherFail: "Nao foi possivel acompanhar alteracoes da pasta",
     logsCleared: "Logs limpos",
     settingsOk: "Configuracoes completas",
     settingsMissing: "Complete as configuracoes obrigatorias",
@@ -114,7 +128,7 @@ const i18n = {
     invalidPackageId: "Informe um Package ID valido, exemplo: com.seuapp.meuapp.",
     invalidVersion: "Informe a versao no formato 1.0.0.",
     missingMode: "Escolha o modo do app.",
-    missingIcon: "Escolha o icone do app.",
+    defaultIcon: "Icone padrao do html2apk",
     invalidIconType: "Use um icone PNG para evitar falhas no Android.",
     invalidThemeColor: "Use uma cor hexadecimal valida, exemplo: #126fff.",
     invalidOneSignalAppId: "Use um OneSignal App ID valido ou deixe vazio.",
@@ -141,6 +155,8 @@ const i18n = {
     successEyebrow: "Concluido",
     successTitle: "APK gerado com sucesso",
     successText: "Seu arquivo Android esta pronto na pasta dist.",
+    usbSuccessTitle: "APK instalado no celular",
+    usbSuccessText: "O build debug foi enviado por USB. O app deve abrir no aparelho conectado.",
     newBuild: "Novo build"
   },
   en: {
@@ -190,7 +206,7 @@ const i18n = {
     oneSignalAppId: "OneSignal App ID",
     oneSignalAppIdHint: "Optional. Use the OneSignal App ID, not the REST API Key.",
     androidPermissions: "Android permissions",
-    chooseIcon: "Choose PNG icon",
+    chooseIcon: "Change PNG icon",
     reviewBuild: "Review build",
     debugBuild: "Technical debug",
     debugBuildText: "Keeps the temporary Cordova folder for inspection.",
@@ -205,6 +221,7 @@ const i18n = {
     buildEyebrow: "Review",
     buildTitle: "Confirm the information and build the APK",
     startBuild: "Build APK",
+    startUsbDebug: "Test on USB",
     stepFolder: "Folder received",
     stepSettings: "Settings complete",
     stepDoctor: "Environment checked",
@@ -216,9 +233,16 @@ const i18n = {
     logsTitle: "Process logs",
     codesEyebrow: "Native bridge",
     codesTitle: "Interpreted code",
-    codesIntro: "These functions called in your app JavaScript are interpreted by the Cordova plugin and executed in Android Java.",
+    codesIntro: "Use these blocks in your project JavaScript. html2apk waits for Android to be ready, asks permissions when needed and opens the right settings screen when Android blocks the prompt.",
+    javaLabel: "Native engine",
+    doesLabel: "What it does",
+    whenUseLabel: "When to use",
     returnsLabel: "Returns",
     handlingLabel: "How to handle",
+    exampleLabel: "Copyable example",
+    copyCode: "Copy",
+    copiedCode: "Copied",
+    copyFailed: "Could not copy",
     clearLogs: "Clear logs",
     helpEyebrow: "Plain and simple",
     helpTitle: "Doctor, build and dependencies",
@@ -242,9 +266,15 @@ const i18n = {
     buildRunning: "Building APK",
     buildOk: "APK generated successfully",
     buildFail: "Build failed",
+    usbDebugRunning: "Building and installing on USB phone",
+    usbDebugOk: "APK installed on USB phone",
+    usbDebugFail: "USB test failed",
     droppedFolder: "Folder received",
     noFolderDrop: "Drop a project folder",
     projectLoaded: "Project loaded",
+    projectAutoUpdated: "Project updated automatically",
+    projectConfigReloaded: "Settings reloaded from project",
+    projectWatcherFail: "Could not watch folder changes",
     logsCleared: "Logs cleared",
     settingsOk: "Settings complete",
     settingsMissing: "Complete the required settings",
@@ -254,7 +284,7 @@ const i18n = {
     invalidPackageId: "Enter a valid Package ID, example: com.yourapp.name.",
     invalidVersion: "Enter the version as 1.0.0.",
     missingMode: "Choose the app mode.",
-    missingIcon: "Choose the app icon.",
+    defaultIcon: "Default html2apk icon",
     invalidIconType: "Use a PNG icon to avoid Android build failures.",
     invalidThemeColor: "Use a valid hex color, example: #126fff.",
     invalidOneSignalAppId: "Use a valid OneSignal App ID or leave it empty.",
@@ -281,6 +311,8 @@ const i18n = {
     successEyebrow: "Complete",
     successTitle: "APK generated successfully",
     successText: "Your Android file is ready in the dist folder.",
+    usbSuccessTitle: "APK installed on phone",
+    usbSuccessText: "The debug build was sent over USB. The app should open on the connected device.",
     newBuild: "New build"
   }
 };
@@ -359,11 +391,11 @@ const nativeCodeEntries = [
     handling: { pt: "Limite duracoes longas e deixe a permissao `VIBRATE` no app; se falhar, siga sem bloquear o fluxo principal.", en: "Keep long durations under control and include the `VIBRATE` permission; if it fails, continue without blocking the main flow." }
   },
   {
-    syntax: { pt: "notificar({ titulo, texto, acoes })", en: "notify({ title, text, actions })" },
+    syntax: { pt: "notificar({ titulo, texto, aoClicar?, acoes?, open? })", en: "notify({ title, text, onClick?, actions?, open? })" },
     java: "notify",
-    description: { pt: "Cria notificacao Android imediata. `acoes` ou `actions` viram botoes clicaveis.", en: "Creates an immediate Android notification. `actions` or `acoes` become clickable buttons." },
-    returns: { pt: "Promise<void>; cliques chegam em `aoEvento('notificacao:clicada')` ou `aoClicarNotificacao()`.", en: "Promise<void>; clicks arrive through `onEvent('notification:clicked')` or `onNotificationClick()`." },
-    handling: { pt: "Antes de usar, chame `solicitarPermissaoNotificacoes()` no Android 13+. Trate o clique pela acao enviada em `aoClicar`/`onClick`.", en: "Before using it, call `requestNotificationPermission()` on Android 13+. Handle clicks using the action sent in `onClick`/`aoClicar`." }
+    description: { pt: "Cria notificacao Android imediata. So `titulo` e `texto` ja bastam; `aoClicar`, `acoes` e `open` sao opcionais.", en: "Creates an immediate Android notification. `title` and `text` are enough; `onClick`, `actions` and `open` are optional." },
+    returns: { pt: "Promise<void>; cliques chegam em `aoEvento('notificacao:clicada')` ou `aoClicarNotificacao()` e tambem podem executar `aoClicar` automaticamente.", en: "Promise<void>; clicks arrive through `onEvent('notification:clicked')` or `onNotificationClick()` and can also run `onClick` automatically." },
+    handling: { pt: "Use `aoClicar: () => funcao()` enquanto o app esta vivo. Para agendada ou app fechado, prefira `aoClicar: { funcao, argumentos }`. `open:false` evita abrir a tela; JavaScript so roda assim se o app ainda estiver vivo, mas acoes externas como `abrirForaDoApp` funcionam por fallback nativo.", en: "Use `onClick: () => functionName()` while the app process is alive. For scheduled notifications or a closed app, prefer `onClick: { functionName, args }`. `open:false` avoids opening the screen; JavaScript only runs this way if the app is still alive, but external actions like `openOutsideApp` work through a native fallback." }
   },
   {
     syntax: { pt: "agendarNotificacao({ titulo, texto, quando }) / agendarNotificacoes([...])", en: "scheduleNotification({ title, text, when }) / scheduleNotifications([...])" },
@@ -377,13 +409,13 @@ const nativeCodeEntries = [
     java: "AlarmManager + NotificationStore",
     description: { pt: "Cria um loop de notificacoes que continua funcionando com o app fechado e alterna os itens da lista.", en: "Creates a notification loop that keeps working with the app closed and rotates through the list items." },
     returns: { pt: "{ id, when, repeating, loop }. Guarde o `id` para cancelar depois.", en: "{ id, when, repeating, loop }. Store the `id` to cancel later." },
-    handling: { pt: "Use `aoClicarNotificacao()` ou `aoEvento('notificacao:clicada')` para chamar funcoes conforme `aoClicar`. Cancele com `cancelarNotificacao(id)`.", en: "Use `onNotificationClick()` or `onEvent('notification:clicked')` to call functions from `onClick`. Cancel with `cancelNotification(id)`." }
+    handling: { pt: "Cancele com `cancelarNotificacao(id)`. Se o clique precisar chamar funcao automaticamente mesmo apos o Android reabrir o app, use `funcao` + `argumentos` no `aoClicar`.", en: "Cancel with `cancelNotification(id)`. If the click must call a function automatically after Android reopens the app, use `functionName` + `args` in `onClick`." }
   },
   {
     syntax: { pt: "solicitarPermissaoNotificacoes()", en: "requestNotificationPermission()" },
     java: "requestNotificationPermission",
     description: { pt: "Pede permissao para mostrar notificacoes quando o Android exigir.", en: "Requests permission to show notifications when Android requires it." },
-    returns: { pt: "{ permission, required, granted }.", en: "{ permission, required, granted }." },
+    returns: { pt: "{ permission, required, granted, requiresSettings, settingsOpened }.", en: "{ permission, required, granted, requiresSettings, settingsOpened }." },
     handling: { pt: "Se `granted` for falso, desative botoes de notificacao ou explique ao usuario como habilitar depois.", en: "If `granted` is false, disable notification buttons or explain how the user can enable it later." }
   },
   {
@@ -398,7 +430,7 @@ const nativeCodeEntries = [
     java: "permissionStatus",
     description: { pt: "Consulta se permissoes Android estao liberadas.", en: "Checks whether Android permissions are granted." },
     returns: { pt: "Objeto com permissao Android como chave e boolean como valor.", en: "Object with Android permission names as keys and booleans as values." },
-    handling: { pt: "Use antes de liberar recursos sensiveis; quando vier falso, mostre uma etapa de permissao em vez de falhar silenciosamente.", en: "Use it before enabling sensitive features; when false, show a permission step instead of failing silently." }
+    handling: { pt: "Use apenas para consultar. Para pedir permissao, chame a funcao real (`lanterna`, `ouvirMic`, `notificar`) ou a API manual correspondente.", en: "Use only to check. To request permission, call the real function (`flashlight`, `listenMic`, `notify`) or the matching manual API." }
   },
   {
     syntax: { pt: "aoEvento('app:background', fn)", en: "onEvent('app:background', fn)" },
@@ -424,23 +456,23 @@ const nativeCodeEntries = [
   {
     syntax: { pt: "solicitarPermissaoCamera()", en: "requestCameraPermission()" },
     java: "requestCameraPermission",
-    description: { pt: "Pede permissao de camera antes de usar lanterna.", en: "Requests camera permission before using flashlight." },
-    returns: { pt: "{ permission, required, granted }.", en: "{ permission, required, granted }." },
-    handling: { pt: "Chame antes de `lanterna()`. Se `granted` for falso, mostre uma mensagem e mantenha a lanterna desativada.", en: "Call before `flashlight()`. If `granted` is false, show a message and keep the flashlight disabled." }
+    description: { pt: "Pede permissao de camera manualmente, se voce quiser preparar a experiencia antes da lanterna.", en: "Requests camera permission manually, if you want to prepare the experience before flashlight." },
+    returns: { pt: "{ permission, required, granted, requiresSettings, settingsOpened }.", en: "{ permission, required, granted, requiresSettings, settingsOpened }." },
+    handling: { pt: "`lanterna()` ja pede permissao sozinha. Use esta funcao apenas se quiser explicar antes e controlar a UI pelo `granted`.", en: "`flashlight()` already requests permission by itself. Use this only if you want to explain first and control the UI from `granted`." }
   },
   {
     syntax: { pt: "await ouvirMic(); const audio = await pararMic()", en: "await listenMic(); const audio = await stopMic()" },
     java: "MediaRecorder",
     description: { pt: "Comeca a gravar pelo microfone e finaliza retornando o audio em base64.", en: "Starts recording from the microphone and finishes by returning the audio as base64." },
-    returns: { pt: "`ouvirMic`: { recording, startedAt, granted }. `pararMic`: { base64, mimeType, extension, durationMs, size }.", en: "`listenMic`: { recording, startedAt, granted }. `stopMic`: { base64, mimeType, extension, durationMs, size }." },
-    handling: { pt: "Chame `solicitarPermissaoMicrofone()` ou deixe `ouvirMic()` pedir a permissao. Para tocar/enviar, monte `data:${audio.mimeType};base64,${audio.base64}`; se parar rapido demais, tente aguardar alguns instantes antes de `pararMic()`.", en: "Call `requestMicrophonePermission()` or let `listenMic()` request permission. To play/upload, build `data:${audio.mimeType};base64,${audio.base64}`; if you stop too quickly, wait a little before `stopMic()`." }
+    returns: { pt: "`ouvirMic`: { recording, startedAt, granted, settingsOpened }. `pararMic`: { base64, mimeType, extension, durationMs, size }.", en: "`listenMic`: { recording, startedAt, granted, settingsOpened }. `stopMic`: { base64, mimeType, extension, durationMs, size }." },
+    handling: { pt: "`ouvirMic()` pede microfone sozinho. Se `settingsOpened` vier true, o Android abriu as configuracoes; quando o usuario voltar, chame `ouvirMic()` de novo.", en: "`listenMic()` requests the microphone by itself. If `settingsOpened` is true, Android opened settings; when the user returns, call `listenMic()` again." }
   },
   {
     syntax: { pt: "lanterna(true) / statusLanterna()", en: "flashlight(true) / flashlightStatus()" },
     java: "flashlight",
     description: { pt: "Liga, desliga e consulta a lanterna do aparelho.", en: "Turns the device flashlight on/off and reads its status." },
     returns: { pt: "{ available, enabled, permissionGranted }.", en: "{ available, enabled, permissionGranted }." },
-    handling: { pt: "Se `available` for falso, esconda o controle. Se `permissionGranted` for falso, volte para a etapa de permissao.", en: "If `available` is false, hide the control. If `permissionGranted` is false, return to the permission step." }
+    handling: { pt: "Ao chamar, o html2apk pede CAMERA automaticamente. Se `settingsOpened` vier true, o Android abriu as configuracoes porque o pop-up estava bloqueado.", en: "When called, html2apk automatically requests CAMERA. If `settingsOpened` is true, Android opened settings because the prompt was blocked." }
   },
   {
     syntax: { pt: "alternarLanterna()", en: "toggleFlashlight()" },
@@ -608,7 +640,709 @@ const nativeCodeEntries = [
     java: "FloatingIconService",
     description: { pt: "Controla o icone flutuante quando o app foi gerado em modo floating.", en: "Controls the floating icon when the app was generated in floating mode." },
     returns: { pt: "Promise<void>.", en: "Promise<void>." },
-    handling: { pt: "Antes de iniciar, confira `statusPermissaoSobreposicao()` e chame `solicitarPermissaoSobreposicao()` se faltar permissao.", en: "Before starting, check `overlayPermissionStatus()` and call `requestOverlayPermission()` when permission is missing." }
+    handling: { pt: "`iniciarIconeFlutuante()` abre a tela de permissao automaticamente se faltar sobreposicao. Quando o usuario voltar, chame novamente para iniciar.", en: "`startFloatingIcon()` opens the permission screen automatically if draw-over-apps is missing. When the user comes back, call it again to start." }
+  }
+];
+
+const nativeCodeRecipes = [
+  {
+    when: { pt: "Para avisos curtos dentro do app, como sucesso, erro simples ou confirmacao.", en: "For short in-app feedback such as success, simple errors or confirmations." },
+    example: {
+      pt: `try {
+  await toast("Salvo com sucesso");
+} catch (erro) {
+  console.error("Toast falhou", erro);
+}`,
+      en: `try {
+  await toast("Saved successfully");
+} catch (error) {
+  console.error("Toast failed", error);
+}`
+    }
+  },
+  {
+    when: { pt: "Para dar feedback fisico em botoes, alertas ou acoes importantes.", en: "For physical feedback on buttons, alerts or important actions." },
+    example: {
+      pt: `await vibrar(250);`,
+      en: `await vibrate(250);`
+    }
+  },
+  {
+    when: { pt: "Para mostrar uma notificacao simples agora. `aoClicar`, `acoes` e `open` sao opcionais.", en: "To show a simple notification now. `onClick`, `actions` and `open` are optional." },
+    example: {
+      pt: `await notificar({
+  titulo: "Pedido aprovado",
+  texto: "Toque para abrir o app"
+});`,
+      en: `await notify({
+  title: "Order approved",
+  text: "Tap to open the app"
+});`
+    }
+  },
+  {
+    when: { pt: "Para executar algo quando a notificacao for clicada.", en: "To run something when the notification is clicked." },
+    example: {
+      pt: `await notificar({
+  titulo: "Pedido aprovado",
+  texto: "Toque para abrir os detalhes",
+  aoClicar: () => abrirForaDoApp("https://exemplo.com/pedidos/123")
+});`,
+      en: `await notify({
+  title: "Order approved",
+  text: "Tap to open details",
+  onClick: () => openOutsideApp("https://example.com/orders/123")
+});`
+    }
+  },
+  {
+    when: { pt: "Para colocar botoes na notificacao, cada um chamando uma funcao.", en: "To add buttons to the notification, each one calling a function." },
+    example: {
+      pt: `window.marcarPedidoLido = (id) => {
+  localStorage.setItem("pedido:" + id, "lido");
+};
+
+await notificar({
+  titulo: "Pedido aprovado",
+  texto: "Escolha uma acao",
+  acoes: [
+    {
+      id: "abrir",
+      titulo: "Abrir",
+      open: true,
+      aoClicar: { funcao: "abrirNoApp", argumentos: ["#/pedido/123"] }
+    },
+    {
+      id: "lido",
+      titulo: "Marcar lido",
+      open: false,
+      aoClicar: { funcao: "marcarPedidoLido", argumentos: [123], open: false }
+    }
+  ]
+});`,
+      en: `window.markOrderRead = (id) => {
+  localStorage.setItem("order:" + id, "read");
+};
+
+await notify({
+  title: "Order approved",
+  text: "Choose an action",
+  actions: [
+    {
+      id: "open",
+      title: "Open",
+      open: true,
+      onClick: { functionName: "openInApp", args: ["#/order/123"] }
+    },
+    {
+      id: "read",
+      title: "Mark read",
+      open: false,
+      onClick: { functionName: "markOrderRead", args: [123], open: false }
+    }
+  ]
+});`
+    }
+  },
+  {
+    when: { pt: "Para clique de notificacao agendada ou com app fechado.", en: "For scheduled notification clicks or when the app is closed." },
+    example: {
+      pt: `await agendarNotificacao({
+  titulo: "Pedido aprovado",
+  texto: "Toque para abrir os detalhes",
+  quando: Date.now() + 60 * 1000,
+  aoClicar: {
+    funcao: "abrirForaDoApp",
+    argumentos: ["https://exemplo.com/pedidos/123"]
+  }
+});`,
+      en: `await scheduleNotification({
+  title: "Order approved",
+  text: "Tap to open details",
+  when: Date.now() + 60 * 1000,
+  onClick: {
+    functionName: "openOutsideApp",
+    args: ["https://example.com/orders/123"]
+  }
+});`
+    }
+  },
+  {
+    when: { pt: "Para lembrar o usuario depois, mesmo se o app nao estiver aberto.", en: "To remind the user later, even if the app is not open." },
+    example: {
+      pt: `const aviso = await agendarNotificacao({
+  titulo: "Lembrete",
+  texto: "Volte ao app daqui 1 minuto",
+  quando: Date.now() + 60 * 1000
+});
+
+console.log("ID para cancelar depois:", aviso.id);`,
+      en: `const reminder = await scheduleNotification({
+  title: "Reminder",
+  text: "Come back in 1 minute",
+  when: Date.now() + 60 * 1000
+});
+
+console.log("ID to cancel later:", reminder.id);`
+    }
+  },
+  {
+    when: { pt: "Para uma sequencia recorrente de notificacoes, como a cada 12 horas.", en: "For a repeating sequence of notifications, such as every 12 hours." },
+    example: {
+      pt: `const loop = await agendarLoopNotificacoes({
+  aCada: "12h",
+  notificacoes: [
+    { titulo: "Agua", texto: "Beba agua agora" },
+    { titulo: "Alongar", texto: "Faca uma pausa rapida" }
+  ]
+});
+
+// Depois, se quiser parar:
+// await cancelarNotificacao(loop.id);`,
+      en: `const loop = await scheduleNotificationLoop({
+  every: "12h",
+  notifications: [
+    { title: "Water", text: "Drink water now" },
+    { title: "Stretch", text: "Take a quick break" }
+  ]
+});
+
+// Later, to stop it:
+// await cancelNotification(loop.id);`
+    }
+  },
+  {
+    when: { pt: "Opcional: use se quiser pedir a permissao antes de chamar notificacoes.", en: "Optional: use it if you want to ask permission before calling notifications." },
+    example: {
+      pt: `const permissao = await solicitarPermissaoNotificacoes();
+
+if (!permissao.granted) {
+  if (permissao.settingsOpened) {
+    console.log("O Android abriu as configuracoes do app");
+  }
+}`,
+      en: `const permission = await requestNotificationPermission();
+
+if (!permission.granted) {
+  if (permission.settingsOpened) {
+    console.log("Android opened the app settings");
+  }
+}`
+    }
+  },
+  {
+    when: { pt: "Para push remoto enviado pelo painel/API do OneSignal. Requer OneSignal App ID no build.", en: "For remote push sent by the OneSignal dashboard/API. Requires OneSignal App ID in the build." },
+    example: {
+      pt: `const permitido = await solicitarPermissaoPush();
+
+if (permitido) {
+  await identificarUsuarioPush("usuario-123");
+  await adicionarTagPush("plano", "premium");
+}
+
+const parar = aoClicarPush((evento) => {
+  abrirNoApp("#/notificacoes");
+});`,
+      en: `const allowed = await requestPushPermission();
+
+if (allowed) {
+  await loginPushUser("user-123");
+  await addPushTag("plan", "premium");
+}
+
+const stop = onPushClick((event) => {
+  openInApp("#/notifications");
+});`
+    }
+  },
+  {
+    when: { pt: "Para consultar permissoes sem abrir uma solicitacao na tela.", en: "To check permissions without opening a permission prompt." },
+    example: {
+      pt: `const permissoes = await statusPermissoes([
+  "CAMERA",
+  "RECORD_AUDIO",
+  "POST_NOTIFICATIONS"
+]);
+
+console.log(permissoes);`,
+      en: `const permissions = await permissionStatus([
+  "CAMERA",
+  "RECORD_AUDIO",
+  "POST_NOTIFICATIONS"
+]);
+
+console.log(permissions);`
+    }
+  },
+  {
+    when: { pt: "Para reagir a eventos do Android, como app indo para segundo plano ou clique em notificacao.", en: "To react to Android events, such as backgrounding or notification clicks." },
+    example: {
+      pt: `const parar = aoEvento("app:background", (evento) => {
+  console.log("Saiu da frente", evento.timestamp);
+});
+
+// Quando nao precisar mais:
+// parar();`,
+      en: `const stop = onEvent("app:background", (event) => {
+  console.log("Moved to background", event.timestamp);
+});
+
+// When you no longer need it:
+// stop();`
+    }
+  },
+  {
+    when: { pt: "Para pausar/resumir tarefas quando o usuario minimiza ou volta para o app.", en: "To pause/resume work when the user minimizes or returns to the app." },
+    example: {
+      pt: `const pararMinimizar = aoMinimizar(() => {
+  console.log("Pause videos, timers ou leituras pesadas");
+});
+
+const pararVoltar = aoVoltarParaApp(() => {
+  console.log("Atualize dados se precisar");
+});`,
+      en: `const stopMinimize = onMinimize(() => {
+  console.log("Pause videos, timers or heavy reads");
+});
+
+const stopResume = onAppResume(() => {
+  console.log("Refresh data if needed");
+});`
+    }
+  },
+  {
+    when: { pt: "Para abrir uma tela especifica quando o APK foi chamado por link.", en: "To open a specific screen when the APK was launched from a link." },
+    example: {
+      pt: `const linkInicial = await obterLinkInicial();
+if (linkInicial) {
+  abrirNoApp("#" + linkInicial.path);
+}
+
+aoAbrirLink((link) => {
+  console.log("Link recebido", link.url);
+});`,
+      en: `const initialLink = await getInitialLink();
+if (initialLink) {
+  openInApp("#" + initialLink.path);
+}
+
+onOpenLink((link) => {
+  console.log("Link received", link.url);
+});`
+    }
+  },
+  {
+    when: { pt: "Opcional: use antes da lanterna se quiser explicar a permissao ao usuario.", en: "Optional: use it before flashlight if you want to explain the permission." },
+    example: {
+      pt: `const camera = await solicitarPermissaoCamera();
+
+if (camera.granted) {
+  await lanterna(true);
+} else if (camera.settingsOpened) {
+  console.log("Libere Camera nas configuracoes e volte ao app");
+}`,
+      en: `const camera = await requestCameraPermission();
+
+if (camera.granted) {
+  await flashlight(true);
+} else if (camera.settingsOpened) {
+  console.log("Allow Camera in settings and return to the app");
+}`
+    }
+  },
+  {
+    when: { pt: "Para gravar audio curto pelo microfone e receber o arquivo em base64.", en: "To record short audio from the microphone and receive the file as base64." },
+    example: {
+      pt: `const inicio = await ouvirMic();
+if (inicio.settingsOpened) {
+  console.log("Libere Microfone nas configuracoes e tente de novo");
+  return;
+}
+
+setTimeout(async () => {
+  const audio = await pararMic();
+  const url = "data:" + audio.mimeType + ";base64," + audio.base64;
+  new Audio(url).play();
+}, 3000);`,
+      en: `const start = await listenMic();
+if (start.settingsOpened) {
+  console.log("Allow Microphone in settings and try again");
+  return;
+}
+
+setTimeout(async () => {
+  const audio = await stopMic();
+  const url = "data:" + audio.mimeType + ";base64," + audio.base64;
+  new Audio(url).play();
+}, 3000);`
+    }
+  },
+  {
+    when: { pt: "Para ligar ou desligar a lanterna. A permissao de camera e pedida automaticamente.", en: "To turn the flashlight on or off. Camera permission is requested automatically." },
+    example: {
+      pt: `const status = await lanterna(true);
+
+if (status.settingsOpened) {
+  console.log("Libere Camera nas configuracoes e chame lanterna(true) de novo");
+} else if (!status.available) {
+  await toast("Este aparelho nao tem lanterna");
+}`,
+      en: `const status = await flashlight(true);
+
+if (status.settingsOpened) {
+  console.log("Allow Camera in settings and call flashlight(true) again");
+} else if (!status.available) {
+  await toast("This device has no flashlight");
+}`
+    }
+  },
+  {
+    when: { pt: "Para um botao que liga/desliga a lanterna sem guardar estado manualmente.", en: "For a button that toggles flashlight without tracking state manually." },
+    example: {
+      pt: `const status = await alternarLanterna();
+console.log("Lanterna ligada?", status.enabled);`,
+      en: `const status = await toggleFlashlight();
+console.log("Flashlight on?", status.enabled);`
+    }
+  },
+  {
+    when: { pt: "Para deixar o usuario escolher uma foto da galeria ou arquivos de imagem.", en: "To let the user choose a photo from gallery or image files." },
+    example: {
+      pt: `const imagem = await escolherImagem();
+
+if (imagem) {
+  document.querySelector("img.preview").src = imagem.uri;
+}`,
+      en: `const image = await pickImage();
+
+if (image) {
+  document.querySelector("img.preview").src = image.uri;
+}`
+    }
+  },
+  {
+    when: { pt: "Para galeria com selecao multipla, como anexar varias fotos.", en: "For multiple gallery selection, such as attaching many photos." },
+    example: {
+      pt: `const imagens = await escolherImagens({ multiplo: true });
+
+for (const imagem of imagens) {
+  console.log(imagem.nome, imagem.tamanho);
+}`,
+      en: `const images = await pickImages({ multiple: true });
+
+for (const image of images) {
+  console.log(image.name, image.size);
+}`
+    }
+  },
+  {
+    when: { pt: "Para escolher PDF, ZIP, TXT ou qualquer tipo de documento.", en: "To choose PDF, ZIP, TXT or any document type." },
+    example: {
+      pt: `const pdf = await escolherArquivo({
+  tipos: ["application/pdf"]
+});
+
+if (pdf) {
+  console.log("PDF escolhido:", pdf.nome);
+}`,
+      en: `const pdf = await pickFile({
+  types: ["application/pdf"]
+});
+
+if (pdf) {
+  console.log("Chosen PDF:", pdf.name);
+}`
+    }
+  },
+  {
+    when: { pt: "Para anexar varios arquivos de uma vez.", en: "To attach multiple files at once." },
+    example: {
+      pt: `const arquivos = await escolherArquivos({ multiplo: true });
+
+const total = arquivos.reduce((soma, arquivo) => {
+  return soma + (arquivo.tamanho || 0);
+}, 0);
+
+console.log("Total em bytes:", total);`,
+      en: `const files = await pickFiles({ multiple: true });
+
+const total = files.reduce((sum, file) => {
+  return sum + (file.size || 0);
+}, 0);
+
+console.log("Total bytes:", total);`
+    }
+  },
+  {
+    when: { pt: "Para pedir um video do usuario sem mostrar documentos que nao sejam video.", en: "To ask the user for a video without showing non-video documents." },
+    example: {
+      pt: `const video = await escolherVideo();
+
+if (video && video.tamanho > 50 * 1024 * 1024) {
+  await toast("Video muito grande");
+}`,
+      en: `const video = await pickVideo();
+
+if (video && video.size > 50 * 1024 * 1024) {
+  await toast("Video is too large");
+}`
+    }
+  },
+  {
+    when: { pt: "Para o usuario escolher uma pasta quando o Android permitir acesso por URI.", en: "To let the user choose a folder when Android allows URI access." },
+    example: {
+      pt: `const pasta = await escolherPasta();
+
+if (pasta.uri) {
+  console.log("Pasta escolhida:", pasta.uri);
+}`,
+      en: `const folder = await pickFolder();
+
+if (folder.uri) {
+  console.log("Chosen folder:", folder.uri);
+}`
+    }
+  },
+  {
+    when: { pt: "Para salvar texto ou base64 em um arquivo escolhido pelo usuario.", en: "To save text or base64 to a file chosen by the user." },
+    example: {
+      pt: `const salvo = await salvarArquivo({
+  nome: "relatorio.txt",
+  mimeType: "text/plain",
+  conteudo: "Conteudo do relatorio"
+});
+
+if (salvo.saved) {
+  await toast("Arquivo salvo");
+}`,
+      en: `const saved = await saveFile({
+  name: "report.txt",
+  mimeType: "text/plain",
+  content: "Report content"
+});
+
+if (saved.saved) {
+  await toast("File saved");
+}`
+    }
+  },
+  {
+    when: { pt: "Para abrir o compartilhamento nativo do Android com texto e/ou link.", en: "To open Android native sharing with text and/or link." },
+    example: {
+      pt: `await compartilhar({
+  texto: "Veja esse app",
+  url: "https://exemplo.com"
+});`,
+      en: `await share({
+  text: "Check this app",
+  url: "https://example.com"
+});`
+    }
+  },
+  {
+    when: { pt: "Para copiar dados para a area de transferencia ou ler o que esta copiado.", en: "To copy data to the clipboard or read what is copied." },
+    example: {
+      pt: `await copiarTexto("ABC-123");
+await toast("Codigo copiado");
+
+const copiado = await lerTextoCopiado();
+console.log(copiado);`,
+      en: `await copyText("ABC-123");
+await toast("Code copied");
+
+const copied = await readText();
+console.log(copied);`
+    }
+  },
+  {
+    when: { pt: "Para impedir que a tela apague em leitura, video, mapa ou monitoramento.", en: "To keep screen awake during reading, video, maps or monitoring." },
+    example: {
+      pt: `await manterTelaLigada(true);
+
+// Ao sair da tela:
+await manterTelaLigada(false);`,
+      en: `await keepScreenOn(true);
+
+// When leaving the screen:
+await keepScreenOn(false);`
+    }
+  },
+  {
+    when: { pt: "Para controlar o brilho so dentro do APK, sem mudar o brilho do sistema todo.", en: "To control brightness only inside the APK, without changing the whole system brightness." },
+    example: {
+      pt: `await brilhoTela(0.8);
+
+// Restaurar comportamento padrao:
+await brilhoTela(-1);`,
+      en: `await setScreenBrightness(0.8);
+
+// Restore default behavior:
+await setScreenBrightness(-1);`
+    }
+  },
+  {
+    when: { pt: "Para combinar status bar/navigation bar com uma tela especifica do app.", en: "To match status/navigation bars with a specific app screen." },
+    example: {
+      pt: `await definirCorTema({
+  statusBarColor: "#126fff",
+  navigationBarColor: "#101827"
+});`,
+      en: `await setThemeColor({
+  statusBarColor: "#126fff",
+  navigationBarColor: "#101827"
+});`
+    }
+  },
+  {
+    when: { pt: "Para navegar dentro do proprio WebView do APK.", en: "To navigate inside the APK WebView itself." },
+    example: {
+      pt: `await abrirNoApp("#/perfil");
+
+// Sem deixar voltar para a tela anterior:
+await abrirNoApp("#/login", { substituir: true });`,
+      en: `await openInApp("#/profile");
+
+// Without keeping the previous screen:
+await openInApp("#/login", { replace: true });`
+    }
+  },
+  {
+    when: { pt: "Para abrir navegador, outro app ou link externo fora do APK.", en: "To open browser, another app or external link outside the APK." },
+    example: {
+      pt: `await abrirForaDoApp("https://exemplo.com");`,
+      en: `await openOutsideApp("https://example.com");`
+    }
+  },
+  {
+    when: { pt: "Para abrir uma conversa do WhatsApp com numero e mensagem opcional.", en: "To open a WhatsApp conversation with phone number and optional message." },
+    example: {
+      pt: `await abrirWhatsapp(
+  "559999999999",
+  "Oi, vim pelo app"
+);`,
+      en: `await openWhatsapp(
+  "559999999999",
+  "Hi, I came from the app"
+);`
+    }
+  },
+  {
+    when: { pt: "Para abrir o discador ou o app de mapas sem fazer a acao sozinho.", en: "To open dialer or maps without performing the action automatically." },
+    example: {
+      pt: `await discar("11999999999");
+await abrirMapa("Avenida Paulista, Sao Paulo");`,
+      en: `await dial("11999999999");
+await openMap("Avenida Paulista, Sao Paulo");`
+    }
+  },
+  {
+    when: { pt: "Para diagnostico, suporte ou pequenas adaptacoes por versao do Android.", en: "For diagnostics, support or small adaptations by Android version." },
+    example: {
+      pt: `const aparelho = await infoDispositivo();
+
+console.log(aparelho.modelo, aparelho.androidVersion);`,
+      en: `const device = await deviceInfo();
+
+console.log(device.model, device.androidVersion);`
+    }
+  },
+  {
+    when: { pt: "Para adaptar a UI quando ficar offline ou quando a bateria estiver baixa.", en: "To adapt the UI when offline or when battery is low." },
+    example: {
+      pt: `const rede = await infoRede();
+const bateria = await infoBateria();
+
+if (!rede.online) {
+  await toast("Sem internet");
+}`,
+      en: `const network = await networkInfo();
+const battery = await batteryInfo();
+
+if (!network.online) {
+  await toast("No internet");
+}`
+    }
+  },
+  {
+    when: { pt: "Para saber se o app deve reduzir imagens, cache ou tarefas pesadas.", en: "To know whether the app should reduce images, cache or heavy tasks." },
+    example: {
+      pt: `const memoria = await infoMemoria();
+const mbLivre = memoria.availableBytes / 1024 / 1024;
+
+if (memoria.lowMemory) {
+  console.log("Reduza cache. MB livre:", mbLivre);
+}`,
+      en: `const memory = await memoryInfo();
+const freeMb = memory.availableBytes / 1024 / 1024;
+
+if (memory.lowMemory) {
+  console.log("Reduce cache. Free MB:", freeMb);
+}`
+    }
+  },
+  {
+    when: { pt: "Para conferir espaco antes de baixar ou salvar arquivos grandes.", en: "To check space before downloading or saving large files." },
+    example: {
+      pt: `const armazenamento = await infoArmazenamento();
+const livre = armazenamento.internal.availableBytes;
+
+console.log("Livre em MB:", Math.round(livre / 1024 / 1024));`,
+      en: `const storage = await storageInfo();
+const free = storage.internal.availableBytes;
+
+console.log("Free MB:", Math.round(free / 1024 / 1024));`
+    }
+  },
+  {
+    when: { pt: "Para uma tela de diagnostico com memoria, armazenamento, bateria e rede juntos.", en: "For a diagnostics screen with memory, storage, battery and network together." },
+    example: {
+      pt: `const desempenho = await infoDesempenho();
+
+console.log(desempenho.memory);
+console.log(desempenho.storage);
+console.log(desempenho.battery);`,
+      en: `const performance = await performanceInfo();
+
+console.log(performance.memory);
+console.log(performance.storage);
+console.log(performance.battery);`
+    }
+  },
+  {
+    when: { pt: "Para diagnostico aproximado de processos que o Android deixa o APK enxergar.", en: "For approximate diagnostics of processes Android lets the APK see." },
+    example: {
+      pt: `const resultado = await appsAbertos();
+
+for (const app of resultado.apps) {
+  console.log(app.nome, app.ramMb + " MB");
+}`,
+      en: `const result = await openAppsMemory();
+
+for (const app of result.apps) {
+  console.log(app.name, app.ramMb + " MB");
+}`
+    }
+  },
+  {
+    when: { pt: "Para apps em modo floating que precisam mostrar/esconder o icone flutuante.", en: "For floating-mode apps that need to show/hide the floating icon." },
+    example: {
+      pt: `const status = await iniciarIconeFlutuante();
+
+if (status.requiresSettings) {
+  console.log("O Android abriu a tela de sobreposicao");
+}
+
+// Para desligar:
+// await pararIconeFlutuante();`,
+      en: `const status = await startFloatingIcon();
+
+if (status.requiresSettings) {
+  console.log("Android opened the draw-over-apps screen");
+}
+
+// To turn it off:
+// await stopFloatingIcon();`
+    }
   }
 ];
 
@@ -624,6 +1358,7 @@ const state = {
   buildRunning: false,
   lastApkPath: null,
   lastDistPath: null,
+  defaultIconPath: "",
   animationTimer: null,
   progress: 0,
   logsVisible: localStorage.getItem("html2apk.logsVisible") === "true"
@@ -659,6 +1394,7 @@ function collectElements() {
     "entryPath",
     "doctorButton",
     "buildButton",
+    "usbDebugButton",
     "appNameInput",
     "packageIdInput",
     "versionInput",
@@ -691,6 +1427,8 @@ function collectElements() {
     "apkPath",
     "openDistButton",
     "showApkButton",
+    "successTitle",
+    "successText",
     "successApkPath",
     "successOpenDistButton",
     "successShowApkButton",
@@ -874,6 +1612,7 @@ function updateActionButtons() {
 
 function setBuildButtons(enabled) {
   elements.buildButton.disabled = !enabled;
+  elements.usbDebugButton.disabled = !enabled;
 }
 
 function packageSegment(value) {
@@ -900,12 +1639,16 @@ function toFileUrl(filePath) {
   return `file:///${String(filePath).replace(/\\/g, "/").replace(/^\/+/, "")}`;
 }
 
+function defaultIconPath() {
+  return state.defaultIconPath || "";
+}
+
 function isAbsolutePath(filePath) {
   return /^[a-zA-Z]:[\\/]/.test(String(filePath || "")) || String(filePath || "").startsWith("/");
 }
 
 function iconPreviewPath(iconPath) {
-  if (!iconPath || !state.project) {
+  if (!iconPath) {
     return "../../../html2apk.png";
   }
   if (isAbsolutePath(iconPath)) {
@@ -914,6 +1657,18 @@ function iconPreviewPath(iconPath) {
   return toFileUrl(`${state.project.projectRoot}\\${iconPath}`);
 }
 
+function displayIconValue(iconPath) {
+  const value = String(iconPath || "").trim();
+  if (!value || (state.defaultIconPath && value === state.defaultIconPath)) {
+    return text("defaultIcon");
+  }
+  return value;
+}
+
+function isConfigFilePath(filePath) {
+  return /(^|[\\/])(app|config)\.json$/i.test(String(filePath || ""));
+}
+
 function escapeHtml(value) {
   return String(value || "")
     .replace(/&/g, "&amp;")
@@ -922,6 +1677,61 @@ function escapeHtml(value) {
     .replace(/"/g, "&quot;");
 }
 
+function recipeForCode(index) {
+  const language = currentLanguage();
+  const recipe = nativeCodeRecipes[index] || {};
+  return {
+    when: recipe.when ? recipe.when[language] || recipe.when.pt : "",
+    example: recipe.example ? recipe.example[language] || recipe.example.pt : ""
+  };
+}
+
+async function copyToClipboard(value) {
+  const textValue = String(value || "");
+  if (navigator.clipboard && navigator.clipboard.writeText) {
+    await navigator.clipboard.writeText(textValue);
+    return;
+  }
+
+  const textarea = document.createElement("textarea");
+  textarea.value = textValue;
+  textarea.setAttribute("readonly", "");
+  textarea.style.position = "fixed";
+  textarea.style.left = "-9999px";
+  document.body.appendChild(textarea);
+  textarea.select();
+  document.execCommand("copy");
+  textarea.remove();
+}
+
+async function handleNativeCodeCopy(event) {
+  const button = event.target.closest("[data-copy-code]");
+  if (!button) {
+    return;
+  }
+
+  const index = Number.parseInt(button.dataset.copyCode, 10);
+  const recipe = recipeForCode(index);
+  if (!recipe.example) {
+    return;
+  }
+
+  const originalText = button.textContent;
+  try {
+    await copyToClipboard(recipe.example);
+    button.textContent = text("copiedCode");
+    button.classList.add("copied");
+  } catch (error) {
+    button.textContent = text("copyFailed");
+    button.classList.add("copy-error");
+  }
+
+  setTimeout(() => {
+    button.textContent = originalText || text("copyCode");
+    button.classList.remove("copied", "copy-error");
+  }, 1400);
+}
+
 function selectedOptionText(select) {
   if (!select || !select.selectedOptions || !select.selectedOptions.length) {
     return select ? select.value : "";
@@ -1023,21 +1833,37 @@ function renderNativeCodeGrid() {
   }
 
   const language = currentLanguage();
+  const javaLabel = text("javaLabel");
+  const doesLabel = text("doesLabel");
+  const whenUseLabel = text("whenUseLabel");
   const returnsLabel = text("returnsLabel");
   const handlingLabel = text("handlingLabel");
-  elements.nativeCodeGrid.innerHTML = nativeCodeEntries.map((entry) => {
+  const exampleLabel = text("exampleLabel");
+  const copyCodeLabel = text("copyCode");
+  elements.nativeCodeGrid.innerHTML = nativeCodeEntries.map((entry, index) => {
     const syntax = entry.syntax ? entry.syntax[language] || entry.syntax.pt : entry.js;
     const description = entry.description[language] || entry.description.pt;
     const returns = entry.returns[language] || entry.returns.pt;
     const handling = entry.handling[language] || entry.handling.pt;
+    const recipe = recipeForCode(index);
 
     return `
     <article class="code-card">
-      <code>${escapeHtml(syntax)}</code>
-      <span>Java: ${escapeHtml(entry.java)}</span>
-      <p>${escapeHtml(description)}</p>
+      <div class="code-card-top">
+        <code>${escapeHtml(syntax)}</code>
+        <span>${escapeHtml(javaLabel)}: ${escapeHtml(entry.java)}</span>
+      </div>
+      <p><strong>${escapeHtml(doesLabel)}:</strong> ${escapeHtml(description)}</p>
+      <small><strong>${escapeHtml(whenUseLabel)}:</strong> ${escapeHtml(recipe.when)}</small>
       <small><strong>${escapeHtml(returnsLabel)}:</strong> ${escapeHtml(returns)}</small>
       <small class="handling"><strong>${escapeHtml(handlingLabel)}:</strong> ${escapeHtml(handling)}</small>
+      <div class="copy-example">
+        <div class="copy-example-header">
+          <strong>${escapeHtml(exampleLabel)}</strong>
+          <button type="button" class="copy-code-button" data-copy-code="${index}">${escapeHtml(copyCodeLabel)}</button>
+        </div>
+        <pre><code>${escapeHtml(recipe.example)}</code></pre>
+      </div>
     </article>
   `;
   }).join("");
@@ -1058,8 +1884,9 @@ function populateSettings(config = {}, project = state.project) {
   elements.themeColorTextInput.value = themeColor;
   elements.oneSignalAppIdInput.value = oneSignalAppIdFromConfig(config);
   renderPermissionOptions(Array.isArray(config.permissions) && config.permissions.length ? config.permissions : DEFAULT_PERMISSIONS);
-  elements.iconPathInput.value = config.icon || "";
-  elements.iconPreview.src = iconPreviewPath(config.icon || "");
+  const iconPath = String(config.icon || "").trim() || defaultIconPath();
+  elements.iconPathInput.value = iconPath;
+  elements.iconPreview.src = iconPreviewPath(iconPath);
   elements.debugInput.checked = Boolean(config.debug);
   elements.releaseInput.checked = Boolean(config.release);
 }
@@ -1093,9 +1920,7 @@ function validateSettings() {
   if (!isValidOptionalOneSignalAppId(elements.oneSignalAppIdInput.value)) {
     errors.push(text("invalidOneSignalAppId"));
   }
-  if (!elements.iconPathInput.value.trim()) {
-    errors.push(text("missingIcon"));
-  } else if (!/\.png$/i.test(elements.iconPathInput.value.trim())) {
+  if (elements.iconPathInput.value.trim() && !/\.png$/i.test(elements.iconPathInput.value.trim())) {
     errors.push(text("invalidIconType"));
   }
 
@@ -1142,7 +1967,7 @@ function renderReview() {
     [text("appThemeColor"), elements.themeColorTextInput.value.trim()],
     [text("oneSignalAppId"), elements.oneSignalAppIdInput.value.trim() || "-"],
     [text("androidPermissions"), selectedPermissions().join(", ")],
-    [text("appIcon"), elements.iconPathInput.value.trim()]
+    [text("appIcon"), displayIconValue(elements.iconPathInput.value.trim())]
   ];
 
   elements.reviewGrid.innerHTML = items.map(([label, value]) => `
@@ -1305,22 +2130,67 @@ async function ensureEnvironmentBeforeSettings() {
   return ready;
 }
 
-async function summarizeProject(project) {
+function renderProjectSnapshot(project) {
   state.project = project;
-  state.doctorOk = false;
-  state.environmentOk = false;
-  state.environmentChecking = false;
-  state.environmentFailed = false;
-  state.settingsValid = false;
-  state.lastApkPath = null;
   state.lastDistPath = project.distPath;
-
   elements.projectSummary.classList.remove("hidden");
   elements.projectName.textContent = project.name;
   elements.projectPath.textContent = project.projectRoot;
   elements.configStatus.textContent = project.hasAppJson || project.hasConfigJson ? text("detected") : text("notDetected");
   elements.entryStatus.textContent = project.hasEntryFile ? text("detected") : text("missing");
   elements.entryPath.textContent = project.entryPath;
+}
+
+async function watchCurrentProject() {
+  if (!state.project || !api.watchProject) {
+    return;
+  }
+
+  try {
+    const result = await api.watchProject(state.project.projectRoot);
+    if (result && !result.ok) {
+      appendLog(`${text("projectWatcherFail")}: ${result.message}`, "error");
+    }
+  } catch (error) {
+    appendLog(`${text("projectWatcherFail")}: ${error.message}`, "error");
+  }
+}
+
+function applyProjectChange(payload) {
+  if (!payload || !payload.project || !state.project) {
+    return;
+  }
+
+  if (payload.project.projectRoot !== state.project.projectRoot) {
+    return;
+  }
+
+  renderProjectSnapshot(payload.project);
+
+  const reloadSettings = isConfigFilePath(payload.changedPath);
+  if (reloadSettings && !state.buildRunning) {
+    populateSettings(payload.project.config || {}, payload.project);
+    appendLog(text("projectConfigReloaded"), "system");
+  } else {
+    appendLog(`${text("projectAutoUpdated")}: ${payload.changedPath || payload.project.projectRoot}`, "system");
+  }
+
+  setStep("folder", payload.project.hasEntryFile ? "done" : "active", payload.project.hasEntryFile ? text("folderReady") : text("missing"));
+  validateSettings();
+  if (document.querySelector(".nav-item.active")?.dataset.view === "build") {
+    renderReview();
+  }
+}
+
+async function summarizeProject(project) {
+  renderProjectSnapshot(project);
+  state.doctorOk = false;
+  state.environmentOk = false;
+  state.environmentChecking = false;
+  state.environmentFailed = false;
+  state.settingsValid = false;
+  state.lastApkPath = null;
+
   elements.nextSettingsButton.disabled = false;
   elements.doctorButton.disabled = true;
   setBuildButtons(false);
@@ -1334,6 +2204,7 @@ async function summarizeProject(project) {
   appendLog(`${text("droppedFolder")}: ${project.projectRoot}`, "system");
   validateSettings();
   setProgress(project.hasEntryFile ? 25 : 15, project.hasEntryFile ? text("progressFolder") : text("missing"), project.hasEntryFile ? "" : "error");
+  await watchCurrentProject();
   await ensureEnvironmentBeforeSettings();
 }
 
@@ -1451,6 +2322,8 @@ async function runBuildFlow() {
     state.lastApkPath = result.apkPath;
     state.lastDistPath = state.project.distPath;
     elements.apkPath.textContent = result.apkPath;
+    elements.successTitle.textContent = text("successTitle");
+    elements.successText.textContent = text("successText");
     elements.successApkPath.textContent = result.apkPath;
     elements.resultPanel.classList.remove("hidden");
     setStep("build", "done", text("buildOk"));
@@ -1470,6 +2343,74 @@ async function runBuildFlow() {
   }
 }
 
+async function runUsbDebugFlow() {
+  if (!state.project || state.buildRunning) {
+    setStatus("error", state.project ? text("usbDebugRunning") : text("chooseProjectFirst"));
+    return;
+  }
+  if (!goToReview()) {
+    return;
+  }
+
+  showLogBar();
+  state.buildRunning = true;
+  updateActionButtons();
+  elements.resultPanel.classList.add("hidden");
+  setView("build");
+  setStep("folder", "done", text("folderReady"));
+
+  const doctorOk = await runDoctorOnly();
+  if (!doctorOk) {
+    state.buildRunning = false;
+    updateActionButtons();
+    return;
+  }
+
+  setStatus("busy", text("usbDebugRunning"));
+  setStep("build", "active", text("usbDebugRunning"));
+  setProgress(90, text("progressBuild"), "active");
+  startAnimatedLogs();
+
+  try {
+    const response = await api.runUsbDebugBuild(buildOptions());
+    stopAnimatedLogs();
+    if (!response.ok) {
+      setStep("build", "error", text("usbDebugFail"));
+      setStatus("error", text("usbDebugFail"));
+      setProgress(90, text("progressError"), "error");
+      appendLog(response.message || text("usbDebugFail"), "error");
+      if (response.buildDir) {
+        appendLog(`Build directory kept: ${response.buildDir}`, "system");
+      }
+      return;
+    }
+
+    const result = response.result;
+    state.lastApkPath = result.apkPath;
+    state.lastDistPath = state.project.distPath;
+    elements.apkPath.textContent = result.apkPath;
+    elements.successTitle.textContent = text("usbSuccessTitle");
+    elements.successText.textContent = text("usbSuccessText");
+    elements.successApkPath.textContent = result.apkPath;
+    elements.resultPanel.classList.remove("hidden");
+    setStep("build", "done", text("usbDebugOk"));
+    setStatus("ready", text("usbDebugOk"));
+    setProgress(100, text("progressDone"));
+    appendLog(`${text("usbDebugOk")}: ${result.device && result.device.id ? result.device.id : "Android USB"}`, "success");
+    appendLog(`${text("buildOk")}: ${result.apkPath}`, "success");
+    setView("success");
+  } catch (error) {
+    stopAnimatedLogs();
+    setStep("build", "error", text("usbDebugFail"));
+    setStatus("error", error.message);
+    setProgress(90, text("progressError"), "error");
+    appendLog(error.message, "error");
+  } finally {
+    state.buildRunning = false;
+    updateActionButtons();
+  }
+}
+
 function toggleTheme() {
   state.theme = state.theme === "dark" ? "light" : "dark";
   applyTheme();
@@ -1519,6 +2460,7 @@ function bindEvents() {
   elements.settingsNextButton.addEventListener("click", goToReview);
   elements.doctorButton.addEventListener("click", runDoctorOnly);
   elements.buildButton.addEventListener("click", runBuildFlow);
+  elements.usbDebugButton.addEventListener("click", runUsbDebugFlow);
   elements.clearLogsButton.addEventListener("click", clearLogs);
   elements.toggleLogsButton.addEventListener("click", toggleLogBar);
   elements.bottomToggleLogsButton.addEventListener("click", toggleLogBar);
@@ -1553,6 +2495,7 @@ function bindEvents() {
     validateSettings();
   });
   elements.permissionGrid.addEventListener("change", validateSettings);
+  elements.nativeCodeGrid.addEventListener("click", handleNativeCodeCopy);
   [
     elements.appNameInput,
     elements.packageIdInput,
@@ -1629,6 +2572,16 @@ function bindEvents() {
   api.onInstallLog((payload) => {
     appendLog(payload.line, payload.kind || "raw");
   });
+
+  if (api.onProjectChanged) {
+    api.onProjectChanged(applyProjectChange);
+  }
+
+  if (api.onProjectWatchError) {
+    api.onProjectWatchError((payload) => {
+      appendLog(`${text("projectWatcherFail")}: ${payload.message}`, "error");
+    });
+  }
 }
 
 async function init() {
@@ -1645,6 +2598,11 @@ async function init() {
   try {
     const info = await api.appInfo();
     elements.appVersion.textContent = `v${info.version}`;
+    state.defaultIconPath = info.iconPath || "";
+    if (elements.iconPathInput && !elements.iconPathInput.value.trim() && state.defaultIconPath) {
+      elements.iconPathInput.value = state.defaultIconPath;
+      elements.iconPreview.src = iconPreviewPath(state.defaultIconPath);
+    }
   } catch {
     elements.appVersion.textContent = "v0.1.0";
   }