Creare un'app per iOS utilizzando Firebase e l'ambiente flessibile di App Engine

Questo tutorial illustra come scrivere un'app per iOS con archiviazione dei dati backend, sincronizzazione in tempo reale e logging degli eventi utente utilizzando Firebase. I servlet Java in esecuzione nell'ambiente flessibile di App Engine ascoltano i nuovi log utente archiviati in Firebase ed li elaborano.

Le istruzioni mostrano come eseguire questa operazione utilizzando Firebase e l'ambiente flessibile di App Engine.

Se vuoi che la tua app elabori i dati utente o orchestra gli eventi, puoi estendere Firebase con l'ambiente flessibile di App Engine per eseguire automaticamente la sincronizzazione dei dati in tempo reale.

L'app di esempio, Playchat, archivia i messaggi di chat in Firebase Realtime Database, che sincronizza automaticamente quei dati sui dispositivi. Inoltre, PlayChat scrive i log eventi utente in Firebase. Per ulteriori informazioni su come il database sincronizza i dati, consulta la sezione Come funziona? nella documentazione di Firebase.

Il seguente diagramma mostra l'architettura del client Playchat.

Architettura del client Playchat

Un set di servlet Java in esecuzione nell'ambiente flessibile di App Engine si registra come ascoltatori con Firebase. I servlet rispondono ai nuovi log di eventi utente ed elaborano i dati dei log. I servlet utilizzano le transazioni per garantire che solo un servlet gestisca ogni log di eventi utente.

Il seguente diagramma mostra l'architettura del server di Playchat.

Architettura del server di Playchat

La comunicazione tra l'app e il servlet si articola in tre parti:

  • Quando un nuovo utente accede a Playchat, l'app richiede un servlet di logging per l'utente aggiungendo una voce in /inbox/ in Firebase Realtime Database.

  • Uno dei servlet accetta l'assegnazione aggiornando il valore della voce al suo identificatore di servlet. Il servlet utilizza una transazione Firebase per garantire che sia l'unico in grado di aggiornare il valore. Una volta aggiornato il valore, tutti gli altri servlet ignorano la richiesta.

  • Quando l'utente accede, si disconnette o modifica in un nuovo canale, Playchat registra l'azione in /inbox/[SERVLET_ID]/[USER_ID]/, dove [SERVLET_ID] è l'identificatore dell'istanza servlet e [USER_ID] è un valore hash che rappresenta l'utente.

  • Il servlet controlla la posta in arrivo delle nuove voci e raccoglie i dati del log.

In questa app di esempio, i servlet copiano localmente i dati di log e li visualizzano in una pagina web. In una versione di produzione di questa app, i servlet possono elaborare i dati di log o copiarli in Cloud Storage, Cloud Bigtable o BigQuery per archiviarli e analizzarli.

Obiettivi

Questo tutorial illustra come:

  • Creare un'app per iOS, Playchat, per archiviare i dati nel Firebase Realtime Database.

  • Esegui un servlet Java nell'ambiente flessibile di App Engine che si connette a Firebase e riceve notifiche quando i dati archiviati in Firebase cambiano.

  • Utilizza questi due componenti per creare un servizio distribuito, in modalità flusso e backend, per raccogliere ed elaborare i dati di log.

Costi

Firebase offre un livello di utilizzo gratuito. Se il tuo utilizzo di questi servizi è inferiore ai limiti specificati nel piano gratuito di Firebase, non ti viene addebitato alcun costo per l'utilizzo di Firebase.

Alle istanze all'interno dell'ambiente flessibile di App Engine viene addebitato il costo delle macchine virtuali Compute Engine sottostanti.

Prima di iniziare

Installa il seguente software:

Installa il componente Java di App Engine dell'interfaccia a riga di comando gcloud eseguendo il comando seguente in una finestra Terminale.

gcloud components install app-engine-java

Clonazione del codice campione

  1. Clonare il codice dell'app client.

    git clone https://github.com/GoogleCloudPlatform/firebase-ios-samples
    
  2. Clona il codice del servlet di backend.

    git clone https://github.com/GoogleCloudPlatform/firebase-appengine-backend
    

Creazione di un progetto Firebase

  1. Crea un account Firebase o accedi a un account esistente.

  2. Fai clic su Aggiungi progetto.

  3. In Nome progetto, inserisci: Playchat. Prendi nota dell'ID progetto assegnato al progetto, perché viene utilizzato in più passaggi di questo tutorial.

  4. Segui i passaggi di configurazione rimanenti e fai clic su Crea progetto.

  5. Dopo che la procedura guidata ha eseguito il provisioning del progetto, fai clic su Continua.

  6. Nella pagina Panoramica del progetto, fai clic sull'icona a forma di ingranaggio Impostazioni e poi su Impostazioni progetto.

  7. Fai clic su Aggiungi Firebase alla tua app per iOS.

  8. In ID bundle iOS, inserisci: com.google.cloud.solutions.flexenv.PlayChat.

  9. Fai clic su Registra app.

  10. Segui i passaggi nella sezione Scarica il file di configurazione per aggiungere il file GoogleService-Info.plist alla cartella PlayChat nel progetto.

  11. Fai clic su Avanti nella sezione Scarica il file di configurazione.

  12. Prendi nota delle istruzioni su come utilizzare CocoaPods per installare e gestire le dipendenze del progetto. Il gestore delle dipendenze CocoaPods è già configurato nel codice di esempio.

  13. Esegui il comando seguente per installare le dipendenze. Il comando potrebbe richiedere molto tempo.

    pod install
    

    Se l'installazione di CocoaPods non riesce a trovare la dipendenza Firebase, potrebbe essere necessario eseguire pod repo update.

    Dopo questo passaggio, utilizza il file .xcworkspace appena creato anziché il file .xcodeproj per lo sviluppo futuro nell'app per iOS.

  14. Fai clic su Avanti nella sezione Aggiungi SDK Firebase.

  15. Prendi nota del codice necessario per inizializzare Firebase nel progetto.

  16. Fai clic su Avanti nella sezione Aggiungi il codice di inizializzazione.

  17. Fai clic su Ignora questo passaggio nella sezione Esegui l'app per verificare l'installazione.

Creazione di un Realtime Database

  1. Dalla Console Firebase, seleziona il tuo progetto.

  2. Nel menu a sinistra della console, seleziona Realtime Database nel gruppo Build.

  3. Fai clic su Create database (Crea database) nella sezione Realtime Database.

  4. Seleziona una sede nelle vicinanze.

  5. Nella finestra di dialogo Regole di sicurezza, seleziona Avvia in modalità test e fai clic su Attiva.

    Questo passaggio mostra i dati archiviati in Firebase. Nei passaggi successivi di questo tutorial, puoi visitare nuovamente questa pagina web per visualizzare i dati aggiunti e aggiornati dall'app client e dal servlet di backend.

  6. Nella scheda Regole del database, assicurati di avere le regole di sicurezza per la lettura/scrittura che specificano una data futura di 30 giorni con l'unità di tempo definita nel tempo Unix. Ad esempio, se crei la regola il 4 agosto, la regola scadrà dopo il 4 settembre:

    {
      "rules": {
        ".read": "now < 1659639249000", //2022-08-04
        ".write": "now < 1659639249000" //2022-08-04
      }
    }
    
  7. Prendi nota dell'URL Firebase del tuo progetto, nel formato https://[FIREBASE_PROJECT_ID].firebaseio.com/ e visualizzato accanto a un'icona link.

Abilitazione di Google Authentication per il progetto Firebase

Esistono diversi provider di accesso che puoi configurare per connetterti al tuo progetto Firebase. Questo tutorial illustra la configurazione dell'autenticazione in modo che l'utente possa accedere con un Account Google.

  1. Nel menu a sinistra della Console Firebase, fai clic su Autenticazione nel gruppo Build.

  2. Fai clic su Configura il metodo di accesso o su Inizia se è la prima volta che accedi alla pagina.

  3. Nella scheda Metodo di accesso, seleziona Google, attiva l'opzione Attiva, seleziona l'email dell'assistenza e fai clic su Salva.

Aggiunta di un account di servizio al progetto Firebase

Il servlet di backend non utilizza un Account Google per accedere. ma utilizza un account di servizio per connettersi a Firebase. I seguenti passaggi spiegano come creare un account di servizio che possa connettersi a Firebase e aggiungere le credenziali dell'account di servizio al codice del servlet.

  1. Nel menu a sinistra della Console Firebase, accanto alla home page del progetto Playchat, seleziona l'ingranaggio Impostazioni e poi Impostazioni progetto.

  2. Seleziona la scheda Account di servizio, quindi fai clic sul link Gestisci autorizzazioni degli account di servizio.

  3. Fai clic su Crea account di servizio.

  4. Configura le seguenti impostazioni:

    1. In Nome account di servizio, inserisci playchat-servlet, quindi fai clic su Crea e continua.
    2. In Seleziona un ruolo, seleziona Progetto > Proprietario, quindi fai clic su Continua.

    3. Fai clic su Fine.

  5. Fai clic sull'account di servizio che hai appena creato, nella scheda CHIAVE, fai clic su Aggiungi chiave, quindi fai clic su Crea nuova chiave.

  6. Accanto a Tipo di chiave, fai clic su JSON, quindi su Crea per scaricare la chiave.

  7. Salva il file della chiave JSON scaricato per l'account di servizio nel progetto di servizio di backend firebase-appengine-backend nella directory src/main/webapp/WEB-INF/. Il nome file è nel formato Playchat-[UNIQUE_ID].json.

  8. Modifica src/main/webapp/WEB-INF/web.xml e modifica i parametri di inizializzazione come segue:

    • Sostituisci JSON_FILE_NAME con il nome del file della chiave JSON che hai scaricato.

    • Sostituisci FIREBASE_URL con l'URL Firebase annotato in precedenza.

      <init-param>
        <param-name>credential</param-name>
        <param-value>/WEB-INF/JSON_FILE_NAME</param-value>
      </init-param>
      <init-param>
        <param-name>databaseUrl</param-name>
        <param-value>FIREBASE_URL</param-value>
      </init-param>
      

Abilitazione di fatturazione e API per il progetto Google Cloud

Per eseguire il servizio di backend su GCP, devi abilitare la fatturazione e le API per il progetto. Il progetto Cloud è lo stesso che hai creato in Creazione di un progetto Firebase e ha lo stesso identificatore di progetto.

  1. In Google Cloud Console, seleziona il progetto Playchat.

    Vai alla pagina Progetti

  2. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  3. Abilita le API App Engine Admin and Compute Engine.

    Abilita le API

Creazione e deployment del servizio di backend

Il servizio di backend in questo esempio utilizza una configurazione Docker per specificare l'ambiente di hosting. Questa personalizzazione significa che devi utilizzare l'ambiente flessibile di App Engine anziché l'ambiente standard di App Engine.

Per creare il servlet di backend e eseguirne il deployment nell'ambiente flessibile di App Engine, puoi utilizzare il plug-in Maven di Google App Engine. Questo plug-in è già specificato nel file di build Maven incluso in questo esempio.

Impostazione del progetto

Affinché Maven crei correttamente il servlet di backend, devi fornirlo nel progetto Google Cloud Platform (GCP) in cui lanciare le risorse del servlet. L'identificatore del progetto GCP e l'identificatore del progetto Firebase sono gli stessi.

  1. Fornisci le credenziali utilizzate dall'interfaccia a riga di comando gcloud per accedere a GCP.

    gcloud auth login
    
  2. Imposta il progetto sul progetto Firebase con il comando seguente, sostituendo [FIREBASE_PROJECT_ID] con il nome dell'ID progetto Firebase annotato in precedenza.

    gcloud config set project [FIREBASE_PROJECT_ID]
    
  3. Verifica che il progetto sia stato impostato elencando la configurazione.

    gcloud config list
    
  4. Se è la prima volta che utilizzi App Engine, inizializza la tua app App Engine:

    gcloud app create
    

(Facoltativo) Esecuzione del servizio sul server locale

Quando sviluppi un nuovo servizio di backend, eseguilo in locale prima di eseguirne il deployment in App Engine per eseguire rapidamente l'iterazione delle modifiche senza l'overhead di un deployment completo in App Engine.

Quando lo esegui localmente, il server non utilizza una configurazione Docker o un ambiente App Engine. Invece, Maven garantisce che tutte le librerie dipendenti siano installate localmente e l'app venga eseguita sul server web Jetty.

  1. Nella directory firebase-appengine-backend, crea ed esegui localmente il modulo di backend con il comando seguente:

    mvn clean package appengine:run
    

    Se hai installato l'interfaccia a riga di comando di Google Cloud in una directory diversa da ~/google-cloud-sdk, aggiungi il percorso di installazione al comando come mostrato di seguito, sostituendo [PATH_TO_TOOL] con il tuo percorso personalizzato.

    mvn clean package appengine:run -Dgcloud.gcloud_directory=[PATH_TO_TOOL]
    
  2. Se ti viene richiesto, Vuoi che l'applicazione "Python.app" accetti le connessioni di rete in entrata?, seleziona Consenti.

Al termine del deployment, apri http://localhost:8080/printLogs per verificare che il servizio di backend sia in esecuzione. Nella pagina web viene visualizzato Inbox : seguito da un identificatore di 16 cifre. Si tratta dell'identificatore della posta in arrivo del servlet in esecuzione sulla tua macchina locale.

Quando aggiorni la pagina, l'identificatore non cambia, il server locale avvia una singola istanza servlet. Questo è utile per i test, in quanto nel Firebase Realtime Database è archiviato un solo identificatore di servlet.

Per chiudere il server locale, premi Ctrl + C.

Deployment del servizio nell'ambiente flessibile di App Engine

Quando esegui il servizio di backend nell'ambiente flessibile di App Engine, App Engine utilizza la configurazione in /firebase-appengine-backend/src/main/webapp/Dockerfiles per creare l'ambiente di hosting in cui viene eseguito il servizio. L'ambiente flessibile espande diverse istanze di servlet e le fa lo scale up e lo scale down per soddisfare la domanda.

  • Nella directory firebase-appengine-backend, crea ed esegui localmente il modulo di backend con il comando seguente:

    mvn clean package appengine:deploy
    
    mvn clean package appengine:deploy -Dgcloud.gcloud_directory=[PATH_TO_GCLOUD]
    

Durante l'esecuzione della build, vengono visualizzate le righe "Invio del contesto della build a daemon Docker...". Il comando precedente carica la configurazione Docker e la configura nell'ambiente flessibile di App Engine.

Al termine del deployment, apri https://[FIREBASE_PROJECT_ID].appspot.com/printLogs, dove [FIREBASE_PROJECT_ID] è l'identificatore di Creare un progetto Firebase. La pagina web in cui è visualizzata la voce Posta in arrivo seguita da un identificatore di 16 cifre. Questo è l'identificatore della casella di posta di un servlet in esecuzione nell'ambiente flessibile di App Engine.

Quando aggiorni la pagina, questo identificatore cambia periodicamente man mano che App Engine sputa più istanze di servlet per gestire le richieste del client in arrivo.

Aggiornare lo schema dell'URL nell'esempio di iOS

  1. In Xcode, con l'area di lavoro PlayChat aperta, apri la cartella PlayChat.

  2. Apri GoogleService-Info.plist e copia il valore della variabile REVERSED_CLIENT_ID.

  3. Apri Info.plist e vai ai tipi di URL chiave > Elemento 0 (Editor) > Schemi di URL > Elemento 0.

  4. Sostituisci il valore segnaposto, [REVERSED_CLIENT_ID], con il valore copiato da GoogleService-Info.plist.

Esecuzione e test dell'app per iOS

  1. In Xcode, con l'area di lavoro PlayChat aperta, seleziona Prodotto > Esegui.

  2. Quando l'app viene caricata nel simulatore, accedi con il tuo Account Google.

    Accedi a Playchat

  3. Seleziona il canale Libri.

  4. Inserisci un messaggio.

    Inviare un messaggio

Quando lo fai, l'app Playchat archivia il tuo messaggio nel Firebase Realtime Database. Firebase sincronizza i dati archiviati nel database tra i dispositivi. I dispositivi che eseguono PlayChat mostrano il nuovo messaggio quando un utente seleziona il canale libri.

Inviare un messaggio

Verificare i dati

Dopo aver utilizzato l'app Playchat per generare alcuni eventi utente mediante l'app, puoi verificare che i servlet si registrino come ascoltatori e raccoglino i log degli eventi utente.

Apri il Firebase Realtime Database per la tua app, dove [FIREBASE_PROJECT_ID] è l'identificatore di Crea un progetto Firebase.

https://console.firebase.google.com/project/[FIREBASE_PROJECT_ID]/database/data

Nella parte inferiore del Firebase Realtime Database, sotto la località dei dati di /inbox/, è presente un gruppo di nodi con il prefisso client- seguito da una chiave generata in modo casuale che rappresenta l'accesso di un utente. L'ultima voce in questo esempio, client-1240563753, è seguita da un identificatore a 16 cifre del servlet che attualmente ascolta gli eventi di log dell'utente in questo esempio 0035806813827987.

Dati archiviati in Firebase Realtime Database

Subito sopra, sotto la località dei dati /inbox/, si trovano gli identificatori dei servlet per tutti i servlet attualmente assegnati. In questo esempio, solo un servlet sta raccogliendo i log. In /inbox/[SERVLET_IDENTIFIER] sono elencati i log utente scritti dall'app nel servlet.

Apri la pagina App Engine per il tuo servizio di backend in https://[FIREBASE_PROJECT_ID].appspot.com/printLogs, dove [FIREBASE_PROJECT_ID] è l'identificatore da Creare un progetto Firebase. La pagina mostra l'identificatore del servlet che ha registrato gli eventi utente generati. Puoi anche vedere le voci di log per tali eventi sotto l'identificatore Posta in arrivo del servlet.

Esplorazione del codice

L'app Playchat per iOS definisce una classe, FirebaseLogger, che utilizza per scrivere log eventi utente nel Firebase Realtime Database.

import Firebase

class FirebaseLogger {
  var logRef: DatabaseReference!

  init(ref: DatabaseReference!, path: String!) {
    logRef = ref.child(path)
  }

  func log(_ tag: String!, message: String!) {
    let entry: LogEntry = LogEntry(tag: tag, log: message)
    logRef.childByAutoId().setValue(entry.toDictionary())
  }
}

Quando un nuovo utente esegue l'accesso, Playchat chiama la funzione requestLogger per aggiungere una nuova voce alla posizione /requestLogger/ del Firebase Realtime Database e impostare un listener in modo che Playchat possa rispondere quando un servlet aggiorna il valore di quella voce, accettando l'assegnazione.

Quando un servlet aggiorna il valore, PlayChat rimuove il listener e scrive il log "Accesso eseguito" nella posta in arrivo del servlet.

func requestLogger() {
  ref.child(IBX + "/" + inbox!).removeValue()
  ref.child(IBX + "/" + inbox!)
    .observe(.value, with: { snapshot in
      print(self.inbox!)
      if snapshot.exists() {
        self.fbLog = FirebaseLogger(ref: self.ref, path: self.IBX + "/"
          + String(describing: snapshot.value!) + "/logs")
        self.ref.child(self.IBX + "/" + self.inbox!).removeAllObservers()
        self.msgViewController!.fbLog = self.fbLog
        self.fbLog!.log(self.inbox, message: "Signed in")
      }
    })
  ref.child(REQLOG).childByAutoId().setValue(inbox)
}

Sul lato servizio di backend, quando inizia un'istanza di servlet, la funzione init(ServletConfig config) in MessageProcessorServlet.java si connette al Firebase Realtime Database e aggiunge un listener alla località dei dati /inbox/.

Quando viene aggiunta una nuova voce alla località dei dati /inbox/, il servlet aggiorna il valore con il proprio identificatore, indicando all'app Playchat che il servlet accetta l'assegnazione per elaborare i log dell'utente. Il servlet utilizza le transazioni Firebase per garantire che solo un servlet possa aggiornare il valore e accettare l'assegnazione.

/*
 * Receive a request from a client and reply back its inbox ID.
 * Using a transaction ensures that only a single servlet instance replies
 * to the client. This lets the client know to which servlet instance
 * send consecutive user event logs.
 */
firebase.child(REQLOG).addChildEventListener(new ChildEventListener() {
  public void onChildAdded(DataSnapshot snapshot, String prevKey) {
    firebase.child(IBX + "/" + snapshot.getValue()).runTransaction(new Transaction.Handler() {
      public Transaction.Result doTransaction(MutableData currentData) {
        // Only the first servlet instance writes its ID to the client inbox.
        if (currentData.getValue() == null) {
          currentData.setValue(inbox);
        }
        return Transaction.success(currentData);
      }

      public void onComplete(DatabaseError error, boolean committed, DataSnapshot snapshot) {}
    });
    firebase.child(REQLOG).removeValue();
  }
  // ...
});

Dopo che un servlet ha accettato un'assegnazione per elaborare i log eventi di un utente, aggiunge un listener che rileva quando l'app Playchat scrive un nuovo file di log nella casella di posta del servlet. Il servlet risponde recuperando i nuovi dati di log da Firebase Realtime Database.

/*
 * Initialize user event logger. This is just a sample implementation to
 * demonstrate receiving updates. A production version of this app should
 * transform, filter, or load to another data store such as Google BigQuery.
 */
private void initLogger() {
  String loggerKey = IBX + "/" + inbox + "/logs";
  purger.registerBranch(loggerKey);
  firebase.child(loggerKey).addChildEventListener(new ChildEventListener() {
    public void onChildAdded(DataSnapshot snapshot, String prevKey) {
      if (snapshot.exists()) {
        LogEntry entry = snapshot.getValue(LogEntry.class);
        logs.add(entry);
      }
    }

    public void onCancelled(DatabaseError error) {
      localLog.warning(error.getDetails());
    }

    public void onChildChanged(DataSnapshot arg0, String arg1) {}

    public void onChildMoved(DataSnapshot arg0, String arg1) {}

    public void onChildRemoved(DataSnapshot arg0) {}
  });
}

Esegui la pulizia

Per evitare che al tuo account Google Cloud Platform vengano addebitati costi per le risorse utilizzate in questo tutorial:

Elimina il progetto Google Cloud Platform e Firebase

Il modo più semplice per interrompere gli addebiti è eliminare il progetto che hai creato per questo tutorial. Anche se hai creato il progetto nella Console Firebase, puoi eliminarlo anche in Cloud Console, poiché i progetti Firebase e Cloud sono gli stessi.

  1. In Cloud Console, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto da eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Elimina le versioni non predefinite della tua app App Engine

Se non vuoi eliminare il progetto GCP e Firebase, puoi ridurre i costi eliminando le versioni non predefinite dell'app per l'ambiente flessibile di App Engine.

  1. In Cloud Console, vai alla pagina Versioni di App Engine.

    Vai a Versioni

  2. Seleziona la casella di controllo relativa alla versione predefinita dell'app da eliminare.
  3. Per eliminare la versione dell'app, fai clic su Elimina.

Passaggi successivi

  • Analisi e archiviazione dei dati: in questo esempio, i servlet archiviano i dati del log soltanto in memoria. Per estendere questo campione, puoi far sì che i servlet archivino, trasformino e analizzino i dati utilizzando servizi come Cloud Storage, Cloud Bigtable, Google Cloud Dataflow e BigQuery.

  • Distribuzione uniforme del carico di lavoro tra i servlet: App Engine offre scalabilità automatica e manuale. Con la scalabilità automatica, l'ambiente flessibile rileva le modifiche al carico di lavoro e risponde aggiungendo o rimuovendo istanze VM nel cluster. Con la scalabilità manuale, devi specificare un numero statico di istanze per gestire il traffico. Per ulteriori informazioni su come configurare la scalabilità, consulta le impostazioni di scalabilità dei servizi nella documentazione di App Engine.

    Poiché i log delle attività degli utenti vengono assegnati ai servlet mediante l'accesso a Firebase Realtime Database, il carico di lavoro potrebbe non essere distribuito in modo uniforme. Ad esempio, un servlet potrebbe elaborare più log eventi utente rispetto ad altri.

    Puoi migliorare l'efficienza implementando un gestore dei carichi di lavoro che controlla in modo indipendente il carico di lavoro su ciascuna VM. Questo bilanciamento del carico di lavoro potrebbe essere basato su metriche come richieste di logging al secondo o numero di client simultanei.

  • Recupera i log degli eventi utente non elaborati: in questa implementazione di esempio, se un'istanza di servlet si arresta in modo anomalo, l'app client associata a tale istanza continua a inviare gli eventi di log alla posta in arrivo del servlet in Firebase Realtime Database. In una versione di produzione di questa app, il servizio di backend deve rilevare questa situazione per recuperare i log di eventi utente non elaborati.

  • Implementa funzionalità aggiuntive utilizzando i prodotti Cloud AI: scopri come fornire funzionalità basate su ML con prodotti e servizi Cloud AI. Ad esempio, puoi estendere questa implementazione di esempio per fornire una funzionalità di traduzione vocale utilizzando una combinazione delle API Speech-to-Text, Traslazione e Text-to-Speech. Per ulteriori informazioni, consulta la sezione Aggiungere la traduzione del parlato all'app Android.