Firebase Android Codelab - Cree un chat amigable

1. Información general

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 usando 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 use 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 , luego seleccione el directorio build-android-start ( carpeta_estudio_de_android ) 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 laboratorio de programación, ya se agregaron todas las dependencias que necesitará, pero es importante comprender cómo agregar el SDK de Firebase a su aplicación:

construir.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'
    }
}

aplicación/construir.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'
}

3. Instale la CLI de Firebase

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

Instalar 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í .

Comprobar instalación

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

firebase --version

4. Conéctese a la suite de emuladores de Firebase

Inicie los emuladores

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

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 interfaz de usuario de Emulator Suite

Deje el comando emulators:start ejecutándose 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)
}

5. Ejecute la aplicación de inicio

Agregue 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 laboratorio de programación, 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 programación, aprenderá a crear un proyecto de Firebase real y una aplicación de Android de Firebase 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 el envío y la recepción de mensajes no funcionarán. En el siguiente paso de este laboratorio de programación, autenticará a los usuarios para que puedan usar el chat amistoso.

6. Habilitar 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 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 iniciado sesión 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 adecuada sobre el usuario de Firebase autenticado actualmente:

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 cierre de 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 simple botón de inicio de sesión para iniciar la autenticación. En esta sección, usará FirebaseUI para implementar la lógica para iniciar 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 de inicio de sesión. Si el resultado del inicio de sesión 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 todo! Ha implementado la autenticación con FirebaseUI en solo unas pocas llamadas de método 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 , 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 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:

  • Inicializar Firebase Realtime Database y agregar un oyente para manejar los cambios realizados en los datos.
  • Actualización del adaptador RecyclerView para que se muestren los mensajes nuevos.
  • Agregar 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

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 de messages en su 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 implemente 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 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()
}

Prueba de sincronización de mensajes

  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. Confirme que el mensaje aparece en su 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 fragmento de código siguiente escucha los eventos de clic en el botón de envío, 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 agregarán al final de la lista.

Actualice el detector de clics del botón de envío 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 onClick() para que coincida con el siguiente código:

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
  • Escriba un 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 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 un mensaje temporal

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

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

Probar el 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 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

Luego, 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 obtener información sobre cómo 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 real de Firebase y, especialmente , cuando comienza a crear una aplicación real, le recomendamos que utilice Firebase Local Emulator Suite para el desarrollo y las pruebas.

10. Opcional: crea y configura un proyecto de Firebase

En este paso, creará un proyecto de Firebase real y una aplicación de Android de Firebase para usar con este laboratorio de programación. 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.

Crear 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. Puedes usar cualquier nombre que quieras.
  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 .

Agregue Firebase a su 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 una salida como la 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.

Vuelva 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: añadir 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 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 . Es posible que también deba 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 autenticación de Firebase en nombre de sus usuarios, debe habilitar la autenticación de Firebase 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 , luego cambie el interruptor a activado (azul).
  4. Haga clic en Google , luego cambie el interruptor a habilitado (azul) y configure un correo electrónico de soporte del proyecto.

Si recibe 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 base de datos en tiempo real

La aplicación en este codelab almacena 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 denominado Reglas de seguridad de Firebase.

  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 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 haya 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 almacenamiento en la nube para Firebase

  1. En Firebase console , seleccione 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 laboratorio de programación, 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 .