Firebase Android Codelab: crea chat amichevole

1. Panoramica

Immagine: app Working Friendly Chat.

Benvenuto nel codelab di Friendly Chat. 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 Firebase Realtime Database.
• Come archiviare file binari in Cloud Storage for Firebase.
• Come utilizzare Firebase Local Emulator Suite per sviluppare un'app Android con Firebase.

Di cosa avrai bisogno

• Ultima versione di Android Studio .
• Un emulatore Android con Android 5.0+.
• Node.js versione 10 o successiva (per utilizzare Emulator Suite).
• Java 8 o successivo. Per installare Java utilizzare queste istruzioni ; per verificare la tua versione, esegui java -version .
• Conoscenza del linguaggio di programmazione Kotlin.

2. Ottieni il codice di esempio

Clona il repository

Clona il repository GitHub dalla riga di comando:

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

Il repository "friendlychat-android" contiene due directory:

• build-android-start : codice iniziale su cui si sviluppa in questo codelab.
• build-android : codice completato per l'app di esempio completata.

Nota : se desideri eseguire l'app finita, devi creare un progetto Firebase nella console Firebase, insieme a un'app Android Firebase con il nome del pacchetto dell'app e SHA1. Per ulteriori informazioni, vedere il passaggio 10 di questo codelab.

Importa in Android Studio

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

Ora dovresti avere il progetto build-android-start aperto in Android Studio. Se vedi un avviso relativo alla mancanza di un file google-services.json , non preoccuparti. 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.kts

plugins {
    id("com.android.application") version "8.0.0" apply false
    id("com.android.library") version "8.0.0" apply false
    id("org.jetbrains.kotlin.android") version "1.8.20" apply false

    // The google-services plugin is required to parse the google-services.json file
    id("com.google.gms.google-services") version "4.3.15" apply false
}

app/build.gradle.kts

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:20.5.0")

    // Firebase SDK
    implementation(platform("com.google.firebase:firebase-bom:32.0.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:8.0.2")
    implementation("com.firebaseui:firebase-ui-database:8.0.2")
}

3. Installa la CLI Firebase

In questo codelab utilizzerai Firebase Emulator Suite per emulare localmente Firebase Auth, Realtime Database e Cloud Storage. Ciò fornisce un ambiente di sviluppo locale sicuro, veloce e gratuito per creare la tua app.

Installa la CLI di Firebase

Per prima cosa dovrai installare la CLI Firebase . Se utilizzi macOS o Linux, puoi eseguire il seguente comando cURL:

curl -sL https://firebase.tools | bash

Se utilizzi Windows, leggi le istruzioni di installazione per ottenere un file binario autonomo o per installarlo tramite npm .

Dopo aver installato la CLI, l'esecuzione firebase --version dovrebbe riportare una versione 9.0.0 o successiva:

$ firebase --version
9.0.0

Login

Esegui firebase login per connettere la CLI al tuo account Google. Si aprirà una nuova finestra del browser per completare il processo di accesso. Assicurati di scegliere lo stesso account che hai utilizzato durante la creazione del tuo progetto Firebase in precedenza.

4. Connettiti alla suite di emulatori Firebase

Avvia gli emulatori

Nel tuo terminale, esegui il comando seguente dalla root della directory codelab-friendlychat-android locale:

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

Dovresti vedere alcuni log come questo. I valori della porta sono stati definiti nel file firebase.json , 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'interfaccia utente di Firebase Emulator Suite:

Lasciare il emulators:start in esecuzione per il resto del codelab.

Collega la tua app

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

// 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)
}

5. Esegui l'app iniziale

Aggiungi google-services.json

Affinché la tua app Android possa connettersi a Firebase, devi aggiungere un file google-services.json nella cartella app del tuo progetto Android. Ai fini di questo codelab, abbiamo fornito un file JSON fittizio che ti consentirà di connetterti a Firebase Emulator Suite.

Copia il file mock-google-services.json nella cartella build-android-start/app 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 Android Firebase 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 Firebase, sei pronto per eseguire l'app per la prima volta.

Nota: affinché la tua app possa comunicare con Firebase Emulator Suite, deve essere in esecuzione su un emulatore Android, non su un vero dispositivo Android. Ciò consentirà all'app di comunicare con Firebase Emulator Suite su localhost . Assicurati che la definizione del dispositivo virtuale selezionata esegua i servizi del Play Store.

1. Avvia il tuo emulatore Android.
2. In Android Studio, fai clic su Esegui ( ) 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.

6. Abilita l'autenticazione

Questa app utilizzerà Firebase Realtime Database per archiviare tutti i messaggi di chat. Prima di aggiungere dati, però, 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 un codice di autenticazione Firebase di base per rilevare gli utenti e implementare una schermata di accesso.

Controlla l'utente corrente

Per prima cosa aggiungi la seguente variabile di istanza alla classe MainActivity.kt :

MainActivity.kt

// Firebase instance variables
private lateinit var auth: FirebaseAuth

Ora modifichiamo MainActivity per inviare l'utente alla schermata di accesso ogni volta che apre l'app e non è autenticato. Aggiungi quanto segue al metodo onCreate() dopo aver collegato l' binding 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 ha effettuato l'accesso 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 implementa i metodi getUserPhotoUrl() e getUserName() 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 implementa il metodo signOut() per gestire il pulsante di disconnessione:

MainActivity.kt

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

Ora disponiamo di tutta la logica per indirizzare l'utente alla schermata di accesso quando necessario. Successivamente dobbiamo implementare la schermata di accesso per autenticare correttamente gli utenti.

Implementare la schermata di accesso

Apri 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.

Aggiungi una variabile di istanza Auth nella classe SignInActivity sotto il commento // Firebase instance variables :

SignInActivity.kt

// Firebase instance variables
private lateinit var auth: FirebaseAuth

Quindi, modifica il metodo onCreate() per inizializzare Firebase nello stesso modo in cui hai fatto in MainActivity :

SignInActivity.kt

// Initialize FirebaseAuth
auth = Firebase.auth

Aggiungi un campo ActivityResultLauncher a SignInActivity :

SignInActivity.kt

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

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

Successivamente, modifica il metodo onStart() per avviare il flusso di accesso FirebaseUI:

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()
    }
}

Successivamente, implementa il metodo onSignInResult per gestire il risultato dell'accesso. Se il risultato dell'accesso ha avuto esito positivo, continua su 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 al metodo e senza la necessità di 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. Tocca il pulsante Accedi con e-mail , quindi crea un account. Se tutto è implementato correttamente, dovresti essere inviato alla schermata di messaggistica.

Nota: l'accesso con Google non funzionerà ancora perché non hai registrato la tua app con Firebase. Avrai la possibilità di farlo alla fine del codelab.

Dopo aver effettuato l'accesso, apri l'interfaccia utente di Firebase Emulator Suite nel browser, quindi fai clic sulla scheda Autenticazione per visualizzare il primo account utente a cui è stato effettuato l'accesso.

7. Leggi i messaggi

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

Importa messaggi di esempio

1. Nell'interfaccia utente di Firebase Emulator Suite, seleziona la scheda Realtime Database .
2. Trascina e rilascia il file initial_messages.json dalla copia locale del repository codelab nel visualizzatore dati.

Ora dovresti avere alcuni messaggi nel nodo messages 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 Firebase Realtime Database e aggiunta di un ascoltatore per gestire le modifiche apportate ai dati.
• Aggiornamento dell'adattatore RecyclerView in modo che vengano visualizzati i nuovi messaggi.
• Aggiunta delle variabili dell'istanza del database con le altre variabili dell'istanza Firebase nella classe MainActivity :

MainActivity.kt

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

Modifica il metodo onCreate() di MainActivity sotto il commento // Initialize Realtime Database and FirebaseRecyclerAdapter con il codice definito di seguito. Questo codice aggiunge tutti i messaggi esistenti da Realtime Database e quindi ascolta le nuove voci secondarie nel percorso messages nel tuo Firebase Realtime Database. 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)
)

Successivamente nella classe FriendlyMessageAdapter.kt implementa il metodo bind() 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)
        }
    }
    ...
}

Dobbiamo anche visualizzare messaggi che sono immagini, quindi implementa anche il metodo bind() 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, torna in MainActivity , avvia e interrompi l'ascolto degli aggiornamenti da Firebase Realtime Database. Aggiorna i metodi onPause() e onResume() in MainActivity come mostrato 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 ( ).
2. Nell'interfaccia utente di Emulator Suite, torna alla scheda Realtime Database , quindi aggiungi 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!

8. Invia messaggi

Implementare l'invio di messaggi di testo

In questa sezione aggiungerai la possibilità per gli utenti dell'app di inviare messaggi di testo. Lo snippet di codice seguente ascolta gli eventi clic sul pulsante di invio, crea un nuovo oggetto FriendlyMessage con il contenuto del campo del messaggio e invia il messaggio al database. Il metodo push() aggiunge un ID generato automaticamente al percorso dell'oggetto inviato. Questi ID sono sequenziali e garantiscono che i nuovi messaggi verranno aggiunti alla fine dell'elenco.

Aggiorna il listener di clic del pulsante di invio nel metodo onCreate() nella classe MainActivity . Questo codice si trova già alla fine del metodo onCreate() . Aggiorna il corpo onClick() in modo che corrisponda al codice seguente:

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 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 l'immagine
• Gestire la selezione delle immagini
• Scrivi un messaggio immagine temporaneo nel Realtime Database
• 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 for Firebase. Cloud Storage è un buon posto in cui archiviare i dati binari della tua app.

Gestire la selezione delle immagini e scrivere un messaggio temporaneo

Una volta che l'utente ha selezionato un'immagine, viene avviato l' Intent di selezione dell'immagine. Questo è già implementato nel codice alla fine del metodo onCreate() . Al termine, chiama il metodo onImageSelected() di MainActivity . Utilizzando lo snippet di codice riportato di seguito, scriverai un messaggio con un URL di immagine temporaneo nel database indicando 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

Aggiungi il metodo putImageInStorage() a MainActivity . Viene chiamato 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 a inviare messaggi

1. In Android Studio, fai clic su 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.

9. Congratulazioni!

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

Quello che hai imparato

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

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

Se vuoi imparare come configurare un vero progetto Firebase e utilizzare risorse Firebase reali (invece di un progetto demo e solo risorse emulate), vai al passaggio successivo.

Nota: anche dopo aver configurato un vero progetto Firebase e soprattutto quando inizi a creare un'app reale, ti consigliamo di utilizzare Firebase Local Emulator Suite per lo sviluppo e il test.

10. Facoltativo: crea e configura un progetto Firebase

In questo passaggio creerai un vero progetto Firebase e un'app Android Firebase da utilizzare con questo codelab. Aggiungerai anche la configurazione Firebase specifica dell'app alla tua app. Infine, configurerai risorse Firebase reali da utilizzare con la tua app.

Crea un progetto Firebase

1. Nel browser, vai alla console Firebase .
2. Seleziona Aggiungi progetto .
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 tuo progetto è pronto, fai clic su Continua .

Aggiungi Firebase al tuo progetto Android

Prima di iniziare questo passaggio, ottieni l'hash SHA1 della tua app. Esegui il comando seguente dalla directory build-android-start locale per determinare lo 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 è l'hash SHA1 . Se non riesci a trovare l'hash SHA1, consulta 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:
2. Nella schermata successiva, inserisci com.google.firebase.codelab.friendlychat come nome del pacchetto per la tua app.
3. Fai clic su Registra app , quindi su Scarica google-services.json per scaricare il file di configurazione Firebase.
4. Copia il file google-services.json nella directory app del tuo progetto Android.
5. Salta i passaggi successivi mostrati nel flusso di lavoro di configurazione della console (sono già stati eseguiti per te nel progetto build-android-start ).
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 Android Studio, seleziona File > Sincronizza progetto con file Gradle . Potrebbe anche essere necessario eseguire Build/Clean Project e Build/Rebuild Project affinché le modifiche alla configurazione abbiano luogo.

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 , seleziona Autenticazione dal pannello di navigazione a sinistra.
2. Seleziona la scheda Metodo di accesso .
3. Fai clic su E-mail/Password , quindi imposta l'interruttore su abilitato (blu).
4. Fai clic su Google , quindi imposta l'interruttore su abilitato (blu) e imposta un'e-mail di supporto per il progetto.

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

Configura il database in tempo reale

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

1. Nella console Firebase , seleziona Realtime Database dal pannello di navigazione a sinistra.
2. Fare clic su Crea database per creare una nuova istanza di Realtime Database. Quando richiesto, seleziona la regione us-central1 , quindi fai clic su Avanti .
3. Quando ti vengono richieste informazioni sulle regole di sicurezza, scegli la modalità bloccata , quindi fai clic su Abilita .
4. Una volta creata l'istanza del database, seleziona la scheda Regole , quindi aggiorna la configurazione delle regole con quanto segue:

    {
      "rules": {
        "messages": {
          ".read": "auth.uid != null",
          ".write": "auth.uid != null"
        }
      }
    }
   

Per ulteriori informazioni su come funzionano le regole di sicurezza (inclusa la documentazione sulla variabile "auth"), consultare la documentazione sulla sicurezza di Realtime Database .

Configura Cloud Storage per Firebase

1. Nella console Firebase , seleziona Archiviazione dal pannello di navigazione a sinistra.
2. Fai clic su Inizia per abilitare Cloud Storage per il tuo progetto.
3. Segui i passaggi nella finestra di dialogo per configurare il tuo bucket, utilizzando le impostazioni predefinite suggerite.

Connettiti alle risorse Firebase

In un passaggio precedente di questo codelab, hai aggiunto quanto segue a 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 desideri connettere la tua app al tuo nuovo progetto Firebase reale e alle sue risorse Firebase reali , puoi rimuovere questo blocco o eseguire la tua app in modalità di rilascio in modo che BuildConfig.DEBUG sia false .