Atelier de programmation Android Firebase – Créer un chat convivial

1. Vue d'ensemble

capture d'écran

Image : Application de chat convivial et fonctionnel.

Bienvenue dans l'atelier de programmation Friendly Chat. Dans cet atelier de programmation, vous apprendrez à utiliser la plate-forme Firebase pour créer une application de chat sur Android.

Ce que vous apprendrez

  • Comment utiliser l'authentification Firebase pour permettre aux utilisateurs de se connecter.
  • Comment synchroniser les données à l'aide de la base de données Firebase Realtime.
  • Comment stocker des fichiers binaires dans Cloud Storage pour Firebase.
  • Comment utiliser Firebase Local Emulator Suite pour développer une application Android avec Firebase.

Ce dont vous aurez besoin

  • Dernière version d'Android Studio .
  • Un émulateur Android avec Android 5.0+.
  • Node.js version 10 ou supérieure (pour utiliser Emulator Suite).
  • Java 8 ou supérieur. Pour installer Java, utilisez ces instructions ; pour vérifier votre version, exécutez java -version .
  • Familiarité avec le langage de programmation Kotlin.

2. Obtenez l'exemple de code

Cloner le référentiel

Clonez le dépôt GitHub à partir de la ligne de commande :

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

Importer dans Android Studio

Dans Android Studio, sélectionnez File > Open , puis sélectionnez le répertoire build-android-start ( dossier_studio_android ) à partir du répertoire dans lequel vous avez téléchargé l'exemple de code.

Le projet build-android-start devrait maintenant être ouvert dans Android Studio. Si vous voyez un avertissement concernant un fichier google-services.json manquant, ne vous inquiétez pas. Il sera ajouté dans une étape ultérieure.

Vérifier les dépendances

Dans cet atelier de programmation, toutes les dépendances dont vous aurez besoin ont déjà été ajoutées, mais il est important de comprendre comment ajouter le SDK Firebase à votre application :

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. Installez la CLI Firebase

Dans cet atelier de programmation, vous utiliserez Firebase Emulator Suite pour émuler localement Firebase Auth, la base de données en temps réel et le stockage cloud. Cela fournit un environnement de développement local sûr, rapide et gratuit pour créer votre application.

Installer la CLI Firebase

Vous devrez d’abord installer la Firebase CLI . Si vous utilisez macOS ou Linux, vous pouvez exécuter la commande cURL suivante :

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

Si vous utilisez Windows, lisez les instructions d'installation pour obtenir un binaire autonome ou pour l'installer via npm .

Une fois que vous avez installé la CLI, l'exécution firebase --version devrait signaler une version 9.0.0 ou supérieure :

$ firebase --version
9.0.0

Se connecter

Exécutez firebase login pour connecter la CLI à votre compte Google. Cela ouvrira une nouvelle fenêtre de navigateur pour terminer le processus de connexion. Assurez-vous de choisir le même compte que vous avez utilisé lors de la création précédente de votre projet Firebase.

4. Connectez-vous à la suite d'émulateurs Firebase

Démarrez les émulateurs

Dans votre terminal, exécutez la commande suivante à partir de la racine de votre répertoire local codelab-friendlychat-android :

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

Vous devriez voir des journaux comme celui-ci. Les valeurs de port ont été définies dans le fichier firebase.json , qui a été inclus dans l'exemple de code cloné.

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

Accédez à http://localhost:4000 dans votre navigateur Web pour afficher l'interface utilisateur de Firebase Emulator Suite :

Accueil de l'interface utilisateur de la suite Emulator

Laissez la commande emulators:start s'exécuter pour le reste de l'atelier de programmation.

Connectez votre application

Dans Android Studio, ouvrez MainActivity.kt , puis ajoutez le code suivant dans la méthode 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. Exécutez l'application de démarrage

Ajouter google-services.json

Pour que votre application Android se connecte à Firebase, vous devez ajouter un fichier google-services.json dans le dossier app de votre projet Android. Pour les besoins de cet atelier de programmation, nous avons fourni un fichier JSON fictif qui vous permettra de vous connecter à Firebase Emulator Suite.

Copiez le fichier mock-google-services.json dans le dossier build-android-start/app sous le nom google-services.json :

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

Dans la dernière étape de cet atelier de programmation, vous apprendrez à créer un véritable projet Firebase et une application Firebase Android afin de pouvoir remplacer ce fichier JSON fictif par votre propre configuration.

Exécutez l'application

Maintenant que vous avez importé le projet dans Android Studio et ajouté un fichier JSON de configuration Firebase, vous êtes prêt à exécuter l'application pour la première fois.

  1. Démarrez votre émulateur Android.
  2. Dans Android Studio, cliquez sur Exécuter ( exécuter ) dans la barre d'outils.

L'application devrait se lancer sur votre émulateur Android. À ce stade, vous devriez voir une liste de messages vide et l’envoi et la réception de messages ne fonctionneront pas. Dans la prochaine étape de cet atelier de programmation, vous allez authentifier les utilisateurs afin qu'ils puissent utiliser Friendly Chat.

6. Activer l'authentification

Cette application utilisera la base de données Firebase Realtime pour stocker tous les messages de discussion. Avant d'ajouter des données, nous devons cependant nous assurer que l'application est sécurisée et que seuls les utilisateurs authentifiés peuvent publier des messages. Dans cette étape, nous activerons l'authentification Firebase et configurerons les règles de sécurité de la base de données en temps réel.

Ajouter une fonctionnalité de connexion de base

Nous ajouterons ensuite du code d'authentification Firebase de base à l'application pour détecter les utilisateurs et implémenter un écran de connexion.

Vérifier l'utilisateur actuel

Ajoutez d’abord la variable d’instance suivante à la classe MainActivity.kt :

MainActivity.kt

// Firebase instance variables
private lateinit var auth: FirebaseAuth

Modifions maintenant MainActivity pour envoyer l'utilisateur vers l'écran de connexion chaque fois qu'il ouvre l'application et n'est pas authentifié. Ajoutez ce qui suit à la méthode onCreate() une fois la binding attachée à la vue :

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
}

Nous voulons également vérifier si l'utilisateur est connecté pendant 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
    }
}

Implémentez ensuite les méthodes getUserPhotoUrl() et getUserName() pour renvoyer les informations appropriées sur l'utilisateur Firebase actuellement authentifié :

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
}

Implémentez ensuite la méthode signOut() pour gérer le bouton de déconnexion :

MainActivity.kt

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

Nous avons désormais toute la logique en place pour envoyer l'utilisateur vers l'écran de connexion lorsque cela est nécessaire. Ensuite, nous devons implémenter l'écran de connexion pour authentifier correctement les utilisateurs.

Implémenter l'écran de connexion

Ouvrez le fichier SignInActivity.kt . Ici, un simple bouton de connexion est utilisé pour lancer l'authentification. Dans cette section, vous utiliserez FirebaseUI pour implémenter la logique de connexion.

Ajoutez une variable d'instance Auth dans la classe SignInActivity sous le commentaire // Firebase instance variables :

ConnexionActivity.kt

// Firebase instance variables
private lateinit var auth: FirebaseAuth

Ensuite, modifiez la méthode onCreate() pour initialiser Firebase de la même manière que vous l'avez fait dans MainActivity :

ConnexionActivity.kt

// Initialize FirebaseAuth
auth = Firebase.auth

Ajoutez un champ ActivityResultLauncher à SignInActivity :

ConnexionActivity.kt

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

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

Ensuite, modifiez la méthode onStart() pour lancer le flux de connexion FirebaseUI :

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

Ensuite, implémentez la méthode onSignInResult pour gérer le résultat de la connexion. Si le résultat de la connexion a réussi, continuez vers MainActivity :

ConnexionActivity.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)
        }
    }
}

C'est ça! Vous avez implémenté l'authentification avec FirebaseUI en seulement quelques appels de méthode et sans avoir à gérer de configuration côté serveur.

Testez votre travail

Exécutez l'application sur votre émulateur Android. Vous devriez être immédiatement redirigé vers l’écran de connexion. Appuyez sur le bouton Se connecter avec e-mail , puis créez un compte. Si tout est correctement mis en œuvre, vous devriez être envoyé à l’écran de messagerie.

Après vous être connecté, ouvrez l'interface utilisateur de Firebase Emulator Suite dans votre navigateur, puis cliquez sur l'onglet Authentification pour voir ce premier compte utilisateur connecté.

7. Lire les messages

Dans cette étape, nous ajouterons des fonctionnalités pour lire et afficher les messages stockés dans la base de données en temps réel.

Importer des exemples de messages

  1. Dans l'interface utilisateur de Firebase Emulator Suite, sélectionnez l'onglet Base de données en temps réel .
  2. Faites glisser et déposez le fichier initial_messages.json de votre copie locale du dépôt de l'atelier de programmation vers la visionneuse de données.

Vous devriez maintenant avoir quelques messages sous le nœud messages de la base de données.

Lire des données

Synchroniser les messages

Dans cette section, nous ajoutons du code qui synchronise les messages nouvellement ajoutés avec l'interface utilisateur de l'application en :

  • Initialisation de la base de données Firebase Realtime et ajout d'un écouteur pour gérer les modifications apportées aux données.
  • Mise à jour de l'adaptateur RecyclerView afin que les nouveaux messages soient affichés.
  • Ajout des variables d'instance de base de données avec vos autres variables d'instance Firebase dans la classe MainActivity :

MainActivity.kt

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

Modifiez la méthode onCreate() de votre MainActivity sous le commentaire // Initialize Realtime Database and FirebaseRecyclerAdapter avec le code défini ci-dessous. Ce code ajoute tous les messages existants de la base de données en temps réel, puis écoute les nouvelles entrées enfants sous le chemin messages dans votre base de données en temps réel Firebase. Il ajoute un nouvel élément à l'interface utilisateur pour chaque message :

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

Ensuite, dans la classe FriendlyMessageAdapter.kt , implémentez la méthode bind() dans la classe interne 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)
        }
    }
    ...
}

Nous devons également afficher des messages qui sont des images, donc également implémenter la méthode bind() dans la classe interne 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)
        }
    }
}

Enfin, de retour dans MainActivity , démarrez et arrêtez d'écouter les mises à jour de Firebase Realtime Database. Mettez à jour les méthodes onPause() et onResume() dans MainActivity comme indiqué ci-dessous :

MainActivity.kt

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

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

Tester la synchronisation des messages

  1. Cliquez sur Exécuter ( exécuter ).
  2. Dans l’interface utilisateur d’Emulator Suite, revenez à l’onglet Base de données en temps réel , puis ajoutez manuellement un nouveau message. Confirmez que le message s'affiche dans votre application Android :

Félicitations, vous venez d'ajouter une base de données en temps réel à votre application !

8. Envoyer des messages

Implémenter l’envoi de SMS

Dans cette section, vous ajouterez la possibilité pour les utilisateurs de l'application d'envoyer des messages texte. L'extrait de code ci-dessous écoute les événements de clic sur le bouton d'envoi, crée un nouvel objet FriendlyMessage avec le contenu du champ de message et transmet le message à la base de données. La méthode push() ajoute un identifiant généré automatiquement au chemin de l'objet poussé. Ces identifiants sont séquentiels, ce qui garantit que les nouveaux messages seront ajoutés à la fin de la liste.

Mettez à jour l'écouteur de clics du bouton d'envoi dans la méthode onCreate() de la classe MainActivity . Ce code se trouve déjà au bas de la méthode onCreate() . Mettez à jour le corps onClick() pour qu'il corresponde au code ci-dessous :

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

Implémenter l'envoi de messages image

Dans cette section, vous ajouterez la possibilité pour les utilisateurs de l'application d'envoyer des messages image. La création d'un message image se fait en suivant ces étapes :

  • Sélectionner une image
  • Gérer la sélection d'images
  • Écrire un message d'image temporaire dans la base de données en temps réel
  • Commencer à télécharger l'image sélectionnée
  • Mettez à jour l'URL du message image avec celle de l'image téléchargée, une fois le téléchargement terminé.

Sélectionnez une image

Pour ajouter des images, cet atelier de programmation utilise Cloud Storage pour Firebase. Cloud Storage est un bon endroit pour stocker les données binaires de votre application.

Gérer la sélection d'images et écrire un message temporaire

Une fois que l’utilisateur a sélectionné une image, l’ Intent de sélection d’image est lancée. Ceci est déjà implémenté dans le code à la fin de la méthode onCreate() . Une fois terminé, il appelle la méthode onImageSelected() de MainActivity . À l'aide de l'extrait de code ci-dessous, vous écrirez un message avec une URL d'image temporaire dans la base de données indiquant que l'image est en cours de téléchargement.

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

Télécharger l'image et mettre à jour le message

Ajoutez la méthode putImageInStorage() à MainActivity . Il est appelé dans onImageSelected() pour lancer le téléchargement de l'image sélectionnée. Une fois le téléchargement terminé, vous mettrez à jour le message pour utiliser l'image appropriée.

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

Tester l'envoi de messages

  1. Dans Android Studio, cliquez sur le bouton exécuter Bouton Exécuter .
  2. Dans votre émulateur Android, saisissez un message, puis appuyez sur le bouton Envoyer. Le nouveau message doit être visible dans l'interface utilisateur de l'application et dans l'interface utilisateur de Firebase Emulator Suite.
  3. Dans l'émulateur Android, appuyez sur l'image « + » pour sélectionner une image sur votre appareil. Le nouveau message doit être visible d'abord avec une image d'espace réservé, puis avec l'image sélectionnée une fois le téléchargement de l'image terminé. Le nouveau message doit également être visible dans l'interface utilisateur d'Emulator Suite, notamment en tant qu'objet dans l'onglet Base de données en temps réel et en tant que blob dans l'onglet Stockage.

9. Félicitations !

Vous venez de créer une application de chat en temps réel à l'aide de Firebase !

Ce que tu as appris

  • Authentification Firebase
  • Base de données en temps réel Firebase
  • Stockage cloud pour Firebase

Ensuite, essayez d'utiliser ce que vous avez appris dans cet atelier de programmation pour ajouter Firebase à votre propre application Android ! Pour en savoir plus sur Firebase, visitez firebase.google.com .

Si vous souhaitez apprendre à configurer un vrai projet Firebase et à utiliser de vraies ressources Firebase (au lieu d'un projet de démonstration et uniquement des ressources émulées), passez à l'étape suivante.

Remarque : Même après avoir configuré un véritable projet Firebase et surtout lorsque vous avez commencé à créer une véritable application, nous vous recommandons d'utiliser la suite d'émulateurs locaux Firebase pour le développement et les tests.

10. Facultatif : créer et configurer un projet Firebase

Au cours de cette étape, vous allez créer un véritable projet Firebase et une application Android Firebase à utiliser avec cet atelier de programmation. Vous ajouterez également la configuration Firebase spécifique à votre application. Et enfin, vous configurerez de véritables ressources Firebase à utiliser avec votre application.

Créer un projet Firebase

  1. Dans votre navigateur, accédez à la console Firebase .
  2. Sélectionnez Ajouter un projet .
  3. Sélectionnez ou saisissez un nom de projet. Vous pouvez utiliser le nom de votre choix.
  4. Vous n'avez pas besoin de Google Analytics pour cet atelier de programmation. Vous pouvez donc ignorer son activation pour votre projet.
  5. Cliquez sur Créer un projet . Lorsque votre projet est prêt, cliquez sur Continuer .

Ajoutez Firebase à votre projet Android

Avant de commencer cette étape, récupérez le hachage SHA1 de votre application. Exécutez la commande suivante à partir de votre répertoire local build-android-start pour déterminer le SHA1 de votre clé de débogage :

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

Vous devriez voir une sortie comme celle ci-dessus. La ligne importante est le hachage SHA1 . Si vous ne parvenez pas à trouver votre hachage SHA1, consultez cette page pour plus d'informations.

Revenez à la console Firebase et suivez ces étapes pour enregistrer votre projet Android auprès de votre projet Firebase :

  1. Depuis l'écran de présentation de votre nouveau projet, cliquez sur l'icône Android pour lancer le workflow de configuration : ajouter une application Android
  2. Sur l'écran suivant, saisissez com.google.firebase.codelab.friendlychat comme nom de package pour votre application.
  3. Cliquez sur Register App , puis sur Download google-services.json pour télécharger votre fichier de configuration Firebase.
  4. Copiez le fichier google-services.json dans le répertoire app de votre projet Android.
  5. Ignorez les étapes suivantes affichées dans le flux de travail de configuration de la console (elles ont déjà été effectuées pour vous dans le projet build-android-start ).
  6. Assurez-vous que toutes les dépendances sont disponibles pour votre application en synchronisant votre projet avec les fichiers Gradle. Dans la barre d'outils Android Studio, sélectionnez Fichier > Synchroniser le projet avec les fichiers Gradle . Vous devrez peut-être également exécuter Build/Clean Project et Build/Rebuild Project pour que les modifications de configuration aient lieu.

Configurer l'authentification Firebase

Avant que votre application puisse accéder aux API d'authentification Firebase au nom de vos utilisateurs, vous devez activer l'authentification Firebase et les fournisseurs de connexion que vous souhaitez utiliser dans votre application.

  1. Dans la console Firebase , sélectionnez Authentification dans le panneau de navigation de gauche.
  2. Sélectionnez l'onglet Méthode de connexion .
  3. Cliquez sur E-mail/Mot de passe , puis basculez le commutateur sur activé (bleu).
  4. Cliquez sur Google , puis basculez le commutateur sur activé (bleu) et définissez un e-mail d'assistance au projet.

Si vous obtenez des erreurs plus tard dans cet atelier de programmation avec le message "CONFIGURATION_NOT_FOUND", revenez à cette étape et vérifiez votre travail.

Configurer la base de données en temps réel

L'application de cet atelier de programmation stocke les messages de discussion dans la base de données Firebase Realtime. Dans cette section, nous allons créer une base de données et configurer sa sécurité via un langage de configuration JSON appelé Firebase Security Rules.

  1. Dans la console Firebase , sélectionnez Base de données en temps réel dans le panneau de navigation de gauche.
  2. Cliquez sur Créer une base de données pour créer une nouvelle instance de base de données en temps réel. Lorsque vous y êtes invité, sélectionnez la région us-central1 , puis cliquez sur Suivant .
  3. Lorsque vous êtes invité à connaître les règles de sécurité, choisissez le mode verrouillé , puis cliquez sur Activer .
  4. Une fois l'instance de base de données créée, sélectionnez l'onglet Règles , puis mettez à jour la configuration des règles avec ce qui suit :
     {
   "rules": {
     "messages": {
       ".read": "auth.uid != null",
       ".write": "auth.uid != null"
     }
   }
 }

Pour plus d'informations sur le fonctionnement des règles de sécurité (y compris la documentation sur la variable « auth »), consultez la documentation sur la sécurité de la base de données en temps réel .

Configurer le stockage cloud pour Firebase

  1. Dans la console Firebase , sélectionnez Stockage dans le panneau de navigation de gauche.
  2. Cliquez sur Commencer pour activer Cloud Storage pour votre projet.
  3. Suivez les étapes de la boîte de dialogue pour configurer votre bucket, en utilisant les valeurs par défaut suggérées.

Se connecter aux ressources Firebase

Dans une étape précédente de cet atelier de programmation, vous avez ajouté les éléments suivants à MainActivity.kt . Ce bloc conditionnel a connecté votre projet Android à 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)
}

Si vous souhaitez connecter votre application à votre nouveau projet Firebase réel et à ses ressources Firebase réelles , vous pouvez soit supprimer ce bloc, soit exécuter votre application en mode release afin que BuildConfig.DEBUG soit false .