Firebase Android Codelab: crea un chat amigable

1. Información general

captura de pantalla

Imagen: Aplicación Work Friendly Chat.

Bienvenido al codelab de Friendly Chat. En este codelab, aprenderá cómo usar la plataforma Firebase para crear una aplicación de chat en Android.

lo que aprenderás

  • Cómo utilizar Firebase Authentication para permitir que los usuarios inicien sesión.
  • Cómo sincronizar datos usando Firebase Realtime Database.
  • Cómo almacenar archivos binarios en Cloud Storage para Firebase.
  • Cómo utilizar Firebase Local Emulator Suite para desarrollar una aplicación de Android con Firebase.

Lo que necesitarás

  • Última versión de Android Studio .
  • Un emulador de Android con Android 5.0+.
  • Node.js versión 10 o superior (para usar Emulator Suite).
  • Java 8 o superior. Para instalar Java utilice estas instrucciones ; para verificar su versión, ejecute java -version .
  • Familiaridad con el lenguaje de programación Kotlin.

2. Obtenga el código de muestra

Clonar el repositorio

Clona el repositorio de GitHub desde la línea de comando:

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

Importar a Android Studio

En Android Studio, seleccione Archivo > Abrir y luego seleccione el directorio build-android-start ( carpeta_android_studio ) del directorio donde descargó el código de muestra.

Ahora debería tener abierto el proyecto build-android-start en Android Studio. Si ve una advertencia sobre la falta de un archivo google-services.json , no se preocupe. Se agregará en un paso posterior.

Comprobar dependencias

En este codelab ya se han agregado todas las dependencias que necesitará, pero es importante comprender cómo agregar el SDK de Firebase a su aplicación:

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
}

aplicación/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. Instale Firebase CLI

En este codelab, utilizará Firebase Emulator Suite para emular localmente Firebase Auth, Realtime Database y Cloud Storage. Esto proporciona un entorno de desarrollo local seguro, rápido y sin costo para crear su aplicación.

Instale la CLI de Firebase

Primero deberá instalar Firebase CLI . Si está utilizando macOS o Linux, puede ejecutar el siguiente comando cURL:

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

Si está utilizando Windows, lea las instrucciones de instalación para obtener un binario independiente o instalarlo mediante npm .

Una vez que hayas instalado la CLI, ejecutar firebase --version debería informar una versión de 9.0.0 o superior:

$ firebase --version
9.0.0

Acceso

Ejecute firebase login para conectar la CLI a su cuenta de Google. Esto abrirá una nueva ventana del navegador para completar el proceso de inicio de sesión. Asegúrese de elegir la misma cuenta que utilizó anteriormente al crear su proyecto de Firebase.

4. Conéctese a Firebase Emulator Suite

Iniciar los emuladores

En su terminal, ejecute el siguiente comando desde la raíz de su directorio local codelab-friendlychat-android :

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

Deberías ver algunos registros como este. Los valores del puerto se definieron en el archivo firebase.json , que se incluyó en el código de muestra clonado.

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

Navegue a http://localhost:4000 en su navegador web para ver la interfaz de usuario de Firebase Emulator Suite:

Inicio de la interfaz de usuario de Emulator Suite

Deje el emulators:start ejecutándose durante el resto del codelab.

Conecta tu aplicación

En Android Studio, abra MainActivity.kt y luego agregue el siguiente código dentro del método 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. Ejecute la aplicación de inicio

Agregar google-services.json

Para que su aplicación de Android se conecte a Firebase, debe agregar un archivo google-services.json dentro de la carpeta de la app de su proyecto de Android. Para los fines de este codelab, proporcionamos un archivo JSON simulado que le permitirá conectarse a Firebase Emulator Suite.

Copie el archivo mock-google-services.json en la carpeta build-android-start/app como google-services.json :

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

En el paso final de este codelab, aprenderá cómo crear un proyecto Firebase real y una aplicación Firebase para Android para que pueda reemplazar este archivo JSON simulado con su propia configuración.

Ejecute la aplicación

Ahora que importó el proyecto a Android Studio y agregó un archivo JSON de configuración de Firebase, está listo para ejecutar la aplicación por primera vez.

  1. Inicie su emulador de Android.
  2. En Android Studio, haga clic en Ejecutar ( ejecutar ) en la barra de herramientas.

La aplicación debería iniciarse en su emulador de Android. En este punto, debería ver una lista de mensajes vacía y enviar y recibir mensajes no funcionará. En el siguiente paso de este codelab, autenticará a los usuarios para que puedan usar Friendly Chat.

6. Habilite la autenticación

Esta aplicación utilizará Firebase Realtime Database para almacenar todos los mensajes de chat. Sin embargo, antes de agregar datos, debemos asegurarnos de que la aplicación sea segura y que solo los usuarios autenticados puedan publicar mensajes. En este paso, habilitaremos la autenticación de Firebase y configuraremos las reglas de seguridad de la base de datos en tiempo real.

Agregar funcionalidad de inicio de sesión básica

A continuación, agregaremos un código de autenticación de Firebase básico a la aplicación para detectar usuarios e implementar una pantalla de inicio de sesión.

Verificar usuario actual

Primero agregue la siguiente variable de instancia a la clase MainActivity.kt :

Actividad principal.kt

// Firebase instance variables
private lateinit var auth: FirebaseAuth

Ahora modifiquemos MainActivity para enviar al usuario a la pantalla de inicio de sesión cada vez que abra la aplicación y no esté autenticado. Agregue lo siguiente al método onCreate() después de adjuntar el binding a la vista:

Actividad principal.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
}

También queremos verificar si el usuario inició sesión durante onStart() :

Actividad principal.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
    }
}

Luego implemente los métodos getUserPhotoUrl() y getUserName() para devolver la información adecuada sobre el usuario de Firebase actualmente autenticado:

Actividad principal.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
}

Luego implemente el método signOut() para manejar el botón de cerrar sesión:

Actividad principal.kt

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

Ahora tenemos toda la lógica para enviar al usuario a la pantalla de inicio de sesión cuando sea necesario. A continuación, debemos implementar la pantalla de inicio de sesión para autenticar correctamente a los usuarios.

Implementar la pantalla de inicio de sesión

Abra el archivo SignInActivity.kt . Aquí se utiliza un simple botón de inicio de sesión para iniciar la autenticación. En esta sección, utilizará FirebaseUI para implementar la lógica de inicio de sesión.

Agregue una variable de instancia de Auth en la clase SignInActivity bajo el comentario // Firebase instance variables :

Iniciar sesiónActividad.kt

// Firebase instance variables
private lateinit var auth: FirebaseAuth

Luego, edite el método onCreate() para inicializar Firebase de la misma manera que lo hizo en MainActivity :

Iniciar sesiónActividad.kt

// Initialize FirebaseAuth
auth = Firebase.auth

Agregue un campo ActivityResultLauncher a SignInActivity :

Iniciar sesiónActividad.kt

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

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

A continuación, edite el método onStart() para iniciar el flujo de inicio de sesión de FirebaseUI:

Iniciar sesiónActividad.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()
    }
}

A continuación, implemente el método onSignInResult para controlar el resultado del inicio de sesión. Si el resultado del inicio de sesión fue exitoso, continúe con MainActivity :

Iniciar sesiónActividad.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)
        }
    }
}

¡Eso es todo! Implementó la autenticación con FirebaseUI en solo unas pocas llamadas a métodos y sin necesidad de administrar ninguna configuración del lado del servidor.

Pon a prueba tu trabajo

Ejecute la aplicación en su emulador de Android. Debería ser enviado inmediatamente a la pantalla de inicio de sesión. Toque el botón Iniciar sesión con correo electrónico y luego cree una cuenta. Si todo se implementa correctamente, debería ser enviado a la pantalla de mensajería.

Después de iniciar sesión, abra la interfaz de usuario de Firebase Emulator Suite en su navegador, luego haga clic en la pestaña Autenticación para ver esta primera cuenta de usuario que inició sesión.

7. Leer mensajes

En este paso, agregaremos funcionalidad para leer y mostrar mensajes almacenados en Realtime Database.

Importar mensajes de muestra

  1. En la interfaz de usuario de Firebase Emulator Suite, seleccione la pestaña Base de datos en tiempo real .
  2. Arrastre y suelte el archivo initial_messages.json desde su copia local del repositorio de codelab en el visor de datos.

Ahora debería tener algunos mensajes en el nodo messages de la base de datos.

leer datos

Sincronizar mensajes

En esta sección agregamos código que sincroniza los mensajes recién agregados con la interfaz de usuario de la aplicación mediante:

  • Inicializar Firebase Realtime Database y agregar un oyente para manejar los cambios realizados en los datos.
  • Actualizando el adaptador RecyclerView para que se muestren nuevos mensajes.
  • Agregar las variables de instancia de la base de datos con sus otras variables de instancia de Firebase en la clase MainActivity :

Actividad principal.kt

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

Modifique el método onCreate() de su MainActivity bajo el comentario // Initialize Realtime Database and FirebaseRecyclerAdapter con el código definido a continuación. Este código agrega todos los mensajes existentes de Realtime Database y luego escucha nuevas entradas secundarias en la ruta messages en Firebase Realtime Database. Agrega un nuevo elemento a la interfaz de usuario para cada mensaje:

Actividad principal.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)
)

A continuación, en la clase FriendlyMessageAdapter.kt implemente el método bind() dentro de la clase 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)
        }
    }
    ...
}

También necesitamos mostrar mensajes que sean imágenes, así que implemente también el método bind() dentro de la clase 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)
        }
    }
}

Finalmente, de vuelta en MainActivity , comience y deje de escuchar las actualizaciones de Firebase Realtime Database. Actualice los métodos onPause() y onResume() en MainActivity como se muestra a continuación:

Actividad principal.kt

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

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

Probar mensajes de sincronización

  1. Haga clic en Ejecutar ( ejecutar ).
  2. En la interfaz de usuario de Emulator Suite, regrese a la pestaña Base de datos en tiempo real y luego agregue manualmente un mensaje nuevo. Confirma que el mensaje aparece en tu aplicación de Android:

¡Felicitaciones, acaba de agregar una base de datos en tiempo real a su aplicación!

8. Enviar mensajes

Implementar el envío de mensajes de texto

En esta sección, agregará la capacidad para que los usuarios de la aplicación envíen mensajes de texto. El siguiente fragmento de código escucha eventos de clic en el botón de enviar, crea un nuevo objeto FriendlyMessage con el contenido del campo de mensaje y envía el mensaje a la base de datos. El método push() agrega una ID generada automáticamente a la ruta del objeto enviado. Estos ID son secuenciales, lo que garantiza que los nuevos mensajes se agregarán al final de la lista.

Actualice el detector de clics del botón de enviar en el método onCreate() en la clase MainActivity . Este código ya se encuentra en la parte inferior del método onCreate() . Actualice el cuerpo onClick() para que coincida con el siguiente código:

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

Implementar el envío de mensajes de imagen.

En esta sección, agregará la capacidad para que los usuarios de la aplicación envíen mensajes con imágenes. La creación de un mensaje con imagen se realiza con estos pasos:

  • Seleccionar imagen
  • Manejar la selección de imágenes
  • Escribir mensaje de imagen temporal en la base de datos en tiempo real
  • Comenzar a cargar la imagen seleccionada
  • Actualice la URL del mensaje de imagen a la de la imagen cargada, una vez que se complete la carga

Seleccionar imagen

Para agregar imágenes, este codelab utiliza Cloud Storage para Firebase. Cloud Storage es un buen lugar para almacenar los datos binarios de tu aplicación.

Manejar la selección de imágenes y escribir mensajes temporales.

Una vez que el usuario ha seleccionado una imagen, se inicia la Intent de selección de imágenes. Esto ya está implementado en el código al final del método onCreate() . Cuando termina, llama al método onImageSelected() de MainActivity . Usando el fragmento de código a continuación, escribirá un mensaje con una URL de imagen temporal en la base de datos indicando que la imagen se está cargando.

Actividad principal.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)
                    })
}

Subir imagen y actualizar mensaje

Agregue el método putImageInStorage() a MainActivity . Se llama en onImageSelected() para iniciar la carga de la imagen seleccionada. Una vez que se complete la carga, actualizará el mensaje para usar la imagen adecuada.

Actividad principal.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
            )
        }
}

Prueba de envío de mensajes

  1. En Android Studio, haga clic en el ejecutar Botón ejecutar .
  2. En su emulador de Android, ingrese un mensaje y luego toque el botón enviar. El nuevo mensaje debería estar visible en la interfaz de usuario de la aplicación y en la interfaz de usuario de Firebase Emulator Suite.
  3. En el emulador de Android, toque la imagen "+" para seleccionar una imagen de su dispositivo. El nuevo mensaje debería ser visible primero con una imagen de marcador de posición y luego con la imagen seleccionada una vez que se complete la carga de la imagen. El nuevo mensaje también debería ser visible en la interfaz de usuario de Emulator Suite, específicamente como un objeto en la pestaña Base de datos en tiempo real y como un blob en la pestaña Almacenamiento.

9. ¡Felicitaciones!

¡Acabas de crear una aplicación de chat en tiempo real con Firebase!

Que has aprendido

  • Autenticación de base de fuego
  • Base de datos en tiempo real de Firebase
  • Almacenamiento en la nube para Firebase

A continuación, intenta usar lo que aprendiste en este codelab para agregar Firebase a tu propia aplicación de Android. Para obtener más información sobre Firebase, visite firebase.google.com .

Si desea aprender cómo configurar un proyecto real de Firebase y utilizar recursos reales de Firebase (en lugar de un proyecto de demostración y solo recursos emulados), continúe con el siguiente paso.

Nota: Incluso después de configurar un proyecto real de Firebase y especialmente cuando comienzas a crear una aplicación real, te recomendamos usar Firebase Local Emulator Suite para el desarrollo y las pruebas.

10. Opcional: cree y configure un proyecto de Firebase

En este paso, creará un proyecto de Firebase real y una aplicación de Firebase para Android para usar con este codelab. También agregará la configuración de Firebase específica de su aplicación. Y, por último, configurará recursos reales de Firebase para usarlos con su aplicación.

Crear un proyecto de Firebase

  1. En tu navegador, ve a Firebase console .
  2. Seleccione Agregar proyecto .
  3. Seleccione o ingrese un nombre de proyecto. Puedes usar cualquier nombre que quieras.
  4. No necesitas Google Analytics para este codelab, por lo que puedes omitir habilitarlo para tu proyecto.
  5. Haga clic en Crear proyecto . Cuando su proyecto esté listo, haga clic en Continuar .

Agrega Firebase a tu proyecto de Android

Antes de comenzar este paso, obtenga el hash SHA1 de su aplicación. Ejecute el siguiente comando desde su directorio local build-android-start para determinar el SHA1 de su clave de depuración:

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

Deberías ver algún resultado como el anterior. La línea importante es el hash SHA1 . Si no puede encontrar su hash SHA1, consulte esta página para obtener más información.

Regrese a la consola de Firebase y siga estos pasos para registrar su proyecto de Android con su proyecto de Firebase:

  1. Desde la pantalla de descripción general de su nuevo proyecto, haga clic en el ícono de Android para iniciar el flujo de trabajo de configuración: agregar aplicación de Android
  2. En la siguiente pantalla, ingrese com.google.firebase.codelab.friendlychat como nombre del paquete para su aplicación.
  3. Haga clic en Registrar aplicación y luego haga clic en Descargar google-services.json para descargar su archivo de configuración de Firebase.
  4. Copie el archivo google-services.json en el directorio de la app de su proyecto de Android.
  5. Omita los siguientes pasos que se muestran en el flujo de trabajo de configuración de la consola (ya se realizaron en el proyecto build-android-start ).
  6. Asegúrese de que todas las dependencias estén disponibles para su aplicación sincronizando su proyecto con archivos Gradle. En la barra de herramientas de Android Studio, seleccione Archivo > Sincronizar proyecto con archivos Gradle . Es posible que también necesite ejecutar Build/Clean Project y Build/Rebuild Project para que se realicen los cambios de configuración.

Configurar la autenticación de Firebase

Antes de que su aplicación pueda acceder a las API de Firebase Authentication en nombre de sus usuarios, debe habilitar Firebase Authentication y los proveedores de inicio de sesión que desea usar en su aplicación.

  1. En Firebase console , seleccione Autenticación en el panel de navegación del lado izquierdo.
  2. Seleccione la pestaña Método de inicio de sesión .
  3. Haga clic en Correo electrónico/Contraseña y luego cambie el interruptor a habilitado (azul).
  4. Haga clic en Google , luego cambie el interruptor a habilitado (azul) y configure un correo electrónico de soporte para el proyecto.

Si recibes errores más adelante en este codelab con el mensaje "CONFIGURATION_NOT_FOUND", vuelve a este paso y vuelve a verificar tu trabajo.

Configurar la base de datos en tiempo real

La aplicación de este codelab almacena mensajes de chat en Firebase Realtime Database. En esta sección, crearemos una base de datos y configuraremos su seguridad mediante un lenguaje de configuración JSON llamado Firebase Security Rules.

  1. En Firebase console , seleccione Realtime Database en el panel de navegación del lado izquierdo.
  2. Haga clic en Crear base de datos para crear una nueva instancia de base de datos en tiempo real. Cuando se le solicite, seleccione la región us-central1 y luego haga clic en Siguiente .
  3. Cuando se le solicite información sobre las reglas de seguridad, elija el modo bloqueado y luego haga clic en Habilitar .
  4. Una vez que se haya creado la instancia de la base de datos, seleccione la pestaña Reglas , luego actualice la configuración de reglas con lo siguiente:
     {
       "rules": {
         "messages": {
           ".read": "auth.uid != null",
           ".write": "auth.uid != null"
         }
       }
     }
    

Para obtener más información sobre cómo funcionan las reglas de seguridad (incluida la documentación sobre la variable "auth"), consulte la documentación de seguridad de Realtime Database .

Configurar el almacenamiento en la nube para Firebase

  1. En Firebase console , selecciona Almacenamiento en el panel de navegación del lado izquierdo.
  2. Haga clic en Comenzar para habilitar Cloud Storage para su proyecto.
  3. Siga los pasos del cuadro de diálogo para configurar su depósito, utilizando los valores predeterminados sugeridos.

Conéctese a los recursos de Firebase

En un paso anterior de este codelab, agregaste lo siguiente a MainActivity.kt . Este bloque condicional conectó su proyecto de 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)
}

Si desea conectar su aplicación a su nuevo proyecto real de Firebase y sus recursos reales de Firebase, puede eliminar este bloque o ejecutar su aplicación en modo de lanzamiento para que BuildConfig.DEBUG sea false .