@pushmesh/sdk 0.7.2

package/android/src/main/java/io/pushmesh/sdk/PushMeshMessageRouter.kt

@@ -0,0 +1,477 @@
+package io.pushmesh.sdk
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Color
+import android.media.RingtoneManager
+import android.net.Uri
+import android.os.Build
+import android.os.SystemClock
+import androidx.core.app.NotificationCompat
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import org.json.JSONObject
+import java.io.ByteArrayOutputStream
+import java.io.InputStream
+import java.net.HttpURLConnection
+import java.net.URL
+import kotlin.concurrent.thread
+
+/**
+ * Roteador central das mensagens PUSHMESH no Android (modo zero-config).
+ * Usado pelo [PushMeshMessagingReceiver] (dual-run — caminho principal) e
+ * pelo [PushMeshMessagingService] (fallback, quando a cadeia de broadcast
+ * não passa pelo receiver).
+ *
+ * Com o corpo DATA-ONLY do servidor (decisão 2026-07-28), NADA é exibido pelo
+ * sistema — então em TODOS os estados (foreground/background/morto) este
+ * router:
+ * 1. avisa o JS (PushMeshMessage) se há instância ativa, ou bufferiza para
+ *    o próximo init (PushMeshMessageBuffer);
+ * 2. exibe a notificação via NotificationCompat (título/corpo/imagem/canal/
+ *    som/cor do `pm_*`; imagem baixada com timeout, TETO DE MEMÓRIA e
+ *    fallback sem imagem);
+ * 3. posta o RECIBO DE ENTREGA direto em Kotlin (não depende de JS vivo nem
+ *    de o usuário abrir o app; o JS reconcilia/deduplica pelo pm_msg_id e o
+ *    servidor deduplica pelo pm:rcpt NX — um eventual recibo duplo via JS é
+ *    absorvido lá).
+ *
+ * Tudo dentro de uma JANELA de tempo: ver o KDoc de [handle].
+ */
+object PushMeshMessageRouter {
+
+  const val CANAL_PADRAO = "pushmesh_default"
+  const val PREFS = "pushmesh_prefs"
+
+  /**
+   * Modo de inicialização do FCM escolhido pelo `configure()`
+   * (PushMeshFirebaseModule) e persistido aqui porque quem precisa dele —
+   * o [PushMeshMessagingService.onNewToken] — roda com o JS morto, em
+   * processo recém-acordado pelo sistema, onde o módulo nativo nem existe.
+   */
+  const val CHAVE_MODO_FCM = "pmx_fcm_mode"
+
+  /** Nós somos o FirebaseApp DEFAULT: o token do onNewToken é NOSSO. */
+  const val MODO_DEFAULT = "default"
+
+  /** O host é o DEFAULT e nós somos o app secundário: onNewToken NÃO é nosso. */
+  const val MODO_SECUNDARIO = "secundario"
+
+  private const val TAG = "PushMeshRouter"
+  private const val TIMEOUT_IMG_MS = 5_000
+  private const val TIMEOUT_HTTP_MS = 8_000
+  private const val PAUSA_RETRY_MS = 1_000L
+
+  /**
+   * Janela total do trabalho de UMA mensagem. O receiver segura o broadcast
+   * com goAsync() e o service do FCM segura um wakelock — os dois têm limite
+   * de ~10s, e estourá-lo é ANR. 9s deixa folga para o finish().
+   */
+  private const val JANELA_TOTAL_MS = 9_000L
+
+  /** Teto do corpo da imagem baixada (ver [baixarImagem]). */
+  private const val MAX_BYTES_IMG = 4L * 1024 * 1024
+
+  /** Teto de pixels do bitmap decodificado — 2 MP (ver [baixarImagem]). */
+  private const val MAX_PIXELS_IMG = 2_000_000L
+
+  fun prefs(context: Context) =
+    context.applicationContext.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+
+  /**
+   * Marcador do dual-run: a mensagem é NOSSA se tem alguma chave `pm_*`
+   * (o servidor manda o bloco de exibição nessas chaves). ESPELHO da função
+   * JS `mensagemDoPushMesh` (src/zeroconfig.ts) — mudou aqui, muda lá.
+   * A prova real do roteamento no manifest mesclado é em device (o push do
+   * provedor legado, sem pm_*, passa intocado).
+   */
+  fun isNossa(data: Map<String, String>): Boolean = data.keys.any { it.startsWith("pmx_") }
+
+  /**
+   * Contexto React vivo — nas DUAS arquiteturas e SEM NUNCA lançar.
+   *
+   * Armadilha que derrubou o app piloto em produção (2026-07-29): na New
+   * Architecture o getter `ReactApplication.reactNativeHost` **lança
+   * RuntimeException de propósito** ("You should not use ReactNativeHost
+   * directly in the New Architecture"). Como o receiver/service rodam em
+   * thread de broadcast do sistema, a exceção não é "erro de push": ela
+   * DERRUBA O APP INTEIRO a cada mensagem recebida.
+   *
+   * Ordem: `reactHost` primeiro (New Architecture, default do RN desde 0.76);
+   * `reactNativeHost` só como fallback para app em arquitetura antiga, dentro
+   * de try/catch. Contexto ausente NÃO é falha: o router bufferiza para o
+   * próximo init e a exibição/recibo nativos independem de JS.
+   */
+  fun contextReact(context: Context): ReactContext? {
+    val app = context.applicationContext as? ReactApplication ?: return null
+    try {
+      app.reactHost?.currentReactContext?.let { return it }
+    } catch (_: Throwable) {
+      // host novo indisponível — cai para o caminho antigo
+    }
+    return try {
+      @Suppress("DEPRECATION")
+      app.reactNativeHost.reactInstanceManager.currentReactContext
+    } catch (_: Throwable) {
+      null
+    }
+  }
+
+  /**
+   * Pipeline completo de uma mensagem nossa (ver KDoc da classe).
+   *
+   * BLOQUEANTE DE PROPÓSITO (2026-08-01) — só chame de thread de background
+   * (o `goAsync` do receiver ou a thread do FCM no service).
+   *
+   * POR QUÊ: quem chama só mantém o processo com prioridade enquanto o
+   * callback NÃO retorna. Na versão anterior o recibo e a exibição saíam em
+   * `thread {}` soltas e handle() voltava em milissegundos — o
+   * `pending.finish()` acontecia logo em seguida e, com o app MORTO (o caso
+   * que o receiver existe para cobrir), o processo virava "cached" na hora.
+   * Sob pressão de memória — justamente nos OEMs agressivos que o SDK mede em
+   * `bateria_irrestrita` — o LMK matava o processo NO MEIO do download da
+   * imagem: push que nunca apareceu e recibo perdido, sem erro em lugar
+   * nenhum. Agora o trabalho termina ANTES de handle() voltar.
+   *
+   * JANELA: a do broadcast/wakelock é de ~10s e estourá-la é ANR, então tudo
+   * respeita [JANELA_TOTAL_MS]. A ordem é deliberada:
+   * 1. evento/buffer do JS — instantâneo, sem rede, e é o FALLBACK durável do
+   *    recibo (o JS drena no próximo init);
+   * 2. exibição — é o que o usuário vê e o que NÃO tem segunda chance;
+   * 3. recibo direto — com o que sobrar da janela; se não couber, o buffer +
+   *    o próximo init reenviam (o servidor deduplica pelo pm:rcpt NX).
+   *
+   * Cada passo é isolado em seu próprio `runCatching`: falha de um não
+   * impede os outros e NADA escapa daqui (LEI do SDK: push nunca derruba o
+   * app do cliente).
+   */
+  fun handle(context: Context, data: Map<String, String>, reactContext: ReactContext?) {
+    val prazo = SystemClock.elapsedRealtime() + JANELA_TOTAL_MS
+    runCatching { avisarJs(context, data, reactContext) }
+      .onFailure { android.util.Log.w(TAG, "aviso ao JS falhou (o resto do push segue)", it) }
+    runCatching { exibirAgora(context, data, prazo) }
+      .onFailure { android.util.Log.w(TAG, "exibição do push falhou (app segue normal)", it) }
+    runCatching { postarReciboAgora(context, data, "recebido", prazo) }
+      .onFailure { android.util.Log.w(TAG, "recibo direto falhou (o buffer reenvia)", it) }
+  }
+
+  /** Evento para o JS vivo; sem instância ativa, bufferiza para o próximo init. */
+  private fun avisarJs(context: Context, data: Map<String, String>, reactContext: ReactContext?) {
+    if (reactContext != null && reactContext.hasActiveReactInstance()) {
+      val dataMap = Arguments.createMap()
+      for ((k, v) in data) dataMap.putString(k, v)
+      val payload = Arguments.createMap()
+      payload.putMap("data", dataMap)
+      reactContext
+        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+        .emit(PushMeshFirebaseModule.EVENT_MESSAGE, payload)
+    } else {
+      PushMeshMessageBuffer.add(context, data)
+    }
+  }
+
+  /** Token FCM novo chegou sem JS (ou com JS): sempre persiste — o boot reconcilia. */
+  fun salvarTokenPendente(context: Context, token: String) {
+    prefs(context).edit().putString("pmx_pending_token", token).apply()
+  }
+
+  fun tokenPendente(context: Context): String? = prefs(context).getString("pmx_pending_token", null)
+
+  fun limparTokenPendente(context: Context) {
+    prefs(context).edit().remove("pmx_pending_token").apply()
+  }
+
+  /** Grava o modo do FCM decidido no configure() (ver [CHAVE_MODO_FCM]). */
+  fun salvarModoFcm(context: Context, modo: String) {
+    prefs(context).edit().putString(CHAVE_MODO_FCM, modo).apply()
+  }
+
+  /**
+   * Modo do FCM persistido. O default é [MODO_DEFAULT] porque esse é o caminho
+   * principal do zero-config (app do cliente sem Firebase): antes do primeiro
+   * `configure()` o token que chegar é, quase sempre, do FirebaseApp que nós
+   * mesmos vamos assumir — e o boot ainda reconcilia com um getToken fresco.
+   */
+  fun modoFcm(context: Context): String =
+    prefs(context).getString(CHAVE_MODO_FCM, MODO_DEFAULT) ?: MODO_DEFAULT
+
+  // -------------------------------------------------------------------------
+  // Recibo de entrega direto (1 retry leve, sempre dentro da janela)
+  // -------------------------------------------------------------------------
+
+  /**
+   * Recibo em thread própria (fire-and-forget) — para quem NÃO pode bloquear:
+   * o clique chega na main thread da [PushMeshClickActivity], onde rede
+   * síncrona seria NetworkOnMainThreadException.
+   *
+   * No caminho de ENTREGA use [postarReciboAgora] (dentro de handle): lá o
+   * trabalho precisa terminar antes de o processo perder prioridade.
+   */
+  fun postarRecibo(context: Context, data: Map<String, String>, evento: String = "recebido") {
+    val prazo = SystemClock.elapsedRealtime() + JANELA_TOTAL_MS
+    thread {
+      // LEI do SDK: push nunca derruba o app do cliente. Exceção (ou Error)
+      // não tratada em thread própria mata o processo inteiro — aqui ela para.
+      try {
+        postarReciboAgora(context, data, evento, prazo)
+      } catch (t: Throwable) {
+        android.util.Log.w(TAG, "recibo em background falhou (app segue normal)", t)
+      }
+    }
+  }
+
+  /**
+   * Recibo SÍNCRONO: roda na thread de quem chamou e respeita o `prazo`
+   * (relógio de [SystemClock.elapsedRealtime]). Falhar aqui não perde o dado —
+   * o buffer nativo + o drain do JS no próximo init reenviam.
+   */
+  private fun postarReciboAgora(
+    context: Context,
+    data: Map<String, String>,
+    evento: String,
+    prazo: Long,
+  ) {
+    val msgId = data["pm_msg_id"] ?: return
+    val rcpt = data["pm_rcpt"] ?: return
+    val prefs = prefs(context)
+    // Faltando qualquer um: player ainda não registrado (1º boot). O recibo sai
+    // pelo JS quando o register acontecer e o buffer for drenado — nada se perde.
+    val baseUrl = prefs.getString("pmx_base_url", null)?.takeIf { it.isNotBlank() } ?: return
+    val appId = prefs.getString("pmx_app_id", null)?.takeIf { it.isNotBlank() } ?: return
+    val playerId = prefs.getString("pmx_player_id", null)?.takeIf { it.isNotBlank() } ?: return
+    val corpo = JSONObject()
+      .put("app_id", appId)
+      .put("notification_id", msgId)
+      .put("player_id", playerId)
+      .put("rcpt", rcpt)
+      .put("evento", evento)
+      .toString()
+
+    for (tentativa in 1..2) {
+      val restante = restanteMs(prazo)
+      if (restante <= 0L) break
+      val timeout = restante.coerceAtMost(TIMEOUT_HTTP_MS.toLong()).toInt()
+      if (enviarRecibo(baseUrl, corpo, timeout)) return
+      // Só pausa para a 2ª tentativa se ainda houver janela para a pausa MAIS
+      // um POST curto — senão a espera só serviria para estourar o limite.
+      if (tentativa == 1) {
+        if (restanteMs(prazo) < PAUSA_RETRY_MS + 1_000L) break
+        Thread.sleep(PAUSA_RETRY_MS)
+      }
+    }
+    android.util.Log.w(TAG, "recibo direto não confirmou; o buffer/JS reenviam no próximo init")
+  }
+
+  /** POST do recibo; true = servidor confirmou (2xx). Nunca lança. */
+  private fun enviarRecibo(baseUrl: String, corpo: String, timeoutMs: Int): Boolean = try {
+    val conn = URL("$baseUrl/api/v1/receipts").openConnection() as HttpURLConnection
+    try {
+      conn.requestMethod = "POST"
+      conn.setRequestProperty("Content-Type", "application/json")
+      conn.connectTimeout = timeoutMs
+      conn.readTimeout = timeoutMs
+      conn.doOutput = true
+      conn.outputStream.use { it.write(corpo.toByteArray(Charsets.UTF_8)) }
+      conn.responseCode in 200..299
+    } finally {
+      conn.disconnect()
+    }
+  } catch (t: Throwable) {
+    android.util.Log.w(TAG, "recibo direto falhou: ${t.message}")
+    false
+  }
+
+  /** Quanto sobrou da janela, nunca negativo. */
+  private fun restanteMs(prazo: Long): Long = (prazo - SystemClock.elapsedRealtime()).coerceAtLeast(0L)
+
+  // -------------------------------------------------------------------------
+  // Display via NotificationCompat (data-only: nós exibimos em todos os estados)
+  // -------------------------------------------------------------------------
+
+  /**
+   * Exibe a notificação NA THREAD DE QUEM CHAMOU (ver KDoc de [handle]: em
+   * thread solta o processo podia morrer antes do `notify`). Respeita o prazo
+   * da janela no download da imagem.
+   */
+  private fun exibirAgora(context: Context, data: Map<String, String>, prazo: Long) {
+    val title = data["pmx_title"]
+    val body = data["pmx_body"]
+    if (title.isNullOrBlank() && body.isNullOrBlank()) return
+
+    val bitmap = data["pmx_image"]?.takeIf { it.isNotBlank() }?.let { baixarImagem(it, restanteMs(prazo)) }
+    val channelId = data["pmx_channel"]?.takeIf { it.isNotBlank() } ?: CANAL_PADRAO
+    garantirCanal(context, channelId, data["pmx_sound"])
+
+    // CLIQUE: passa pelo NOSSO trampolim (PushMeshClickActivity).
+    //
+    // Por quê: quando a mensagem tem `pm_url`, o toque precisa abrir a URL —
+    // e se o PendingIntent fosse um ACTION_VIEW direto, o navegador abriria
+    // sem o nosso processo rodar e o CLIQUE NUNCA SERIA CONTADO (o funil
+    // ficaria zerado justamente nas campanhas com link, que são as que mais
+    // importam). O receiver registra o clique e só então abre o destino:
+    // a URL, quando existe; a MainActivity, quando não.
+    val notifId = data["pm_msg_id"]?.hashCode() ?: (System.currentTimeMillis() % 100_000).toInt()
+    val intentClique = Intent(context, PushMeshClickActivity::class.java).apply {
+      for ((k, v) in data) putExtra(k, v)
+      addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+    }
+    // getActivity, NÃO getBroadcast: só um PendingIntent de Activity pode
+    // abrir tela a partir da notificação (Android 10+ bloqueia abertura de
+    // tela por app em segundo plano, e bloqueia em silêncio).
+    val pi = PendingIntent.getActivity(
+      context, notifId, intentClique,
+      PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+    )
+
+    val builder = NotificationCompat.Builder(context, channelId)
+      .setSmallIcon(resolverIcone(context, data["pmx_icon"]))
+      .setContentTitle(title)
+      .setContentText(body)
+      .setAutoCancel(true)
+      .setPriority(NotificationCompat.PRIORITY_HIGH)
+    builder.setContentIntent(pi)
+    data["pmx_color"]?.let {
+      try {
+        builder.setColor(Color.parseColor(it))
+      } catch (_: IllegalArgumentException) {
+        // cor inválida: segue sem cor
+      }
+    }
+    resolverSom(context, data["pmx_sound"])?.let { builder.setSound(it) } // < API 26 (canal manda no 26+)
+    if (bitmap != null) {
+      builder.setStyle(NotificationCompat.BigPictureStyle().bigPicture(bitmap))
+    } else if (!body.isNullOrBlank()) {
+      builder.setStyle(NotificationCompat.BigTextStyle().bigText(body))
+    }
+
+    val nm = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    nm.notify(notifId, builder.build())
+  }
+
+  private fun garantirCanal(context: Context, id: String, sound: String?) {
+    if (Build.VERSION.SDK_INT < 26) return
+    val nm = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    if (nm.getNotificationChannel(id) != null) return // canal do host: não mexe
+    val canal = NotificationChannel(
+      id,
+      if (id == CANAL_PADRAO) "Notificações" else id,
+      NotificationManager.IMPORTANCE_HIGH,
+    )
+    resolverSom(context, sound)?.let { canal.setSound(it, Notification.AUDIO_ATTRIBUTES_DEFAULT) }
+    nm.createNotificationChannel(canal)
+  }
+
+  private fun resolverSom(context: Context, sound: String?): Uri? {
+    if (sound.isNullOrBlank()) return null
+    if (sound == "default") return RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION)
+    val nome = sound.substringBeforeLast('.')
+    return Uri.parse("android.resource://${context.packageName}/raw/$nome")
+  }
+
+  private fun resolverIcone(context: Context, icon: String?): Int {
+    if (!icon.isNullOrBlank()) {
+      val porDrawable = context.resources.getIdentifier(icon, "drawable", context.packageName)
+      if (porDrawable != 0) return porDrawable
+      val porMipmap = context.resources.getIdentifier(icon, "mipmap", context.packageName)
+      if (porMipmap != 0) return porMipmap
+    }
+    return context.applicationInfo.icon
+  }
+
+  /**
+   * Baixa a imagem do bigPicture com TETO DE MEMÓRIA e timeout; qualquer falha
+   * ⇒ null (a notificação sai SEM imagem — nunca sem notificação).
+   *
+   * ARMADILHA REAL (corrigida em 2026-08-01): decodificar direto do stream não
+   * tem teto nenhum. O bitmap custa largura × altura × 4 bytes, então uma
+   * campanha com foto de 12 MP (4000 × 3000) pede ~48 MB de uma vez — e o que
+   * estoura é `OutOfMemoryError`, que é `java.lang.Error`, NÃO `Exception`:
+   * um `catch (e: Exception)` deixa ele passar e, vindo de thread própria, ele
+   * MATA O PROCESSO do app do cliente. E não adianta confiar no upload do
+   * painel: a API compatível aceita a URL da imagem vinda de fora (big_picture),
+   * e um JPEG de 1 MB pode ser 8000 × 4000.
+   *
+   * Três defesas, nesta ordem:
+   * 1. recusar Content-Length absurdo ANTES de ler, e cortar a leitura em
+   *    [MAX_BYTES_IMG] (servidor que mente no header não passa);
+   * 2. medir com `inJustDecodeBounds` e reamostrar com `inSampleSize` para no
+   *    máximo [MAX_PIXELS_IMG] — o BigPictureStyle não usa mais que isso, então
+   *    cortar pixel aqui não tira NADA da tela do usuário;
+   * 3. `catch (t: Throwable)` — é o único catch que pega OutOfMemoryError.
+   */
+  private fun baixarImagem(url: String, tetoMs: Long): Bitmap? {
+    if (tetoMs <= 0L) return null // sem janela: melhor notificação sem imagem que push atrasado
+    return try {
+      val timeout = tetoMs.coerceAtMost(TIMEOUT_IMG_MS.toLong()).toInt()
+      val conn = URL(url).openConnection() as HttpURLConnection
+      try {
+        conn.connectTimeout = timeout
+        conn.readTimeout = timeout
+        val declarado = conn.contentLengthLong // -1 quando o servidor não declara
+        if (declarado > MAX_BYTES_IMG) {
+          android.util.Log.w(TAG, "imagem do push recusada: $declarado bytes declarados")
+          return null
+        }
+        val bytes = conn.inputStream.use { lerAteOTeto(it) }
+          ?: run {
+            android.util.Log.w(TAG, "imagem do push recusada: corpo acima de $MAX_BYTES_IMG bytes")
+            return null
+          }
+        decodificarComTeto(bytes)
+      } finally {
+        conn.disconnect()
+      }
+    } catch (t: Throwable) {
+      // Throwable, não Exception: OutOfMemoryError é Error e é exatamente o
+      // que precisa morrer AQUI, e não no processo do cliente.
+      android.util.Log.w(TAG, "imagem do push falhou: ${t.message}")
+      null
+    }
+  }
+
+  /** Lê o corpo até [MAX_BYTES_IMG]; passou do teto ⇒ null (não guardamos lixo em RAM). */
+  private fun lerAteOTeto(entrada: InputStream): ByteArray? {
+    val saida = ByteArrayOutputStream()
+    val balde = ByteArray(16 * 1024)
+    var total = 0L
+    while (true) {
+      val lidos = entrada.read(balde)
+      if (lidos < 0) break
+      total += lidos
+      if (total > MAX_BYTES_IMG) return null
+      saida.write(balde, 0, lidos)
+    }
+    return saida.toByteArray()
+  }
+
+  /** Duas passadas: mede (sem alocar) e só então decodifica reamostrado. */
+  private fun decodificarComTeto(bytes: ByteArray): Bitmap? {
+    val medida = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+    BitmapFactory.decodeByteArray(bytes, 0, bytes.size, medida)
+    val largura = medida.outWidth
+    val altura = medida.outHeight
+    if (largura <= 0 || altura <= 0) return null // não é imagem que sabemos ler
+    val opcoes = BitmapFactory.Options().apply { inSampleSize = amostragem(largura, altura) }
+    return BitmapFactory.decodeByteArray(bytes, 0, bytes.size, opcoes)
+  }
+
+  /**
+   * Menor potência de 2 que traz largura × altura para ≤ [MAX_PIXELS_IMG]
+   * (o `inSampleSize` só respeita potência de 2 — valor quebrado é arredondado
+   * para baixo pelo próprio BitmapFactory).
+   */
+  private fun amostragem(largura: Int, altura: Int): Int {
+    val pixels = largura.toLong() * altura.toLong()
+    var amostra = 1
+    while (pixels / (amostra.toLong() * amostra.toLong()) > MAX_PIXELS_IMG) amostra *= 2
+    return amostra
+  }
+}

package/android/src/main/java/io/pushmesh/sdk/PushMeshMessagingReceiver.kt

@@ -0,0 +1,77 @@
+package io.pushmesh.sdk
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import kotlin.concurrent.thread
+
+/**
+ * Receiver de ALTA PRIORIDADE para `com.google.android.c2dm.intent.RECEIVE` —
+ * a peça do DUAL-RUN (migração do provedor legado):
+ *
+ * No manifest mesclado, o FCM entrega a mensagem como broadcast ORDENADO —
+ * apenas UM service/receiver a processa. Sem este receiver, ou o push do
+ * provedor legado morre, ou o nosso nunca chega. A regra:
+ *
+ * - mensagem NOSSA (marcador `pm_*`, ver PushMeshMessageRouter.isNossa):
+ *   processamos aqui (recibo direto + display NotificationCompat + evento/
+ *   buffer JS) e `abortBroadcast()` — o SDK do provedor legado nem vê;
+ * - mensagem SEM o marcador: return imediato, SEM abort — o broadcast segue
+ *   a cadeia e o SDK legado recebe normalmente (dual-run de verdade).
+ *
+ * A prova real do roteamento no manifest mesclado é em device (NÃO VERIFICADO
+ * em build); a decisão do marcador é testada em JS (espelho) e revisada aqui.
+ */
+class PushMeshMessagingReceiver : BroadcastReceiver() {
+
+  override fun onReceive(context: Context, intent: Intent) {
+    val extras = intent.extras ?: return
+    val data = HashMap<String, String>()
+    for (k in extras.keySet()) {
+      (extras.get(k) as? String)?.let { data[k] = it }
+    }
+    if (!PushMeshMessageRouter.isNossa(data)) return // pass-through: provedor legado segue
+
+    // ABORTAR ANTES do goAsync(). O goAsync() transfere o resultado do
+    // broadcast para o PendingResult; depois dele o receiver não tem mais
+    // resultado "pendente" e abortBroadcast() lança IllegalStateException —
+    // que num receiver do sistema NÃO é erro de push, é o app inteiro caindo
+    // (crash real no piloto, 2026-07-29). E só há o que abortar em broadcast
+    // ORDENADO: com o FCM ele é, mas a guarda evita depender disso.
+    if (isOrderedBroadcast) {
+      try {
+        abortBroadcast() // a mensagem é nossa: o SDK legado não a vê
+      } catch (_: Throwable) {
+        // sem resultado pendente (broadcast não ordenado): seguir sem abortar
+      }
+    }
+
+    // NUNCA acessar reactNativeHost direto: na New Architecture o getter lança
+    // e, num receiver do sistema, isso derruba o app a cada push (2026-07-29).
+    val reactContext = PushMeshMessageRouter.contextReact(context)
+    // goAsync() + trabalho SÍNCRONO dentro da thread: o `finish()` só acontece
+    // depois que a exibição e o recibo terminaram DE VERDADE.
+    //
+    // POR QUE ISSO IMPORTA (corrigido em 2026-08-01): o goAsync só segura a
+    // prioridade do processo enquanto o resultado está pendente. Enquanto o
+    // `handle` apenas DISPARAVA threads soltas, o finish() saía em
+    // milissegundos e, com o app MORTO — o caso que este receiver existe para
+    // cobrir —, o processo virava "cached" na hora; sob pressão de memória
+    // (os mesmos OEMs agressivos que o SDK mede em `bateria_irrestrita`) o LMK
+    // podia matá-lo NO MEIO do download da imagem: push que nunca apareceu e
+    // recibo perdido, sem erro em lugar nenhum. O `handle` agora é bloqueante
+    // e cabe na janela do broadcast (~10s) por construção — ver o KDoc dele.
+    val pending = goAsync()
+    thread {
+      try {
+        PushMeshMessageRouter.handle(context.applicationContext, data, reactContext)
+      } catch (t: Throwable) {
+        // LEI do SDK: push nunca derruba o app do cliente. Exceção não tratada
+        // em thread própria mata o processo — aqui ela para.
+        android.util.Log.w("PushMesh", "falha ao processar push (app segue normal)", t)
+      } finally {
+        pending.finish()
+      }
+    }
+  }
+}

package/android/src/main/java/io/pushmesh/sdk/PushMeshMessagingService.kt

@@ -0,0 +1,88 @@
+package io.pushmesh.sdk
+
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.google.firebase.messaging.FirebaseMessagingService
+import com.google.firebase.messaging.RemoteMessage
+
+/**
+ * FirebaseMessagingService do modo ZERO-CONFIG — caminho FALLBACK de entrega:
+ * quando a cadeia de broadcast passa pelo PushMeshMessagingReceiver (dual-run),
+ * é ele quem processa; este service cobre o cenário em que o FCM entrega
+ * direto ao service (sem o receiver na cadeia, comportamento de alguns OEMs).
+ *
+ * Com o corpo DATA-ONLY do servidor, onMessageReceived roda em TODOS os
+ * estados — tudo é delegado ao PushMeshMessageRouter (recibo direto +
+ * display NotificationCompat + evento/buffer JS), a MESMA lógica do receiver.
+ *
+ * onNewToken: emite 'PushMeshTokenRefresh' quando há JS e persiste o token
+ * pendente (SharedPreferences) — o boot reconcilia, então rotação de token
+ * não se perde. Exceção: no modo secundário o token NÃO é nosso (ver
+ * o comentário dentro do onNewToken).
+ */
+class PushMeshMessagingService : FirebaseMessagingService() {
+
+  // LEI do SDK: push nunca derruba o app do cliente. Estes dois callbacks
+  // rodam em thread do FCM — exceção que escapa daqui mata o processo
+  // inteiro (crash já visto em campo). Tudo fica dentro de guarda.
+
+  override fun onMessageReceived(message: RemoteMessage) {
+    val data = message.data
+    if (data.isEmpty()) return
+    // SEPARAÇÃO TOTAL (regra do produto, 2026-07-30): mensagem sem o NOSSO marcador
+    // é de outro SDK — não exibimos, não bufferizamos, não avisamos o JS. O
+    // receiver (caminho principal do dual-run) já deixa a cadeia seguir; aqui
+    // no fallback simplesmente não tocamos nela.
+    if (!PushMeshMessageRouter.isNossa(data)) return
+    try {
+      // handle() é BLOQUEANTE de propósito e aqui isso é o certo: onMessageReceived
+      // roda em thread de background do FCM, que mantém um wakelock enquanto não
+      // retorna. Voltar cedo (como fazia a versão com threads soltas) entregava o
+      // processo ao LMK no meio do download da imagem. O teto de ~9s do handle
+      // cabe na janela do serviço.
+      PushMeshMessageRouter.handle(applicationContext, data, currentReactContext())
+    } catch (t: Throwable) {
+      android.util.Log.w("PushMesh", "falha ao processar push (app segue normal)", t)
+    }
+  }
+
+  override fun onNewToken(token: String) {
+    super.onNewToken(token)
+    try {
+      // ARMADILHA DO MULTI-PROJETO (corrigida em 2026-08-01): o onNewToken do
+      // FirebaseMessagingService só é chamado para o FirebaseApp **DEFAULT**.
+      // No fallback secundário — o host tem Firebase próprio e nós viramos o
+      // app nomeado 'pushmesh' (ver PushMeshFirebaseModule.configure) — o
+      // token que chega aqui é do PROJETO DO HOST. Registrá-lo como nosso
+      // quebra o player em silêncio: o servidor passa a enviar para um token
+      // de outro sender e todo envio falha com SENDER_ID_MISMATCH, sem erro
+      // visível para ninguém. A rotação do NOSSO token nesse modo já é coberta
+      // pelo getToken fresco que o boot faz em toda abertura do app.
+      if (PushMeshMessageRouter.modoFcm(applicationContext) == PushMeshMessageRouter.MODO_SECUNDARIO) {
+        android.util.Log.w(
+          "PushMesh",
+          "token novo ignorado: é do FirebaseApp default (do app host), não do nosso projeto — " +
+            "o boot revalida o token pelo app secundário",
+        )
+        return
+      }
+      PushMeshMessageRouter.salvarTokenPendente(applicationContext, token)
+      val reactContext = currentReactContext()
+      if (reactContext != null && reactContext.hasActiveReactInstance()) {
+        reactContext
+          .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+          .emit(PushMeshFirebaseModule.EVENT_TOKEN_REFRESH, token)
+      }
+    } catch (t: Throwable) {
+      android.util.Log.w("PushMesh", "falha ao tratar token novo (boot reconcilia)", t)
+    }
+  }
+
+  /**
+   * Delegado ao router: na New Architecture `reactNativeHost` LANÇA, e aqui
+   * estamos numa thread de serviço do FCM — a exceção derrubaria o app a
+   * cada push/rotação de token (crash real observado em campo).
+   */
+  private fun currentReactContext(): ReactContext? =
+    PushMeshMessageRouter.contextReact(applicationContext)
+}

package/dist/cjs/boot.d.ts

@@ -0,0 +1,7 @@
+import type { PushMeshConfig } from './types';
+/**
+ * Sequência de boot do SDK: montagem automática do host in-app + init + hook de
+ * AppState + reporte de permissão no cold start (fire-and-forget — não bloqueia
+ * a abertura do app). Usado pelo PushMesh.init e pela API clássica (compat).
+ */
+export declare function boot(config: PushMeshConfig): Promise<void>;

package/dist/cjs/boot.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true}),exports.boot=boot;const auto_1=require("./inapp/auto"),permissions_1=require("./permissions"),players_1=require("./players");async function boot(config){true===config.inAppAutoMontar&&(0,auto_1.montarInAppAutomaticamente)(),await(0,players_1.init)(config),(0,permissions_1.attachAppStateHook)(),(0,permissions_1.checkAndReport)().catch(e=>console.warn("[PushMesh] checkAndReport falhou",e))}