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

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

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 nell'ambiente flessibile di App Engine ascoltano i nuovi log utente archiviati in Firebase ed 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 la sincronizzazione automatica dei dati in tempo reale.

L'app di esempio, Playchat, archivia i messaggi di chat nel Firebase Realtime Database, che sincronizza automaticamente tali dati tra i dispositivi. Playchat scrive anche i log eventi utente in Firebase. Per scoprire di più su come il database sincronizza i dati, consulta 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 degli eventi utente e 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 Playchat

La comunicazione tra l'app e il servlet si compone di tre parti:

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

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

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

  • Il servlet controlla le caselle di posta in arrivo per le nuove voci e raccoglie i dati del log.

In questa app di esempio, i servlet copiano i dati del log in locale 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 l'archiviazione e l'analisi.

Obiettivi

Questo tutorial illustra come:

  • Crea un'app per iOS, PlayChat, per archiviare i dati nel Firebase Realtime Database.

  • Eseguire 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 di backend distribuito, distribuito e per raccogliere ed elaborare i dati di log.

Costi

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

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

Prima di iniziare

Installa il software seguente:

Installa il componente Java di App Engine dell'interfaccia a riga di comando gcloud eseguendo il comando seguente in una finestra del 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
    

Crea 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, che verrà utilizzato in più passaggi di questo tutorial.

  4. Segui i passaggi rimanenti per la configurazione 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, 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 del progetto.

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

  12. Prendi nota delle istruzioni per 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 completamento del comando potrebbe richiedere molto tempo.

    pod install
    

    Potrebbe essere necessario eseguire pod repo update se l'installazione di CocoaPods non riesce a trovare la dipendenza di Firebase.

    Dopo questo passaggio, utilizza il file .xcworkspace appena creato al posto del file .xcodeproj per tutti gli sviluppi futuri dell'app 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 Crea database nella sezione Database in tempo reale.

  4. Seleziona una sede vicino a te.

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

    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 di Unix in tempo reale. Ad esempio, se crei la regola il 4 agosto, la regola dovrebbe scadere dopo il 4 settembre:

    {
      "rules": {
        ".read": "now < 1659639249000", //2022-08-04
        ".write": "now < 1659639249000" //2022-08-04
      }
    }
    
  7. Prendi nota dell'URL Firebase per il tuo progetto, che è nel formato https://[FIREBASE_PROJECT_ID].firebaseio.com/ e compare accanto a un'icona di collegamento.

Abilitazione dell'autenticazione Google per il progetto Firebase in corso...

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 utilizzando 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 il pulsante di attivazione/disattivazione 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 l'accesso. Utilizza invece un account di servizio per connettersi a Firebase. I passaggi seguenti spiegano come creare un account di servizio in grado di 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 e fai clic sul link Gestisci autorizzazioni dell'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 appena creato, nella scheda Chiavi, quindi su Aggiungi chiave e infine su Crea nuova chiave.

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

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

  8. Modifica src/main/webapp/WEB-INF/web.xml e modifica i parametri di inizializzazione nel seguente modo:

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

    • Sostituisci FIREBASE_URL con l'URL Firebase indicato 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 della fatturazione e delle API per il progetto Google Cloud

Per eseguire il servizio di backend su GCP, devi abilitare le API e la fatturazione per il progetto. Il progetto cloud è lo stesso progetto che hai creato in Creare 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 ed eseguirne il deployment nell'ambiente flessibile di App Engine, puoi utilizzare il plug-in Google App Engine Maven. Questo plug-in è già specificato nel file di build Maven incluso in questo esempio.

Impostazione del progetto

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

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

    gcloud auth login
    
  2. Imposta il progetto nel 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 iterare rapidamente le modifiche senza il sovraccarico di un deployment completo in App Engine.

Quando esegui il server in locale, non viene utilizzata una configurazione Docker né eseguita in 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 il modulo di backend in locale con il seguente comando:

    mvn clean package appengine:run
    

    Se hai installato Google Cloud CLI 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 chiesto Vuoi che l'applicazione "Python.app" accetti le connessioni di rete in arrivo?, 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 visualizzata la dicitura Posta in arrivo : seguita 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, questo identificatore non cambia; il tuo server locale avvia una singola istanza di servlet. Questo è utile per eseguire test, perché nel Firebase Realtime Database è presente un solo identificatore di servlet.

Per arrestare 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 aggiunge diverse istanze di servlet e ne fa lo scale up e lo scale down per soddisfare la domanda.

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

    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 al daemon Docker in corso..." 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 da Creare un progetto Firebase. La pagina web che mostra Posta in arrivo : seguita da un identificatore di 16 cifre. Questo è l'identificatore della posta in arrivo di un servlet in esecuzione nell'ambiente flessibile di App Engine.

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

Aggiornamento dello 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 di REVERSED_CLIENT_ID.

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

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

Esecuzione e test dell'app per iOS

  1. In Xcode, con l'area di lavoro PlayChat aperta, seleziona Product > Run (Esegui).

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

    Accedere a PlayChat

  3. Seleziona il canale Libri.

  4. Inserisci un messaggio.

    Inviare un messaggio

Quando lo fai, l'app Playchat archivia il tuo messaggio in Firebase Realtime Database. Firebase sincronizza i dati archiviati nel database tra i dispositivi. I dispositivi su cui è installata la riproduzione di Chat 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 utilizzando l'app Playchat, puoi verificare che i servlet si stiano registrando come ascoltatori e stiano raccogliendo i log degli eventi utente.

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

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

Nella parte inferiore di Firebase Realtime Database, sotto la località dei dati /inbox/, è presente un gruppo di nodi preceduti da client- e seguiti da una chiave generata casualmente che rappresenta l'accesso di un utente. L'ultima voce di questo esempio, client-1240563753, è seguita da un identificatore a 16 cifre del servlet che sta ascoltando gli eventi di log dell'utente in questo esempio 0035806813827987.

Dati archiviati in Firebase Realtime Database

Subito sopra, nella posizione dei dati /inbox/, si trovano gli identificatori dei servlet per tutti i servlet attualmente assegnati. In questo esempio, un solo servlet sta raccogliendo i log. In /inbox/[SERVLET_IDENTIFIER] sono riportati i log utente scritti dall'app per quel servlet.

Apri la pagina App Engine per il tuo servizio di backend all'indirizzo https://[FIREBASE_PROJECT_ID].appspot.com/printLogs, dove [FIREBASE_PROJECT_ID] è l'identificatore da Creare un progetto Firebase. Nella pagina viene visualizzato l'identificatore del servlet che ha registrato gli eventi utente generati. Puoi anche vedere le voci di log per questi 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 i log degli 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 accede, Playchat chiama la funzione requestLogger per aggiungere una nuova voce alla località /requestLogger/ in Firebase Realtime Database e impostare un listener per consentire a Playchat di rispondere quando un servlet aggiorna il valore di tale voce, accettando l'assegnazione.

Quando un servlet aggiorna il valore, Playchat rimuove il listener e scrive il log "Signed" 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, all'avvio di un'istanza di servlet, la funzione init(ServletConfig config) in MessageProcessorServlet.java si connette a 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, un indicatore per l'app Playchat che indica che il servlet accetta l'assegnazione per elaborare i log per l'utente in questione. 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 posta in arrivo 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 relativi alle 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 nella Console Google Cloud, perché i progetti Firebase e Cloud sono uguali.

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

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi 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.

Eliminare versioni non predefinite dell'applicazione 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 Google Cloud Console, vai alla pagina Versioni di App Engine.

    Vai a Versioni

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

Passaggi successivi

  • Analizza e archivia i dati: in questo esempio, i servlet archiviano i dati di log solo in memoria. Per estendere questo campione, puoi fare in modo che i servlet archivino, trasformino e analizzino i dati, utilizzando servizi come Cloud Storage, Cloud Bigtable, Google Cloud Dataflow e BigQuery.

  • Distribuisci in modo uniforme il carico di lavoro tra i servlet: App Engine offre la scalabilità sia automatica che manuale. Con la scalabilità automatica, l'ambiente flessibile rileva le modifiche al carico di lavoro e risponde aggiungendo o rimuovendo le istanze VM nel cluster. Con la scalabilità manuale, specifichi un numero statico di istanze per gestire il traffico. Per ulteriori informazioni su come configurare la scalabilità, consulta le impostazioni di scalabilità del servizio 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 uniformemente. Ad esempio, un servlet potrebbe elaborare più log eventi-utente rispetto ad altri servlet.

    Puoi migliorare l'efficienza implementando un gestore dei carichi di lavoro che controlla in modo indipendente il carico di lavoro su ogni 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 eventi di log alla posta in arrivo del servlet nel Firebase Realtime Database. In una versione di produzione di questa app, il servizio di backend deve rilevare questa situazione per recuperare i log degli eventi utente non elaborati.

  • Implementa funzionalità aggiuntive utilizzando i prodotti Cloud AI: scopri come fornire funzionalità basate su ML con i prodotti e i 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, Traduzione e Text-to-Speech. Per ulteriori informazioni, consulta la pagina Aggiungere la traduzione del parlato alla tua app Android.