1. Panoramica
Immagine: App Chat efficiente e funzionante.
Ti diamo il benvenuto nel codelab di Friendly Chat. In questo codelab imparerai a utilizzare la piattaforma Firebase per creare un'app di chat su Android.
Obiettivi didattici
- Come utilizzare Firebase Authentication 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 per Android con Firebase.
Che cosa ti serve
- La versione più recente di Android Studio.
- Un emulatore Android con Android 5.0 o versioni successive.
- Node.js versione 10 o successive (per utilizzare Emulator Suite).
- Java 8 o superiore. Per installare Java utilizza queste istruzioni; per controllare la tua versione, esegui
java -version
. - Familiarità con il linguaggio di programmazione Kotlin.
2. recupera il codice campione
clona il repository
Clona il repository GitHub dalla riga di comando:
$ git clone https://github.com/firebase/codelab-friendlychat-android
Importazione 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 il progetto build-android-start
dovrebbe essere aperto in Android Studio. Se viene visualizzato 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 l'interfaccia a riga di comando di Firebase
In questo codelab utilizzerai Firebase Emulator Suite per emulare localmente Firebase Authentication, Realtime Database e Cloud Storage. In questo modo, avrai a disposizione un ambiente di sviluppo locale sicuro, veloce e senza costi per creare la tua app.
Installa l'interfaccia a riga di comando di Firebase
Innanzitutto devi installare l'interfaccia a riga di comando di 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 installare il programma tramite npm
.
Una volta installata l'interfaccia a riga di comando, l'esecuzione di firebase --version
dovrebbe segnalare una versione 9.0.0
o successiva:
$ firebase --version 9.0.0
Accedi
Esegui firebase login
per connettere l'interfaccia a riga di comando al tuo Account Google. Si aprirà una nuova finestra del browser per completare la procedura di accesso. Assicurati di scegliere lo stesso account utilizzato in precedenza per creare il progetto Firebase.
4. Connettersi a Firebase Emulator Suite
Avvia gli emulatori
Nel terminale, esegui questo comando dalla directory radice 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.
Vai alla pagina http://localhost:4000 nel browser web per visualizzare l'interfaccia utente di Firebase Emulator Suite:
Lascia in esecuzione il comando emulators:start
per il resto del codelab.
Collegare l'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 di avvio
Aggiungi google-services.json
Affinché la tua app per Android si connetta a Firebase, devi aggiungere un file google-services.json
all'interno della cartella app
del tuo progetto Android. Ai fini di questo codelab, abbiamo fornito un file JSON di esempio 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
Nel passaggio finale di questo codelab, scoprirai come creare un progetto Firebase e un'app per Android Firebase reali in modo da poter sostituire questo file JSON simulato con la tua configurazione.
Esegui l'app
Ora che hai importato il progetto in Android Studio e hai aggiunto un file JSON di configurazione di Firebase, puoi eseguire l'app per la prima volta.
- Avvia l'emulatore Android.
- In Android Studio, fai clic su Esegui ( ) nella barra degli strumenti.
L'app dovrebbe avviarsi sull'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 Chat di Google.
6. Attiva l'autenticazione
Questa app utilizzerà Firebase Realtime Database per archiviare tutti i messaggi di chat. Prima di aggiungere i dati, però, dobbiamo assicurarci che l'app sia sicura e che solo gli utenti autenticati possano pubblicare messaggi. In questo passaggio abiliteremo Firebase Authentication e configureremo le regole di sicurezza di Realtime Database.
Aggiungi funzionalità di accesso di base
Successivamente aggiungeremo all'app del codice Firebase Authentication 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
in modo che l'utente venga indirizzato alla schermata di accesso ogni volta che apre l'app e non è autenticato. Aggiungi il seguente metodo al metodo onCreate()
dopo che binding
è stato collegato 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 eseguito 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
}
}
Poi 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
}
Poi 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 abbiamo tutta la logica necessaria per inviare l'utente alla schermata di accesso quando necessario. Ora dobbiamo implementare la schermata di accesso per autenticare correttamente gli utenti.
Implementare la schermata di accesso
Apri il file SignInActivity.kt
. In questo caso, per avviare l'autenticazione viene utilizzato un semplice pulsante Accedi. 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?) {
// ...
}
Poi, modifica il metodo onStart()
per avviare il flusso di accesso a 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 è positivo, vai 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)
}
}
}
Ecco fatto. Hai implementato l'autenticazione con FirebaseUI in poche chiamate al metodo e senza dover gestire alcuna configurazione lato server.
Verifica l'attività completata
Esegui l'app nell'emulatore Android. Dovrebbe aprirsi immediatamente la schermata di accesso. Tocca il pulsante Accedi con email e crea un account. Se tutto è implementato correttamente, dovresti essere indirizzato alla schermata dei messaggi.
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 con cui è stato eseguito l'accesso.
7. Leggere i messaggi
In questo passaggio aggiungeremo la funzionalità per leggere e visualizzare i messaggi archiviati in Realtime Database.
Importa messaggi di esempio
- Nell'interfaccia utente di Firebase Emulator Suite, seleziona la scheda Realtime Database.
- Trascina il file
initial_messages.json
dalla copia locale del repository del codelab nel visualizzatore dati.
A questo punto dovresti avere alcuni messaggi sotto il nodo messages
del database.
Lettura di dati
Sincronizzare i messaggi
In questa sezione aggiungiamo il codice che sincronizza i messaggi appena aggiunti all'interfaccia utente dell'app tramite:
- Inizializzazione di Firebase Realtime Database e aggiunta di un listener per gestire le modifiche apportate ai dati.
- Aggiornamento dell'adattatore
RecyclerView
in modo che vengano mostrati i nuovi messaggi. - Aggiunta delle variabili di istanza di Database insieme alle altre variabili di 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 poi rimane in ascolto delle nuove voci figlio nel percorso messages
di 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)
)
Poi nella classe FriendlyMessageAdapter.kt
implementa il metodo bind()
nella 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 implementiamo 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
per avviare e interrompere 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()
}
Testare la sincronizzazione dei messaggi
- Fai clic su Esegui ( ).
- Nell'interfaccia utente di Emulator Suite, torna alla scheda Realtime Database, quindi aggiungi manualmente un nuovo messaggio. Verifica che il messaggio venga visualizzato nell'app per Android:
Congratulazioni, hai appena aggiunto un database in tempo reale alla tua app.
8. Invio messaggi
Implementare l'invio di messaggi
In questa sezione, aggiungerai la possibilità per gli utenti dell'app di inviare messaggi. Lo snippet di codice riportato di seguito rimane in ascolto degli eventi di clic sul pulsante di invio, crea un nuovo oggetto FriendlyMessage
con i contenuti del campo del messaggio e invia il messaggio al database. Il metodo push()
aggiunge un ID generato automaticamente al percorso dell'oggetto sottoposto a push. Questi ID sono sequenziali per fare in modo che i nuovi messaggi vengano aggiunti alla fine dell'elenco.
Aggiorna l'ascoltatore di clic del pulsante di invio nel metodo onCreate()
della classe MainActivity
. Questo codice è già presente nella parte inferiore del metodo onCreate()
. Aggiorna il corpo di 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 con immagini
In questa sezione aggiungerai la possibilità per gli utenti dell'app di inviare messaggi con immagini. Per creare un messaggio illustrato:
- Seleziona immagine
- Gestire la selezione delle immagini
- Scrivi un messaggio immagine temporaneo in Realtime Database
- Inizia a caricare l'immagine selezionata
- Aggiorna l'URL del messaggio immagine con quello dell'immagine caricata al termine del caricamento
Seleziona immagine
Per aggiungere immagini questo codelab utilizza Cloud Storage for Firebase. Cloud Storage è un buon posto per archiviare i dati binari della tua app.
Gestire la selezione delle immagini e scrivere un messaggio temporaneo
Una volta selezionata un'immagine, viene avviata la selezione delle immagini Intent
. 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 temporaneo dell'immagine nel database per indicare 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 immagine e aggiorna messaggio
Aggiungi il metodo putImageInStorage()
a MainActivity
. Viene chiamato in onImageSelected()
per avviare il caricamento dell'immagine selezionata. Al termine del caricamento, aggiorna il messaggio in modo da utilizzare l'immagine appropriata.
Attività principale.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
- In Android Studio, fai clic sul pulsante Esegui.
- In Android Emulator, inserisci un messaggio e tocca il pulsante di invio. Il nuovo messaggio dovrebbe essere visibile nell'interfaccia utente dell'app e in quella di Firebase Emulator Suite.
- In Android Emulator, tocca l'immagine "+" per selezionare un'immagine dal tuo dispositivo. Il nuovo messaggio deve 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. Complimenti!
Hai appena creato un'applicazione di chat in tempo reale utilizzando Firebase.
Che cosa hai imparato
- Firebase Authentication
- Firebase Realtime Database
- Cloud Storage for Firebase
A questo punto, prova a utilizzare ciò che hai imparato in questo codelab per aggiungere Firebase alla tua app per Android. Per scoprire di più su Firebase, visita il sito firebase.google.com.
Se vuoi imparare a configurare un progetto Firebase reale e utilizzare risorse Firebase reale (anziché un progetto demo e solo risorse emulate), vai al passaggio successivo.
Nota: anche dopo aver configurato un progetto Firebase reale e soprattutto quando hai iniziato a creare un'app reale, ti consigliamo di usare Firebase Local Emulator Suite per lo sviluppo e i test.
10. (Facoltativo) Crea e configura un progetto Firebase
In questo passaggio, creerai un progetto Firebase reale e un'app Firebase per Android da utilizzare in questo codelab. Aggiungerai anche la configurazione Firebase specifica per l'app. Infine, configurerai risorse Firebase reali da utilizzare con l'app.
Crea un progetto Firebase
- Nel browser, vai alla console Firebase.
- Seleziona Aggiungi progetto.
- Seleziona o inserisci un nome per il progetto. Puoi utilizzare il nome che preferisci.
- Non hai bisogno di Google Analytics per questo codelab, quindi puoi saltare l'abilitazione per il tuo progetto.
- Fai clic su Crea progetto. Quando il progetto è pronto, fai clic su Continua.
Eseguire l'upgrade del piano tariffario di Firebase
Per utilizzare Cloud Storage for Firebase, il progetto Firebase deve avere il piano tariffario di pagamento a consumo (Blaze), il che significa che è collegato a un account di fatturazione Cloud.
- Un account di fatturazione Cloud richiede un metodo di pagamento, ad esempio una carta di credito.
- Se non hai mai utilizzato Firebase e Google Cloud, controlla se hai diritto a un credito di 300$e a un account di fatturazione Cloud di prova senza costi.
- Se partecipi a questo codelab come parte di un evento, chiedi all'organizzatore se sono disponibili crediti Cloud.
Per eseguire l'upgrade del progetto al piano Blaze:
- Nella console Firebase, scegli di eseguire l'upgrade del piano.
- Seleziona il piano Blaze. Segui le istruzioni sullo schermo per collegare un account di fatturazione Cloud al tuo progetto.
Se hai dovuto creare un account di fatturazione Cloud nell'ambito di questo upgrade, potresti dover tornare al flusso di upgrade nella console Firebase per completarlo.
Aggiungere Firebase al progetto Android
Prima di iniziare questo passaggio, recupera l'hash SHA1 dell'app. Esegui il seguente comando dalla directory build-android-start
locale per determinare l'algoritmo 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 riportato sopra. La riga importante è l'hash SHA1
. Se non riesci a trovare l'hash SHA1, visita questa pagina per ulteriori informazioni.
Torna alla console Firebase e segui questi passaggi per registrare il tuo progetto Android al progetto Firebase:
- Dalla schermata di panoramica del nuovo progetto, fai clic sull'icona Android per avviare il flusso di lavoro di configurazione:
- Nella schermata successiva, inserisci
com.google.firebase.codelab.friendlychat
come nome del pacchetto dell'app. - Fai clic su Registra app, quindi su Scarica google-services.json per scaricare il file di configurazione Firebase.
- Copia il file
google-services.json
nella directoryapp
del progetto Android. - Salta i passaggi successivi mostrati nel flusso di lavoro di configurazione della console (sono già stati eseguiti per te nel progetto
build-android-start
). - Assicurati che tutte le dipendenze siano disponibili per la tua app sincronizzando il progetto con i file Gradle. Nella barra degli strumenti di Android Studio, seleziona File > Sincronizza il progetto con i file Gradle. Potrebbe anche essere necessario eseguire Build/Clean Project e Build/Rebuild Project per applicare le modifiche alla configurazione.
Configura Firebase Authentication
Prima che la tua app possa accedere alle API Firebase Authentication per conto dei tuoi utenti, devi attivare Firebase Authentication e i provider di accesso che vuoi utilizzare nella tua app.
- Nella console Firebase, seleziona Autenticazione dal pannello di navigazione a sinistra.
- Seleziona la scheda Metodo di accesso.
- Fai clic su Email/Password e imposta l'opzione su Attivato (blu).
- Fai clic su Google, quindi imposta l'opzione su Abilitato (blu) e imposta un'email di assistenza per il progetto.
Se in un secondo momento in questo codelab ricevi errori con il messaggio "CONFIGURATION_NOT_FOUND", torna a questo passaggio e ricontrolla il tuo lavoro.
configura Realtime Database
L'app in questo codelab archivia 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.
- Nel riquadro a sinistra della console Firebase, espandi Build e seleziona Database in tempo reale.
- Fai clic su Crea database.
- Seleziona una posizione per il database, poi fai clic su Avanti.
Per un'app reale, scegli una posizione vicina ai tuoi utenti. - Fai clic su Avvia in modalità di test. Leggi il disclaimer relativo alle regole di sicurezza.
Nei passaggi successivi di questo codelab, aggiungerai regole di sicurezza per proteggere i tuoi dati. Non distribuire o esporre pubblicamente un'app senza aggiungere regole di sicurezza per il tuo database. - Fai clic su Crea.
- Dopo aver creato l'istanza di database, seleziona la scheda Regole e aggiorna la configurazione delle regole con quanto segue:
{ "rules": { "messages": { ".read": "auth.uid != null", ".write": "auth.uid != null" } } }
Per ulteriori informazioni sul funzionamento delle regole di sicurezza (inclusa la documentazione sulla variabile "auth"), consulta la documentazione sulla sicurezza di Realtime Database.
Configura Cloud Storage per Firebase
- Nel riquadro a sinistra della console Firebase, espandi Crea e seleziona Spazio di archiviazione.
- Fai clic su Inizia.
- Seleziona una posizione per il bucket di archiviazione predefinito.
I bucket inUS-WEST1
,US-CENTRAL1
eUS-EAST1
possono usufruire del livello "Sempre gratuito" per Google Cloud Storage. I bucket in tutte le altre località rispettano i prezzi e l'utilizzo di Google Cloud Storage. - Fai clic su Avvia in modalità di test. Leggi il disclaimer relativo alle regole di sicurezza.
Più avanti in questo codelab, aggiungerai regole di sicurezza per proteggere i tuoi dati. Non distribuire o esporre pubblicamente un'app senza aggiungere regole di sicurezza per il bucket Storage. - Fai clic su Crea.
Connettersi alle risorse Firebase
In un passaggio precedente di questo codelab, hai aggiunto quanto segue a MainActivity.kt
. Questo blocco condizionale ha collegato il 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 vuoi collegare la tua app al nuovo progetto Firebase reale e alle relative risorse Firebase reale, puoi rimuovere il blocco o eseguire l'app in modalità di rilascio in modo che BuildConfig.DEBUG
sia false
.