Firebase Android Codelab - Crea chat amichevole

immagine dello schermo

Immagine: app di chat amichevole funzionante.

Benvenuto nel codelab della chat amichevole. In questo codelab imparerai come utilizzare la piattaforma Firebase per creare un'app di chat su Android.

Cosa imparerai

  • Come utilizzare l'autenticazione Firebase per consentire agli utenti di accedere.
  • Come sincronizzare i dati utilizzando il database Firebase Realtime.
  • Come archiviare file binari in Cloud Storage per Firebase.
  • Come utilizzare Firebase Local Emulator Suite per sviluppare un'app Android con Firebase.

Di cosa avrai bisogno

  • Android Studio versione 4.2+.
  • Un emulatore Android con Android 5.0+.
  • Java 7 o versioni successive. Per installare Java utilizzare queste istruzioni ; per controllare la versione, eseguire java -version .
  • Familiarità con il linguaggio di programmazione Kotlin.

Clona il repository

Clona il repository GitHub dalla riga di comando:

$ git clone https://github.com/firebase/codelab-friendlychat-android

Importa in Android Studio

In Android Studio, selezionare File> Apri, quindi selezionare l' build-android-start directory ( android_studio_folder ) dalla directory in cui hai scaricato il codice di esempio.

Ora si dovrebbe avere la build-android-start progetto open in Android Studio. Se vedi un avviso su un google-services.json file mancante, non ti preoccupare. Verrà aggiunto in un passaggio successivo.

Controlla le dipendenze

In questo codelab tutte le dipendenze di cui avrai bisogno sono già state aggiunte per te, ma è importante capire come aggiungere l'SDK Firebase alla tua app:

build.gradle

buildscript {
    // ...

    dependencies {
        classpath 'com.android.tools.build:gradle:4.1.2'

        // The google-services plugin is required to parse the google-services.json file
        classpath 'com.google.gms:google-services:4.3.5'
    }
}

app/build.gradle

plugins {
    id 'com.android.application'
    id 'kotlin-android'
    id 'com.google.gms.google-services'
}

android {
    // ...
}

dependencies {
    // ...

    // Google Sign In SDK
    implementation 'com.google.android.gms:play-services-auth:19.0.0'

    // Firebase SDK
    implementation platform('com.google.firebase:firebase-bom:26.6.0')
    implementation 'com.google.firebase:firebase-database-ktx'
    implementation 'com.google.firebase:firebase-storage-ktx'
    implementation 'com.google.firebase:firebase-auth-ktx'

    // Firebase UI Library
    implementation 'com.firebaseui:firebase-ui-auth:7.2.0'
    implementation 'com.firebaseui:firebase-ui-database:7.2.0'
}

Al fine di eseguire la Firebase emulatore Suite , è necessario installare e utilizzare il Firebase CLI .

Installa il CLI

Opzione 1 - Installa con npm

Se hai già Node.js e npm installati sulla tua macchina, puoi installare la CLI con il seguente comando:

npm install -g firebase-tools@latest

Opzione 2 - Installa binario autonomo

Se non si dispone di Node.js / NPM o sei un nuovo sviluppo di app, è possibile installare la CLI come un binario autonomo seguendo le istruzioni per la piattaforma qui .

Controllare l'installazione

Una volta che avete installato il Firebase CLI, eseguire il seguente comando per assicurarsi di avere la versione 9.11.0 o superiore:

firebase --version

Avvia gli emulatori

Nel vostro terminale, eseguire il seguente comando dalla radice del vostro locale codelab-friendlychat-android directory:

firebase emulators:start --project=demo-friendlychat-android

Dovresti vedere alcuni log come questo. I valori della porta sono stati definiti nel firebase.json file, che è stato incluso nel codice di esempio clonato.

$ firebase emulators:start --project=demo-friendlychat-android
i  emulators: Starting emulators: auth, database, storage
i  emulators: Detected demo project ID "demo-friendlychat-android", emulated services will use a demo configuration and attempts to access non-emulated services for this project will fail.
i  database: Database Emulator logging to database-debug.log
i  ui: Emulator UI logging to ui-debug.log

┌─────────────────────────────────────────────────────────────┐
│ ✔  All emulators ready! It is now safe to connect your app. │
│ i  View Emulator UI at http://localhost:4000                │
└─────────────────────────────────────────────────────────────┘

┌────────────────┬────────────────┬────────────────────────────────┐
│ Emulator       │ Host:Port      │ View in Emulator UI            │
├────────────────┼────────────────┼────────────────────────────────┤
│ Authentication │ localhost:9099 │ http://localhost:4000/auth     │
├────────────────┼────────────────┼────────────────────────────────┤
│ Database       │ localhost:9000 │ http://localhost:4000/database │
├────────────────┼────────────────┼────────────────────────────────┤
│ Storage        │ localhost:9199 │ http://localhost:4000/storage  │
└────────────────┴────────────────┴────────────────────────────────┘
  Emulator Hub running at localhost:4400
  Other reserved ports: 4500

Issues? Report them at https://github.com/firebase/firebase-tools/issues and attach the *-debug.log files.

Passare a http: // localhost: 4000 nel browser web per visualizzare l'emulatore Firebase Suite UI:

Emulatore Suite UI home

Lasciare le emulators:start il comando corsa per il resto del codelab.

Connetti la tua app

In Android Studio, aperto MainActivity.kt , quindi aggiungere il seguente codice all'interno del onCreate metodo:

// When running in debug mode, connect to the Firebase Emulator Suite.
// "10.0.2.2" is a special IP address which allows the Android Emulator
// to connect to "localhost" on the host computer. The port values (9xxx)
// must match the values defined in the firebase.json file.
if (BuildConfig.DEBUG) {
    Firebase.database.useEmulator("10.0.2.2", 9000)
    Firebase.auth.useEmulator("10.0.2.2", 9099)
    Firebase.storage.useEmulator("10.0.2.2", 9199)
}

Aggiungi google-services.json

Affinché la tua app Android per la connessione a Firebase, è necessario aggiungere un google-services.json di file all'interno della app cartella del progetto Android. Ai fini di questo codelab, abbiamo fornito un file JSON fittizio che ti consentirà di connetterti a Firebase Emulator Suite.

Copiare il mock-google-services.json file nella build-android-start/app cartella come google-services.json :

cp mock-google-services.json build-android-start/app/google-services.json

Nella fase finale di questo codelab, imparerai come creare un vero progetto Firebase e un'app Firebase Android in modo da poter sostituire questo file JSON fittizio con la tua configurazione.

Esegui l'app

Ora che hai importato il progetto in Android Studio e aggiunto un file JSON di configurazione di Firebase, sei pronto per eseguire l'app per la prima volta.

  1. Avvia il tuo emulatore Android.
  2. In Android Studio, fare clic su Esegui (eseguire ) nella barra degli strumenti.

L'app dovrebbe avviarsi sul tuo emulatore Android. A questo punto, dovresti vedere un elenco di messaggi vuoto e l'invio e la ricezione di messaggi non funzioneranno. Nel passaggio successivo di questo codelab, autenticherai gli utenti in modo che possano utilizzare la chat amichevole.

Questa app utilizzerà Firebase Realtime Database per archiviare tutti i messaggi di chat. Prima di aggiungere dati, tuttavia, dovremmo assicurarci che l'app sia sicura e che solo gli utenti autenticati possano pubblicare messaggi. In questo passaggio, abiliteremo l'autenticazione Firebase e configureremo le regole di sicurezza del database in tempo reale.

Aggiungi funzionalità di accesso di base

Successivamente, aggiungeremo all'app del codice di autenticazione Firebase di base per rilevare gli utenti e implementare una schermata di accesso.

Controlla l'utente corrente

In primo luogo aggiungere il seguente variabile di istanza al MainActivity.kt classe:

MainActivity.kt

// Firebase instance variables
private lateinit var auth: FirebaseAuth

Ora cerchiamo di modificare MainActivity per inviare l'utente alla schermata di accesso ogni volta che aprono l'applicazione e sono non autenticato. Aggiungere la seguente al onCreate() metodo dopo il binding è attaccato alla vista:

MainActivity.kt

// Initialize Firebase Auth and check if the user is signed in
auth = Firebase.auth
if (auth.currentUser == null) {
    // Not signed in, launch the Sign In activity
    startActivity(Intent(this, SignInActivity::class.java))
    finish()
    return
}

Vogliamo anche verificare se l'utente è firmato durante onStart() :

MainActivity.kt

public override fun onStart() {
    super.onStart()
    // Check if user is signed in.
    if (auth.currentUser == null) {
        // Not signed in, launch the Sign In activity
        startActivity(Intent(this, SignInActivity::class.java))
        finish()
        return
    }
}

Quindi implementare la getUserPhotoUrl() e getUserName() metodi per restituire le informazioni appropriate sull'utente Firebase attualmente autenticato:

MainActivity.kt

private fun getPhotoUrl(): String? {
    val user = auth.currentUser
    return user?.photoUrl?.toString()
}

private fun getUserName(): String? {
    val user = auth.currentUser
    return if (user != null) {
        user.displayName
    } else ANONYMOUS
}

Quindi implementare la signOut() metodo per gestire il segno pulsante di fuori:

MainActivity.kt

private fun signOut() {
    AuthUI.getInstance().signOut()
    startActivity(Intent(this, SignInActivity::class.java))
    finish()
}

Ora abbiamo tutta la logica in atto per inviare l'utente alla schermata di accesso quando necessario. Successivamente, dobbiamo implementare la schermata di accesso per autenticare correttamente gli utenti.

Implementa la schermata di accesso

Aprire il file SignInActivity.kt . Qui viene utilizzato un semplice pulsante di accesso per avviare l'autenticazione. In questa sezione utilizzerai FirebaseUI per implementare la logica di accesso.

Aggiungere una variabile di istanza Auth nel SignInActivity classe sotto la // Firebase instance variables commento:

SignInActivity.kt

// Firebase instance variables
private lateinit var auth: FirebaseAuth

Quindi, modificare onCreate() metodo per inizializzare Firebase nello stesso modo che hai fatto in MainActivity :

SignInActivity.kt

// Initialize FirebaseAuth
auth = Firebase.auth

Aggiungere un ActivityResultLauncher campo per SignInActivity :

SignInActivity.kt

// ADD THIS
private val signIn: ActivityResultLauncher<Intent> =
        registerForActivityResult(FirebaseAuthUIActivityResultContract(), this::onSignInResult)

override fun onCreate(savedInstanceState: Bundle?) {
    // ...
}

Avanti, modificare onStart() metodo per dare il via il segno FirebaseUI del flusso:

SignInActivity.kt

public override fun onStart() {
    super.onStart()

    // If there is no signed in user, launch FirebaseUI
    // Otherwise head to MainActivity
    if (Firebase.auth.currentUser == null) {
        // Sign in with FirebaseUI, see docs for more details:
        // https://firebase.google.com/docs/auth/android/firebaseui
        val signInIntent = AuthUI.getInstance()
                .createSignInIntentBuilder()
                .setLogo(R.mipmap.ic_launcher)
                .setAvailableProviders(listOf(
                        AuthUI.IdpConfig.EmailBuilder().build(),
                        AuthUI.IdpConfig.GoogleBuilder().build(),
                ))
                .build()

        signIn.launch(signInIntent)
    } else {
        goToMainActivity()
    }
}

Avanti, implementare il onSignInResult metodo per gestire il segno del risultato. Se il risultato del signin ha avuto successo, continuare a MainActivity :

SignInActivity.kt

private fun onSignInResult(result: FirebaseAuthUIAuthenticationResult) {
    if (result.resultCode == RESULT_OK) {
        Log.d(TAG, "Sign in successful!")
        goToMainActivity()
    } else {
        Toast.makeText(
                this,
                "There was an error signing in",
                Toast.LENGTH_LONG).show()

        val response = result.idpResponse
        if (response == null) {
            Log.w(TAG, "Sign in canceled")
        } else {
            Log.w(TAG, "Sign in error", response.error)
        }
    }
}

Questo è tutto! Hai implementato l'autenticazione con FirebaseUI in poche chiamate di metodo e senza dover gestire alcuna configurazione lato server.

Metti alla prova il tuo lavoro

Esegui l'app sul tuo emulatore Android. Dovresti essere immediatamente indirizzato alla schermata di accesso. Toccare il segno con il tasto e-mail, quindi creare un account. Se tutto è implementato correttamente, dovresti essere inviato alla schermata dei messaggi.

Dopo l'accesso, aprire la Firebase Emulator Suite UI nel browser, quindi fare clic sulla scheda Autenticazione per vedere questo primo firmato-in account utente.

In questo passaggio, aggiungeremo funzionalità per leggere e visualizzare i messaggi archiviati in Realtime Database.

Importa messaggi di esempio

  1. Nel Firebase emulatore Suite UI, selezionare la scheda Database in tempo reale.
  2. Trascinare e rilasciare il initial_messages.json file dalla vostra copia locale del repository codelab nel visualizzatore di dati.

Ora si dovrebbe avere un paio di messaggi sotto la messages nodo del database.

Leggi i dati

Sincronizza i messaggi

In questa sezione aggiungiamo il codice che sincronizza i messaggi appena aggiunti all'interfaccia utente dell'app tramite:

  • Inizializzazione del database Firebase Realtime e aggiunta di un listener per gestire le modifiche apportate ai dati.
  • Aggiornamento del RecyclerView adattatore in modo verranno visualizzati i nuovi messaggi.
  • Aggiungendo le variabili di istanza di database con le altre variabili di istanza Firebase nella MainActivity classe:

MainActivity.kt

// Firebase instance variables
// ...
private lateinit var db: FirebaseDatabase
private lateinit var adapter: FriendlyMessageAdapter

Modificare del MainActivity onCreate() il metodo con il commento // Initialize Realtime Database and FirebaseRecyclerAdapter con il codice definito di seguito. Questo codice aggiunge tutti i messaggi esistenti da tempo reale del database e quindi attende per le nuove voci bambino al di sotto messages percorso nel database Firebase in tempo reale. Aggiunge un nuovo elemento all'interfaccia utente per ogni messaggio:

MainActivity.kt

// Initialize Realtime Database
db = Firebase.database
val messagesRef = db.reference.child(MESSAGES_CHILD)

// The FirebaseRecyclerAdapter class and options come from the FirebaseUI library
// See: https://github.com/firebase/FirebaseUI-Android
val options = FirebaseRecyclerOptions.Builder<FriendlyMessage>()
    .setQuery(messagesRef, FriendlyMessage::class.java)
    .build()
adapter = FriendlyMessageAdapter(options, getUserName())
binding.progressBar.visibility = ProgressBar.INVISIBLE
manager = LinearLayoutManager(this)
manager.stackFromEnd = true
binding.messageRecyclerView.layoutManager = manager
binding.messageRecyclerView.adapter = adapter

// Scroll down when a new message arrives
// See MyScrollToBottomObserver for details
adapter.registerAdapterDataObserver(
    MyScrollToBottomObserver(binding.messageRecyclerView, adapter, manager)
)

Avanti nella FriendlyMessageAdapter.kt classe implementare il bind() metodo all'interno della classe interna MessageViewHolder() :

FriendlyMessageAdapter.kt

inner class MessageViewHolder(private val binding: MessageBinding) : ViewHolder(binding.root) {
    fun bind(item: FriendlyMessage) {
        binding.messageTextView.text = item.text
        setTextColor(item.name, binding.messageTextView)

        binding.messengerTextView.text = if (item.name == null) ANONYMOUS else item.name
        if (item.photoUrl != null) {
            loadImageIntoView(binding.messengerImageView, item.photoUrl!!)
        } else {
            binding.messengerImageView.setImageResource(R.drawable.ic_account_circle_black_36dp)
        }
    }
    ...
}

Abbiamo anche bisogno di messaggi sul display che sono le immagini, in modo anche implementare il bind() il metodo all'interno della classe interna ImageMessageViewHolder() :

FriendlyMessageAdapter.kt

inner class ImageMessageViewHolder(private val binding: ImageMessageBinding) :
    ViewHolder(binding.root) {
    fun bind(item: FriendlyMessage) {
        loadImageIntoView(binding.messageImageView, item.imageUrl!!)

        binding.messengerTextView.text = if (item.name == null) ANONYMOUS else item.name
        if (item.photoUrl != null) {
            loadImageIntoView(binding.messengerImageView, item.photoUrl!!)
        } else {
            binding.messengerImageView.setImageResource(R.drawable.ic_account_circle_black_36dp)
        }
    }
}

Infine, nel MainActivity , avviare e arrestare l'ascolto per gli aggiornamenti da Firebase in tempo reale del database. Aggiornare onPause() e onResume() metodi in MainActivity come illustrato di seguito:

MainActivity.kt

public override fun onPause() {
    adapter.stopListening()
    super.onPause()
}

public override fun onResume() {
    super.onResume()
    adapter.startListening()
}

Prova la sincronizzazione dei messaggi

  1. Fare clic su Esegui (eseguire ).
  2. Nell'emulatore Suite UI, tornare alla scheda del database in tempo reale, quindi aggiungere manualmente un nuovo messaggio. Verifica che il messaggio venga visualizzato nella tua app Android:

Congratulazioni, hai appena aggiunto un database in tempo reale alla tua app!

Implementare l'invio di messaggi di testo

In questa sezione, aggiungerai la possibilità per gli utenti dell'app di inviare messaggi di testo. Il frammento di codice di seguito ascolti per eventi Fare clic sul pulsante di invio, crea un nuovo FriendlyMessage oggetto con il contenuto del campo del messaggio, e spinge il messaggio al database. La push() metodo aggiunge un ID generato automaticamente tracciato dell'oggetto spinta. Questi ID sono sequenziali, il che garantisce che i nuovi messaggi vengano aggiunti alla fine dell'elenco.

Aggiornare il click ascoltatore del pulsante di invio nel onCreate() metodo nella MainActivity di classe. Questo codice è nella parte inferiore del onCreate() metodo già. Aggiornare onClick() il corpo in modo che corrisponda il codice qui sotto:

MainActivity.kt

// Disable the send button when there's no text in the input field
// See MyButtonObserver for details
binding.messageEditText.addTextChangedListener(MyButtonObserver(binding.sendButton))

// When the send button is clicked, send a text message
binding.sendButton.setOnClickListener {
    val friendlyMessage = FriendlyMessage(
        binding.messageEditText.text.toString(),
        getUserName(),
        getPhotoUrl(),
        null /* no image */
    )
    db.reference.child(MESSAGES_CHILD).push().setValue(friendlyMessage)
    binding.messageEditText.setText("")
}

Implementare l'invio di messaggi di immagine

In questa sezione, aggiungerai la possibilità per gli utenti dell'app di inviare messaggi immagine. La creazione di un messaggio immagine viene eseguita con questi passaggi:

  • Seleziona immagine
  • Gestire la selezione delle immagini
  • Scrivi un messaggio immagine temporaneo nel database in tempo reale
  • Inizia a caricare l'immagine selezionata
  • Aggiorna l'URL del messaggio immagine a quello dell'immagine caricata, una volta completato il caricamento

Seleziona immagine

Per aggiungere immagini, questo codelab utilizza Cloud Storage per Firebase. Cloud Storage è un buon posto per archiviare i dati binari della tua app.

Gestisci la selezione delle immagini e scrivi il messaggio temporaneo

Una volta che l'utente ha selezionato un'immagine, la selezione dell'immagine Intent viene avviato. Questo è già implementata nel codice alla fine del onCreate() metodo. Al termine si chiama il MainActivity s' onImageSelected() metodo. Utilizzando lo snippet di codice riportato di seguito, scriverai un messaggio con un URL temporaneo dell'immagine nel database che indica che l'immagine è in fase di caricamento.

MainActivity.kt

private fun onImageSelected(uri: Uri) {
    Log.d(TAG, "Uri: $uri")
    val user = auth.currentUser
    val tempMessage = FriendlyMessage(null, getUserName(), getPhotoUrl(), LOADING_IMAGE_URL)
    db.reference
            .child(MESSAGES_CHILD)
            .push()
            .setValue(
                    tempMessage,
                    DatabaseReference.CompletionListener { databaseError, databaseReference ->
                        if (databaseError != null) {
                            Log.w(
                                    TAG, "Unable to write message to database.",
                                    databaseError.toException()
                            )
                            return@CompletionListener
                        }

                        // Build a StorageReference and then upload the file
                        val key = databaseReference.key
                        val storageReference = Firebase.storage
                                .getReference(user!!.uid)
                                .child(key!!)
                                .child(uri.lastPathSegment!!)
                        putImageInStorage(storageReference, uri, key)
                    })
}

Carica l'immagine e aggiorna il messaggio

Aggiungere il metodo putImageInStorage() per MainActivity . Si chiama in onImageSelected() per avviare il caricamento dell'immagine selezionata. Una volta completato il caricamento, aggiornerai il messaggio per utilizzare l'immagine appropriata.

MainActivity.kt

private fun putImageInStorage(storageReference: StorageReference, uri: Uri, key: String?) {
    // First upload the image to Cloud Storage
    storageReference.putFile(uri)
        .addOnSuccessListener(
            this
        ) { taskSnapshot -> // After the image loads, get a public downloadUrl for the image
            // and add it to the message.
            taskSnapshot.metadata!!.reference!!.downloadUrl
                .addOnSuccessListener { uri ->
                    val friendlyMessage =
                        FriendlyMessage(null, getUserName(), getPhotoUrl(), uri.toString())
                    db.reference
                        .child(MESSAGES_CHILD)
                        .child(key!!)
                        .setValue(friendlyMessage)
                }
        }
        .addOnFailureListener(this) { e ->
            Log.w(
                TAG,
                "Image upload task was unsuccessful.",
                e
            )
        }
}

Prova l'invio di messaggi

  1. In Android Studio, fai clic sueseguire Pulsante Esegui.
  2. Nel tuo emulatore Android, inserisci un messaggio, quindi tocca il pulsante di invio. Il nuovo messaggio dovrebbe essere visibile nell'interfaccia utente dell'app e nell'interfaccia utente di Firebase Emulator Suite.
  3. Nell'emulatore Android, tocca l'immagine "+" per selezionare un'immagine dal tuo dispositivo. Il nuovo messaggio dovrebbe essere visibile prima con un'immagine segnaposto e poi con l'immagine selezionata una volta completato il caricamento dell'immagine. Il nuovo messaggio dovrebbe essere visibile anche nell'interfaccia utente di Emulator Suite, in particolare come oggetto nella scheda Realtime Database e come blob nella scheda Archiviazione.

Hai appena creato un'applicazione di chat in tempo reale utilizzando Firebase!

Cosa hai imparato

  • Autenticazione Firebase
  • Database in tempo reale Firebase
  • Archiviazione cloud per Firebase

Quindi, prova a utilizzare ciò che hai imparato in questo codelab per aggiungere Firebase alla tua app Android! Per ulteriori informazioni su Firebase, visitare firebase.google.com .

Se volete imparare come impostare un vero e proprio progetto Firebase e utilizzare le risorse reali Firebase (invece di un progetto demo e le risorse solo emulati), passare alla fase successiva.

Nota: Anche dopo aver impostato un vero e proprio progetto Firebase e soprattutto quando a iniziare la costruzione di una vera e propria applicazione, si consiglia di utilizzare l'emulatore Suite Firebase locali per lo sviluppo e la sperimentazione.

In questo passaggio, creerai un vero progetto Firebase e un'app Android Firebase da utilizzare con questo codelab. Aggiungerai anche la configurazione Firebase specifica per l'app alla tua app. Infine, imposterai vere risorse Firebase da utilizzare con la tua app.

Crea un progetto Firebase

  1. Nel browser, accedere alla console Firebase .
  2. Selezionare progetto del componente aggiuntivo.
  3. Seleziona o inserisci un nome di progetto. Puoi usare qualsiasi nome tu voglia.
  4. Non hai bisogno di Google Analytics per questo codelab, quindi puoi saltare l'abilitazione per il tuo progetto.
  5. Fare clic su Crea progetto. Quando il progetto è pronto, fare clic su Continua.

Aggiungi Firebase al tuo progetto Android

Prima di iniziare questo passaggio, ottieni l'hash SHA1 della tua app. Eseguire il seguente comando dal locale build-android-start directory per determinare la SHA1 della chiave di debug:

./gradlew signingReport

Store: /Users/<username>/.android/debug.keystore
Alias: AndroidDebugKey
MD5: A5:88:41:04:8F:06:59:6A:AE:33:76:87:AA:AD:19:23
SHA1: A7:89:F5:06:A8:07:A1:22:EC:90:6A:A6:EA:C3:D4:8B:3A:30:AB:18
SHA-256: 05:A2:2A:35:EE:F2:51:23:72:4D:72:67:A5:6A:8A:58:22:2C:00:A6:AB:F6:45:D5:A1:82:D8:90:A4:69:C8:FE
Valid until: Wednesday, August 10, 2044

Dovresti vedere un output come quello sopra. La linea importante è la SHA1 hash. Se non riesci a trovare il tuo hash SHA1, consultare questa pagina per ulteriori informazioni.

Torna alla console Firebase e segui questi passaggi per registrare il tuo progetto Android con il tuo progetto Firebase:

  1. Dalla schermata di panoramica del tuo nuovo progetto, fai clic sull'icona Android per avviare il flusso di lavoro di configurazione:aggiungi app Android
  2. Nella schermata successiva, inserire com.google.firebase.codelab.friendlychat come il nome del pacchetto per la vostra applicazione.
  3. Fare clic su Registra App, quindi fare clic su Scarica google-services.json di scaricare il file di configurazione Firebase.
  4. Copiare il google-services.json file nella app directory del progetto Android.
  5. Saltare i passi successivi indicati nella workflow di installazione della console (che hanno già fatto per voi nel build-android-start del progetto).
  6. Assicurati che tutte le dipendenze siano disponibili per la tua app sincronizzando il tuo progetto con i file Gradle. Dalla barra degli strumenti di Studio Android, selezionare File> Progetto Sincronizzazione con Gradle Files.

Configura l'autenticazione Firebase

Prima che la tua app possa accedere alle API di autenticazione Firebase per conto dei tuoi utenti, devi abilitare Firebase Authentication e i provider di accesso che desideri utilizzare nella tua app.

  1. Nella console Firebase , selezionare Autenticazione dal pannello di navigazione a sinistra.
  2. Selezionare il Sign-in scheda Metodo.
  3. Clicca Email / password, quindi impostare l'interruttore abilitato (blu).
  4. Fare clic su Google, quindi impostare l'interruttore abilitato (blu) e impostare un'email di sostegno ai progetti.

Se ricevi errori più avanti in questo codelab con il messaggio "CONFIGURATION_NOT_FOUND", torna a questo passaggio e ricontrolla il tuo lavoro.

Configura database in tempo reale

L'app in questo codelab memorizza i messaggi di chat in Firebase Realtime Database. In questa sezione, creeremo un database e configureremo la sua sicurezza tramite un linguaggio di configurazione JSON chiamato Firebase Security Rules.

  1. Nella console Firebase , selezionare in tempo reale del database dal pannello di navigazione a sinistra.
  2. Fare clic su Crea database per creare una nuova istanza di database in tempo reale. Quando richiesto, selezionare il us-central1 regione, quindi fare clic su Avanti.
  3. Quando vengono richieste le regole di sicurezza, scegliere la modalità di blocco, quindi fare clic su Attiva.
  4. Una volta che l'istanza del database è stato creato, selezionare la scheda Regole, quindi aggiornare la configurazione norme con il seguente:
     {
       "rules": {
         "messages": {
           ".read": "auth.uid != null",
           ".write": "auth.uid != null"
         }
       }
     }
    

Per ulteriori informazioni su come le regole di sicurezza di lavoro (compresa la documentazione sulla variabile "auth"), consultare la documentazione di sicurezza del database in tempo reale .

Configura Cloud Storage per Firebase

  1. Nella console Firebase , selezionare bagagli dal pannello di navigazione a sinistra.
  2. Clicca Inizia per abilitare Cloud Storage per il vostro progetto.
  3. Segui i passaggi nella finestra di dialogo per configurare il bucket, utilizzando le impostazioni predefinite suggerite.

Connettiti alle risorse Firebase

In una fase precedente di questo codelab, è aggiunto il testo seguente MainActivity.kt . Questo blocco condizionale ha collegato il tuo progetto Android a Firebase Emulator Suite.

// REMOVE OR DISABLE THIS
if (BuildConfig.DEBUG) {
    Firebase.database.useEmulator("10.0.2.2", 9000)
    Firebase.auth.useEmulator("10.0.2.2", 9099)
    Firebase.storage.useEmulator("10.0.2.2", 9199)
}

Se si desidera collegare l'app per il nuovo progetto Firebase reale e le sue reali risorse Firebase, è possibile rimuovere o questo blocco o eseguire l'applicazione in modalità di rilascio in modo che BuildConfig.DEBUG è false .