Google se compromete a impulsar la igualdad racial para las comunidades afrodescendientes. Obtén información al respecto.

Firebase Android Codelab: crea un chat amigable

captura de pantalla

Imagen: Aplicación Working Friendly Chat.

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

Lo que aprenderás

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

Lo que necesitarás

  • Android Studio versión 4.2+.
  • Un emulador de Android con Android 5.0+.
  • Java 7 o superior. Para instalar Java, utilice estas instrucciones ; para comprobar su versión, ejecute java -version .
  • Familiaridad con el lenguaje de programación Kotlin.

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 , luego seleccione el directorio build-android-start ( android_studio_folder ) 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.

Verificar dependencias

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

build.gradle

buildscript {
    // ...

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

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

app / build.gradle

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

android {
    // ...
}

dependencies {
    // ...

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

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

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

Para ejecutar Firebase Emulator Suite , debe instalar y usar Firebase CLI .

Instale la CLI

Opción 1: instalar con npm

Si ya tiene Node.js y npm instalados en su máquina, puede instalar la CLI con el siguiente comando:

npm install -g firebase-tools@latest

Opción 2: instalar binario independiente

Si no tiene Node.js / npm o es nuevo en el desarrollo de aplicaciones, puede instalar la CLI como un binario independiente siguiendo las instrucciones para su plataforma aquí .

Verifique la instalación

Una vez que tenga Firebase CLI instalado, ejecute el siguiente comando para asegurarse de tener la versión 9.11.0 o superior:

firebase --version

Iniciar los emuladores

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

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

Debería 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 IU de Firebase Emulator Suite:

Inicio de la interfaz de usuario de Emulator Suite

Deje los emulators:start comando de emulators:start ejecución durante el resto del laboratorio de código.

Conecta tu aplicación

En Android Studio, abra MainActivity.kt , 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)
}

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 propósitos de este laboratorio de código, 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 laboratorio de código, aprenderá cómo crear un proyecto de Firebase real y una aplicación de Firebase para Android para que pueda reemplazar este archivo JSON simulado con su propia configuración.

Ejecutar 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 el envío y la recepción de mensajes no funcionarán. En el siguiente paso de este codelab, autenticará a los usuarios para que puedan usar el Chat amistoso.

Esta aplicación usará 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 Firebase Authentication y configuraremos las reglas de seguridad de Realtime Database.

Agregar funcionalidad básica de inicio de sesión

A continuación, agregaremos un código básico de autenticación de Firebase 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 :

MainActivity.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:

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
}

También queremos comprobar si el usuario ha onStart() 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
    }
}

Luego, implemente los getUserPhotoUrl() y getUserName() para devolver la información apropiada sobre el usuario de Firebase actualmente autenticado:

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
}

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

MainActivity.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 botón de inicio de sesión simple para iniciar la autenticación. En esta sección, usará FirebaseUI para implementar la lógica de inicio de sesión.

Agrega una variable de instancia de Auth en la clase SignInActivity debajo del comentario // Firebase instance variables :

SignInActivity.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 :

SignInActivity.kt

// Initialize FirebaseAuth
auth = Firebase.auth

Agregue un campo ActivityResultLauncher a SignInActivity :

SignInActivity.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:

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

A continuación, implemente el método onSignInResult para manejar el resultado del inicio de sesión. Si el resultado del MainActivity de MainActivity fue exitoso, continúe con 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)
        }
    }
}

¡Eso es! Ha implementado 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 está implementado 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.

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

Importar mensajes de muestra

  1. En la IU de Firebase Emulator Suite, seleccione la pestaña Realtime Database .
  2. Arrastre y suelte el archivo initial_messages.json de su copia local del repositorio de codelab en el visor de datos.

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

Leer datos

Sincronizar mensajes

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

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

MainActivity.kt

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

Modifica el método onCreate() de onCreate() en 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 las nuevas entradas secundarias en la ruta de los messages en tu Firebase Realtime Database. Agrega un nuevo elemento a la interfaz de usuario para cada mensaje:

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

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 son imágenes, así que también implementar 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 onPause() y onResume() en MainActivity como se muestra a continuación:

MainActivity.kt

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

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

Probar la sincronización de mensajes

  1. Haga clic en Ejecutar (ejecutar ).
  2. En la interfaz de usuario de Emulator Suite, regrese a la pestaña Realtime Database 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!

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 fragmento de código a continuación escucha los eventos de clic en el botón enviar, crea un nuevo objeto FriendlyMessage con el contenido del campo del 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 empujado. Estos ID son secuenciales, lo que garantiza que los nuevos mensajes se agreguen al final de la lista.

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

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

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 de imagen se realiza con estos pasos:

  • Seleccionar imagen
  • Manejar la selección de imágenes
  • Escribe un mensaje de imagen temporal en Realtime Database
  • 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 usa Cloud Storage para Firebase. Cloud Storage es un buen lugar para almacenar los datos binarios de su aplicación.

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

Una vez que el usuario ha seleccionado una imagen, se lanza la Intent selección de imágenes. Esto ya está implementado en el código al final del método onCreate() . Cuando termina, llama al MainActivity onImageSelected() . 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.

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

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.

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

Prueba de envío de mensajes

  1. En Android Studio, haga clic en elejecutar Botón Ejecutar .
  2. En su emulador de Android, ingrese un mensaje, luego toque el botón enviar. El nuevo mensaje debe 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 debe 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 estar visible en la interfaz de usuario de Emulator Suite, específicamente como un objeto en la pestaña Realtime Database y como un blob en la pestaña Almacenamiento.

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

Que has aprendido

  • Autenticación de Firebase
  • Firebase Realtime Database
  • Cloud Storage para Firebase

A continuación, intente usar lo que aprendió en este laboratorio de código para agregar Firebase a su propia aplicación de Android. Para obtener más información sobre Firebase, visite firebase.google.com .

Si desea aprender a configurar un proyecto de Firebase real y usar recursos de Firebase reales (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 de Firebase real y especialmente cuando comienza a crear una aplicación real, le recomendamos que utilice Firebase Local Emulator Suite para el desarrollo y las pruebas.

En este paso, creará un proyecto de Firebase real y una aplicación de Firebase para Android para usar con este laboratorio de código. También agregará la configuración de Firebase específica de su aplicación a su aplicación. Y finalmente, configurará recursos reales de Firebase para usar con su aplicación.

Crea un proyecto de Firebase

  1. En su navegador, vaya a la consola de Firebase .
  2. Seleccione Agregar proyecto .
  3. Seleccione o ingrese un nombre de proyecto. Puede utilizar el nombre que desee.
  4. No necesita Google Analytics para este codelab, por lo que puede omitir habilitarlo para su 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 build-android-start local 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ía ver un 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 icono 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 el nombre del paquete para su aplicación.
  3. Haga clic en Registrar aplicación , 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 han realizado 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 los archivos de Gradle. En la barra de herramientas de Android Studio, seleccione Archivo > Sincronizar proyecto con archivos Gradle .

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 , selecciona 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 , 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 del proyecto.

Si obtiene errores más adelante en este laboratorio de código con el mensaje "CONFIGURATION_NOT_FOUND", vuelva a este paso y vuelva a verificar su trabajo.

Configurar la base de datos en tiempo real

La aplicación en este laboratorio de código almacena los mensajes de chat en Firebase Realtime Database. En esta sección, crearemos una base de datos y configuraremos su seguridad a través de un lenguaje de configuración JSON llamado Reglas de seguridad de Firebase.

  1. En Firebase console , selecciona 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 Realtime Database. Cuando se le solicite, seleccione la región us-central1 , luego haga clic en Siguiente .
  3. Cuando se le pregunte acerca de las reglas de seguridad, elija el modo bloqueado y luego haga clic en Habilitar .
  4. Una vez que se ha creado la instancia de la base de datos, seleccione la pestaña Reglas , luego actualice la configuración de las 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 Cloud Storage 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, agregó 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 .