AppMint Push - Avvisa i tuoi utenti

1Come funziona#

AppMint Push invia notifiche a tutti coloro che hanno installato la tua app, da dentro AppMint: invio immediato, pianificazione, modifica dopo l'invio, annullamento, link diretti.

Ogni messaggio può essere progettato: 8 modelli, un colore tutto tuo, fino a 3 pulsanti che aprono ciascuno la propria pagina, scelte di suono e pop-up, e un banner, una scheda, un pannello o uno schermo intero nativo in-app mentre l'app è aperta. Un'anteprima dal vivo lo mostra esattamente come lo vedranno i telefoni degli utenti.

Funziona sul TUO progetto Firebase: i tuoi utenti, il tuo progetto, nessun limite condiviso e niente di tuo ospitato da AppMint. Firebase Cloud Messaging è gratuito e senza limite di messaggi.

Ti servono due file da quel progetto: google-services.json (per la build) e una chiave dell'account di servizio (per l'invio). I passaggi successivi ti guidano a ottenerli entrambi. Funziona con ogni modalità di build: sito web, ZIP, HTML e AI.

AppMint Push e OneSignal sono alternative: attivarne uno disattiva l'altro.

2Crea un progetto Firebase#

Vai alla Firebase Console e clicca 'Add project' (oppure apri un progetto che hai già). Un progetto Firebase gratuito è sufficiente: per le notifiche non serve la fatturazione.

Un progetto può contenere più delle tue app.

Apri la Firebase Console →

3Aggiungi la tua app e scarica google-services.json#

Nel tuo progetto Firebase:

• Clicca 'Add app' e scegli Android
• Inserisci il nome del pacchetto ESATTAMENTE come impostato nella procedura guidata di AppMint (ad es. com.yourname.yourapp): una differenza significa che le notifiche non arrivano mai, e AppMint rifiuta la build per questo
• Clicca 'Register app' e scarica google-services.json
• Puoi saltare i passaggi rimanenti dell'SDK: AppMint li gestisce

4Attivalo e carica il file#

Nella scheda Notifiche push della procedura guidata di creazione:

• Attiva 'AppMint Push'
• Tocca 'Carica google-services.json' e scegli il file del passaggio precedente

La procedura guidata controlla che il file contenga il nome del tuo pacchetto. Poi crea il tuo APK come al solito: durante la build la tua app viene registrata per le push sul tuo progetto.

Gli utenti installano l'app e la aprono una volta. Su Android 13+ viene chiesto loro di consentire le notifiche dopo il caricamento della prima schermata.

I modelli, i pulsanti e gli stili in-app richiedono un'app creata con questa versione di AppMint o successiva. Una build più vecchia riceve comunque ogni messaggio, ma lo mostra nello stile semplice di sempre.

5Carica la chiave dell'account di servizio (una sola volta)#

AppMint invia tramite il tuo progetto, quindi ha bisogno di una chiave da esso: lo stesso file che chiede OneSignal.

Nella Firebase Console:

• ⚙ Impostazioni del progetto → scheda 'Service accounts'
• Clicca 'Generate new private key' e conferma: viene scaricato un file JSON

In AppMint: Home > Notifiche → scegli la tua app → 'Carica chiave' → scegli quel JSON.

AppMint verifica la chiave con un invio di prova al tuo progetto prima di memorizzarla (cifrata), così una spunta verde significa che il prossimo invio partirà davvero. Un solo caricamento per app; ricreare l'app non lo richiede di nuovo, a meno che tu non cambi progetto Firebase.

⚠️ Carica qui la chiave dell'ACCOUNT DI SERVIZIO, non google-services.json: la schermata ti avvisa se li confondi. Per revocare l'accesso in seguito, elimina la chiave nella Firebase Console.

6Invia la tua prima notifica#

In Home > Notifiche:

• Scegli la tua app
• Scrivi un titolo (messaggio, immagine e link sono facoltativi)
• Controlla la scheda Anteprima dal vivo
• Tocca 'Invia notifica'

Lo riceve ogni telefono con la tua app installata.

Per l'immagine, tocca la casella Immagine: 'Scegli dal dispositivo' (fino a 2 MB, PNG, JPEG o WebP) oppure 'Incolla un link all'immagine' (https://). Un'immagine scelta viene caricata solo quando premi Invia: puoi sceglierla, sostituirla o rimuoverla quante volte vuoi prima.

7Scegli un modello#

Design → Modello imposta il layout della notifica. Il testo viene sempre per primo: un'immagine non copre mai il messaggio:

• Automatico: scheda con immagine quando il messaggio ha un'immagine, altrimenti Standard
• Standard: titolo e messaggio completo; un'immagine diventa una piccola miniatura accanto
• Scheda con immagine: l'immagine SOTTO il titolo e il messaggio leggibili
• Banner: una scheda riempita con il tuo colore, con un badge facoltativo
• Promo: un badge come '50% OFF' e un pulsante colorato (il tuo primo pulsante)
• Elenco: fino a 6 righe brevi, ad es. più aggiornamenti di ordini
• Conto alla rovescia: un timer dal vivo che conta alla rovescia fino a una data e un'ora che scegli, poi esce da solo dall'area notifiche
• Avanzamento: una barra di avanzamento; modifica e reinvia con un nuovo valore e la barra avanza su ogni telefono senza vibrare di nuovo
• Minimale: titolo e una riga, nessun suono, nessun pop-up

Le dimensioni di testo e immagini si adattano alla dimensione del carattere di ogni utente, così niente viene tagliato sui telefoni con testo grande.

8Scegli un colore#

Design → Colore tinge l'icona, il banner, i pulsanti e il conto alla rovescia della notifica. Scegli uno dei 9 colori già pronti, oppure '+' per qualsiasi #RRGGBB.

Ogni colore già pronto si legge bene sia sui telefoni chiari sia su quelli scuri. Un colore personalizzato viene controllato su entrambi: se è troppo pallido o troppo scuro, la nota sotto i colori lo dice, e 'Correggi contrasto' nella casella del colore personalizzato lo avvicina alla tonalità più vicina che funziona mantenendo il tono. Il testo su un pulsante o banner colorato viene scritto in nero o bianco automaticamente.

Usa i riquadri 'Telefono chiaro' / 'Telefono scuro' nell'anteprima dal vivo per vederli entrambi.

9Aggiungi pulsanti#

Design → Pulsanti: '+ Aggiungi pulsante' (fino a 3). Ognuno ha un'etichetta (fino a 24 caratteri) e il proprio link, ad es. 'Traccia ordine' → #/orders/1042 e 'Aiuto' → #/support. Lascia vuoto il link di un pulsante per aprire il link principale.

I pulsanti compaiono sotto la notifica nell'area notifiche e nella presentazione in-app. Nel modello Promo il primo pulsante diventa il grande pulsante colorato sulla scheda.

10Mentre l'app è aperta#

Design → 'Mentre l'app è aperta' decide cosa vede un utente quando il messaggio arriva mentre sta usando la tua app:

• Design dell'app (predefinito): il codice della tua app lo mostra (vedi Posta in arrivo in-app qui sotto)
• Banner in alto: scende dall'alto e si nasconde da solo dopo qualche secondo
• Scheda al centro: una scheda sopra l'app oscurata con immagine, testo e pulsanti
• Pannello dal basso: la stessa scheda che sale dal basso
• Schermo intero: una grande immagine con i pulsanti in basso

La presentazione segue il tema chiaro o scuro del telefono, e Indietro o un tocco all'esterno la chiude. Quando viene mostrata, lo stesso messaggio non viene messo anche nell'area notifiche: l'utente lo sta già guardando.

Con 'Solo in-app' (Consegna → Mostra come), un messaggio che arriva mentre l'app è chiusa viene mostrato la volta successiva che l'utente la apre.

11Suono, pop-up e tempistica#

Design → Comportamento:

• Suono: disattivato per una notifica silenziosa
• Mostra a schermo: disattivalo per saltare l'apparizione su ciò che l'utente sta facendo (arriva comunque nell'area notifiche)
• Chiusura automatica: rimuove la notifica dall'area notifiche dopo un tempo da 30 secondi a 3 giorni (Android 8 e successivi)

Opzioni avanzate:

• Immagine icona / avatar: una piccola immagine rotonda accanto al testo (link https://)
• Chiave di raggruppamento: i messaggi che la condividono vengono raggruppati sotto un solo titolo
• Chiave di sostituzione: un messaggio più recente con la stessa chiave SOSTITUISCE quello più vecchio sul telefono e nella posta in arrivo, ad es. un punteggio in diretta

Gli utenti possono anche regolare il suono per tipo nelle impostazioni di notifica di Android per la tua app.

Il tuo suono: nella procedura, Integra → Notifiche push → Suono di notifica (MP3, OGG, WAV, M4A, AAC, FLAC o Opus, fino a 1 MB e 30 secondi). Viene riprodotto per ogni messaggio inviato con Suono attivo. Le app installate lo ricevono con l'aggiornamento che lo contiene; ogni utente può comunque cambiarlo nelle impostazioni di notifica di Android.

12Prova, salva e riusa#

• Anteprima dal vivo: riquadri Compatta, Espansa e In-app, su un telefono chiaro o scuro, disegnati dallo stesso codice che girano i telefoni dei tuoi utenti
• 'Prova su questo telefono': mostra il messaggio solo sul TUO telefono, come vera notifica o come presentazione in-app sopra la schermata Notifiche. Non viene inviato nulla agli utenti
• Modelli salvati (icona del libro in alto): 'Salva il messaggio attuale come modello' conserva su questo telefono testo, link, immagine e ogni scelta di design; 'Usa' lo ricarica con un tocco
• Nella Cronologia, 'Duplica come nuovo messaggio' avvia un nuovo messaggio da uno qualsiasi dei precedenti

13Pianifica per dopo#

Nella scheda Consegna, tocca 'Pianifica' sotto Quando, poi scegli una data e un'ora. La notifica parte automaticamente in quel momento.

Finché non parte, puoi modificarla o annullarla dall'elenco Cronologia qui sotto.

14Correggi un errore dopo l'invio#

Tocca una notifica qualsiasi nella Cronologia:

• 'Modifica e reinvia': lo ricarica nell'editor con tutto il suo design; 'Aggiorna e reinvia' lo sostituisce poi SUL POSTO su ogni dispositivo
• 'Annulla': lo rimuove da ogni telefono dove non è stato ancora aperto, compresa una presentazione in-app ancora sullo schermo
• 'Elimina': come annulla, e lo rimuove dalla cronologia

⚠️ Una notifica che l'utente ha già aperto o chiuso non può essere ritirata.

15Apri una pagina specifica#

Il campo facoltativo Link controlla cosa apre un tocco (ogni pulsante può avere il suo):

• Un indirizzo https:// completo (ottimo per le app di siti web)
• Un percorso in-app come #/offers

Il codice della tua app può anche leggerlo in qualsiasi momento:

const link = window.WebToApk?.getLaunchUrl?.();
window.addEventListener('appmint:deep-link',
  e => goTo(e.detail.url));

16Posta in arrivo in-app (facoltativa)#

Ogni push viene anche salvato dentro l'app installata (le ultime 50), così la tua app può mostrare una propria schermata di notifiche con i badge dei non letti. Funziona in OGNI modalità di build, comprese le app per sito web (URL), dove basta aggiungere queste poche righe al tuo sito.

Quando la shell ha già mostrato un messaggio sullo schermo (uno stile sotto 'Mentre l'app è aperta'), l'evento dice presented: true: in quel caso non disegnare un secondo banner. Un'app che disegna tutti i propri banner può disattivare quelli della shell con setPushPresentation('none').

Chiudere è uno SWIPE, non una piccola ✕, ed è reversibile: abbinalo a un breve Annulla:

const B = window.WebToApk;
const inbox = JSON.parse(B?.getPushInbox?.() ?? "[]");
// [{id,title,body,imageUrl,link,receivedAt,read,
//   template?,accent?,buttons?,badge?,inapp?...}]
const unread = inbox.filter(m => !m.read).length;

// live arrival while the app is open
window.addEventListener('appmint:push', e => {
  const d = e.detail;
  if (d.type === 'received' && !d.presented) showBanner(d.message);
  refreshInbox();   // fires for 'revoked' too
});

B?.markPushRead?.(id);        // "" = mark all read
B?.dismissPushMessage?.(id);  // swipe away
B?.restorePushMessage?.(id);  // ...Undo
B?.setPushPresentation?.('none'); // app draws its own

17Se sul telefono di prova non arriva nulla#

Quasi sempre è un limite del TELEFONO DI PROVA, non della tua app o dei tuoi utenti.

Android consente circa 100 registrazioni push per telefono. Ogni installazione NUOVA di un'app che usa le notifiche ne consuma una: installare una build dopo l'altra durante i test può esaurirle tutte, e quel telefono smette poi di ricevere per le app appena installate.

Libera degli slot (è questo che funziona davvero):

• Disinstalla le app di prova che non ti servono più: Android libera lo slot che ognuna occupava
• Oppure cancella i dati di un'app di prova: Impostazioni > App > [quell'app] > Archiviazione > Cancella dati: questo libera il suo slot senza disinstallare
• Su un emulatore, cancellarlo azzera subito ogni slot

Riavviare il telefono NON aiuta: queste registrazioni sono memorizzate in modo permanente, ed è per questo che sopravvivono a un riavvio. Anche svuotare la cache di Google Play Services non le libera.

Evitalo durante i test:

• Mantieni UN SOLO nome del pacchetto mentre fai le prove: ogni nome di pacchetto diverso occupa un suo slot
• Installa il nuovo APK SOPRA quello vecchio invece di disinstallare prima: un aggiornamento mantiene la registrazione esistente, una reinstallazione ne consuma una nuova
• Prova su un telefono di scorta o su un emulatore; cancellare un emulatore azzera subito i suoi slot
• Elimina le app di prova che hai finito di usare

Controlla anche le basi: l'app è stata aperta almeno una volta dopo l'installazione e le notifiche sono consentite nelle impostazioni di Android. L'app si iscrive di nuovo a ogni avvio, quindi si riprende da sola quando gli slot si liberano: non serve ricreare.

18Limiti e buone pratiche#

• Nessun limite al numero di notifiche che invii: Firebase Cloud Messaging è gratuito
• Titolo fino a 120 caratteri, messaggio fino a 1000; i link di immagine e icona devono iniziare con https://
• Fino a 3 pulsanti (etichette di 24 caratteri) e fino a 6 righe di elenco
• Nel piano gratuito, un breve annuncio viene riprodotto prima di ogni invio
• App di prova: rimuovile con l'icona del cestino accanto al selettore dell'app; questo elimina solo la cronologia e la chiave salvata in AppMint, il tuo progetto Firebase resta intatto, e una nuova build aggiunge di nuovo l'app
• Ricreare con un NUOVO google-services.json dallo STESSO progetto non cambia nulla: la tua chiave resta, le installazioni esistenti continuano a ricevere
• ⚠️ Spostare l'app su un progetto Firebase DIVERSO è una rottura netta. Ricrea con il nuovo google-services.json, carica la chiave del nuovo progetto (AppMint scarta la vecchia, perché non avrebbe mai potuto inviare per il nuovo progetto) e sappi che i telefoni che usano ancora la VECCHIA versione smettono di ricevere finché i loro utenti non aggiornano. Le notifiche raggiungono un progetto, e quelle installazioni sono ancora in ascolto del vecchio
• Invia con parsimonia: gli utenti disinstallano le app che li riempiono di messaggi

19Scegli chi lo riceve#

Sotto 'Chi lo riceve', un messaggio va a Tutti (il predefinito) oppure ai telefoni che scegli:

• Paesi, lingue, versioni di Android e versioni dell'app
• Attività: ha aperto l'app negli ultimi N giorni, oppure non la apre da N giorni
• Solo i telefoni con le notifiche attive
• ID utente e tag che la pagina della tua app imposta (passaggio successivo)

Prima di inviare, la schermata mostra quanti telefoni raggiunge la tua scelta.

Altri modi di inviare:

• Ora locale di ogni telefono (sotto Quando): ad es. le 09:00 sull'orologio di ogni telefono, fuso orario per fuso orario
• Test A/B: scrivi una versione B; ogni versione va a una parte di prova del pubblico e, dopo l'attesa che imposti, quella con più aperture (o tocchi) va a tutti gli altri
• Limite giornaliero per telefono: il massimo di messaggi che un telefono riceve da questa app in un giorno; i messaggi oltre il limite vengono saltati per quel telefono e mostrati come 'saltato (limite giornaliero)'

La Cronologia mostra, per ogni messaggio, a quanti telefoni è andato, quanti hanno fallito e quanti sono stati saltati.

⚠️ La scelta dei destinatari, l'ora locale, i test A/B, le automazioni e il limite giornaliero raggiungono solo i telefoni con un'app creata dal 30 set 2026 in poi (si registrano da soli). I telefoni con build più vecchie ricevono comunque gli invii a 'Tutti': ricrea e pubblica un aggiornamento per raggiungerli anche così.

20Rivolgiti agli utenti connessi e ai tag#

La pagina della tua app dice ad AppMint Push chi ha effettuato l'accesso e cosa sapere di questa installazione. Poi puoi inviare a un solo utente, o a tutti quelli con un tag come plan = pro.

• setPushUser: dopo l'accesso, con il TUO ID account (l'id del database, mai un indirizzo e-mail o un numero di telefono). Lettere, cifre e _ @ . : + - (fino a 128). Chiamalo con "" alla disconnessione, altrimenti il telefono continua a ricevere i messaggi di quell'utente
• setPushTag / setPushTags: un nome di tag (lettere, cifre e _, fino a 32) e un valore (fino a 128). "" rimuove un tag; fino a 50 per installazione
• getPushUser / getPushTags: rileggi ciò che questo telefono conserva

Gli ID e i tag appartengono all'installazione, non all'account: cancella anche i tag specifici dell'utente alla disconnessione. Il telefono segnala una modifica qualche secondo dopo (all'avvio successivo se è offline). Lo stesso utente connesso su due telefoni viene raggiunto su entrambi.

const B = window.WebToApk;

// after sign-in: your own account id
B?.setPushUser?.(user.id);
B?.setPushTag?.('plan', user.isPro ? 'pro' : 'free');
B?.setPushTags?.(JSON.stringify({ city: 'pune', level: '12' }));

// on sign-out
B?.setPushUser?.('');
B?.setPushTag?.('plan', '');

// read back
const who = B?.getPushUser?.() ?? '';
const tags = JSON.parse(B?.getPushTags?.() ?? '{}');

21Automazioni#

Messaggi che partono da soli. In Automazioni, tocca '＋ Nuovo' e scegline uno:

• Benvenuto: N minuti dopo una nuova installazione (da 0 minuti a 30 giorni). Ogni telefono lo riceve una volta
• Recupero utenti: quando qualcuno non apre l'app da N giorni (da 1 a 180). Una volta per assenza: un telefono che torna e poi si allontana di nuovo lo riceve di nuovo
• Tag: N minuti dopo che la pagina della tua app imposta un tag, facoltativamente solo per un valore. Parte solo se il tag è ancora impostato allo scadere del tempo

Carrello abbandonato: imposta un tag quando gli articoli vanno nel carrello e rimuovilo al pagamento. Un'automazione 'cart' con un ritardo di 60 minuti ricorda poi solo a chi se n'è andato senza acquistare. Impostare di nuovo lo stesso valore non riavvia il conteggio; dopo la rimozione del tag, impostarlo di nuovo può inviare ancora una volta.

Le automazioni contano nel limite giornaliero per telefono e raggiungono i telefoni con build create dal 30 set 2026 in poi.

const B = window.WebToApk;

// items added to the cart
B?.setPushTag?.('cart', 'open');

// checkout finished, or the cart emptied: no reminder
B?.setPushTag?.('cart', '');

22Raggiungi gli utenti con le notifiche disattivate#

Un telefono con le notifiche disattivate non mostra mai una notifica nell'area notifiche, ma il tuo messaggio raggiunge comunque l'app, e un messaggio in-app compare la volta successiva che l'utente la apre. Usalo per chiedere di riattivare le notifiche:

• Chi lo riceve → Scegli chi → attiva 'Notifiche disattivate'
• Mostra come → Solo in-app (un Banner in alto o una Scheda al centro in Design)
• Design → Pulsanti → '+ Pulsante “Attiva le notifiche”'. Il suo link è appmint://notifications/enable: un tocco mostra la richiesta di autorizzazione, oppure apre le impostazioni di notifica dell'app quando la richiesta non può più essere mostrata

Quando l'app ha telefoni con le notifiche disattivate, il centro di invio mostra 'Raggiungi gli N telefoni con le notifiche disattivate' sotto la chiave Firebase: un tocco imposta tutti e tre. Appena un utente attiva le notifiche, il suo telefono esce da quel pubblico.

Il pulsante richiede un'app creata con questa versione di AppMint o successiva; le build più vecchie trattano il link come un link normale. appmint://notifications/settings apre direttamente la schermata delle impostazioni.

// Your page can offer the same thing itself:
const r = await window.AppMint?.enableNotifications?.();
// r = { state: 'granted' | 'prompt' | 'blocked' | 'unavailable',
//       changed, openedSettings }

// and hear a push button's result too:
window.addEventListener('appmint:notifications', e => {
  if (e.detail.state === 'granted') hideNotifBanner();
});

23Messaggi in-app#

I messaggi in-app sono campagne che crei nel centro di invio: Notifiche push → 'Messaggi in-app' → '＋ Nuovo'. L'app li scarica e li mostra da sola, senza push, quando accade il trigger che hai scelto:

• L'app si apre: l'N-esima apertura dell'app
• Una pagina o un percorso (/checkout, #/cart, /product/*)
• Tempo nell'app: N secondi nell'app
• Un evento che la tua pagina traccia (passaggio successivo)
• Un tag push
• Notifiche disattivate: abbinalo a un pulsante 'Attiva le notifiche'
• Aggiornamento dell'app: la prima apertura dopo un aggiornamento

Mostralo come banner, finestra modale, pannello o schermo intero. Ogni messaggio ha una frequenza (una volta per installazione per impostazione predefinita), un pubblico facoltativo e un orario di inizio e fine facoltativo. Richiede AppMint Push nella build.

24Di' all'app cosa è successo#

La parte della tua pagina è piccola: segnala i momenti importanti con trackEvent. Un messaggio il cui trigger è 'Quando accade un evento' con lo stesso nome compare subito (o dopo l'attesa che hai scelto). Nomi: lettere, cifre e _ . : - (fino a 64). Gli eventi non vengono contati né memorizzati da nessuna parte; decidono solo se un messaggio compare.

I messaggi per percorso seguono da soli i veri cambiamenti di URL (caricamenti di pagina, pushState, percorsi #hash). Una vista che l'indirizzo non mostra (una scheda, un passaggio di una procedura) può essere segnalata come percorso con l'evento appmint:route.

if (window.AppMint && AppMint.trackEvent) AppMint.trackEvent('checkout_done', { total: 42 });

// raw bridge: props as a JSON string ('' for none)
WebToApk.trackEvent('level:3', '');

// a view the address does not show, reported as a route
window.dispatchEvent(new CustomEvent('appmint:route', { detail: { path: '/cart' } }));

25Disegna i messaggi da solo (facoltativo)#

Ogni messaggio lancia appmint:inapp con { type: 'shown' | 'clicked' | 'dismissed', id, name } (e chiama window.onAppMintInApp(detail) se la definisci).

Per disegnare i messaggi da solo, chiama WebToApk.setInAppPresentation('none'): l'app allora non disegna nulla e l'evento 'shown' porta presented: false e il messaggio (titolo, testo, immagine, pulsanti). setInAppPresentation('auto') restituisce il disegno all'app. WebToApk.getInAppCampaigns() elenca ciò che questa installazione contiene ([{id, name}]).

Tutto questo richiede AppMint Push nella build; in qualsiasi altra build i metodi rispondono false / "[]".

window.addEventListener('appmint:inapp', e => {
  // e.detail = { type: 'shown' | 'clicked' | 'dismissed', id, name, presented?, message? }
  if (e.detail.type === 'shown' && e.detail.presented === false) drawMyBanner(e.detail.message);
});

WebToApk.setInAppPresentation('none');   // 'auto' gives drawing back to the app
const held = JSON.parse(WebToApk.getInAppCampaigns() || '[]');   // [{id, name}]

26Parti da un modello#

'＋ Nuovo' apre una galleria di messaggi già pronti, ognuno con un'anteprima dal vivo che puoi cercare o filtrare per layout: Benvenuto, Valutaci, Attiva le notifiche, Novità, Vendita flash (con un conto alla rovescia dal vivo), Promo stagionale, Nuova funzione, Aggiornamento disponibile, Carrello abbandonato, Recupero utenti, Sondaggio a stelle, Punteggio NPS, Invita amici, Offerta di abbonamento, Serie di giorni, Consiglio, Spiegazione dell'autorizzazione, Manutenzione (resta finché non viene chiuso), Aggiornamento dei termini (senza pulsante di chiusura) e Seguici. Un modello compila layout, emoji o immagine, testo, pulsanti, trigger e frequenza: cambia qualsiasi cosa prima di salvare. 'Messaggio vuoto' parte da zero.

Sondaggio a stelle, Valutaci e NPS pongono una domanda: una riga di 1-5 stelle o un punteggio da 0 a 10. Il primo pulsante attende una risposta; la risposta viene segnalata una volta, alla chiusura del messaggio, come evento 'answered' appmint:inapp { value, question }, e il centro di invio mostra la media delle stelle o il punteggio NPS con la distribuzione.

I link dei pulsanti possono essere anche appmint://review (la schermata di recensione di Google Play), share:text (la schermata di condivisione), copy:text (gli appunti), route:/page e event:name. Il testo può usare {app}, {store}, {name}, {streak} e {tag:key}, compilati su ogni telefono; {name|friend} dà una parola di riserva quando non c'è alcun valore. Un messaggio il cui segnaposto non ha valore non viene mostrato. Richiede un'app creata con questa versione o successiva.

window.addEventListener('appmint:inapp', e => {
  const d = e.detail;
  if (d.type === 'answered') {
    // d.question: 'stars' (1-5) or 'nps' (0-10); d.template e.g. 'survey_stars'
    if (d.question === 'nps' && d.value <= 6) openFeedbackForm();
  }
  if (d.type === 'clicked' && d.link === 'event:allow') askForLocation();
});

// {streak} and {tag:key} come from push tags
WebToApk.setPushTag('streak', '7');