Firebase Android Codelab: crea 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 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 y versiones posteriores.
  • Un emulador de Android con Android 5.0 o superior.
  • Java 7 o superior. Para instalar Java utilizan estas instrucciones ; Para comprobar la versión, ejecución java -version .
  • Familiaridad con el lenguaje de programación Kotlin.

2. Obtén 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, a continuación, seleccione la build-android-start directorio ( android_studio_folder ) del directorio donde descargó el código de muestra.

Ahora debe tener la build-android-start proyecto abierto en Android Studio. Si ve una advertencia sobre un google-services.json archivo que falta, 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'
}

3. Instala Firebase CLI

Con el fin de ejecutar el Firebase emulador suite , es necesario instalar y utilizar el 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 usted no tiene Node.js / NPM o eres nuevo en el desarrollo de aplicaciones, puede instalar la CLI como un binario independiente siguiendo las instrucciones correspondientes a su plataforma de aquí .

Verifique la instalación

Una vez que tenga instalada la base del fuego CLI, ejecute el siguiente comando para asegurarse de que tiene la versión 9.11.0 o superior:

firebase --version

4. Conéctese a Firebase Emulator Suite

Iniciar los emuladores

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

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

Debería ver algunos registros como este. Los valores de puerto se definieron en el firebase.json archivo, que fue incluido en el código de ejemplo 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.

Vaya a http: // localhost: 4000 en su navegador web para acceder a la base del fuego emulador Suite de interfaz de usuario:

Inicio de la interfaz de usuario de Emulator Suite

Deja los emulators:start comandos de funcionamiento para el resto del laboratorio de programación.

Conecta tu aplicación

En Android de estudio, abierto MainActivity.kt , a continuación, añadir el siguiente código dentro de la onCreate método:

// 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 la aplicación de Android para conectarse a Firebase, debe agregar un google-services.json archivo dentro de la app de carpeta de su proyecto Android. Para los propósitos de este laboratorio de código, proporcionamos un archivo JSON simulado que le permitirá conectarse a Firebase Emulator Suite.

Copiar la mock-google-services.json archivo en la build-android-start/app carpeta 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á a 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.

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 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 se debe agregar la siguiente variable de instancia a la MainActivity.kt clase:

MainActivity.kt

// Firebase instance variables
private lateinit var auth: FirebaseAuth

Ahora vamos a modificar MainActivity para enviar al usuario a la pantalla de acceso cada vez que abran la aplicación y son no autenticado. Añadir lo siguiente a la onCreate() método después de la binding está unido 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 en 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
    }
}

A continuación, poner en práctica el getUserPhotoUrl() y getUserName() métodos para devolver la información adecuada sobre el usuario autenticado actualmente Firebase:

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
}

A continuación, poner en práctica el signOut() método para manejar el botón 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.

Añadir una variable de instancia de autenticación en el SignInActivity clase bajo la // Firebase instance variables comentario:

SignInActivity.kt

// Firebase instance variables
private lateinit var auth: FirebaseAuth

A continuación, editar el onCreate() método para inicializar Firebase de la misma manera que lo hizo en MainActivity :

SignInActivity.kt

// Initialize FirebaseAuth
auth = Firebase.auth

Añadir un ActivityResultLauncher campo para SignInActivity :

SignInActivity.kt

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

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

A continuación, editar el onStart() método para poner en marcha el signo FirebaseUI de flujo:

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, poner en práctica el onSignInResult método para manejar la señal en consecuencia. Si el resultado de la signin tuvo éxito, seguir 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 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. Pulse en el botón Iniciar sesión con el correo electrónico, a continuación, crear 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 base del fuego emulador Suite de interfaz de usuario en el navegador, a continuación, haga clic en la ficha Autenticación para ver esta primera sesión iniciada cuenta de usuario.

7. Leer mensajes

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

Importar mensajes de muestra

  1. En la base del fuego emulador Suite de interfaz de usuario, seleccione la ficha Base de datos en tiempo real.
  2. Arrastrar y soltar el initial_messages.json fichero de su copia local del repositorio codelab en el visor de datos.

Ahora debe tener un par de mensajes bajo el messages nodo 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.
  • Actualización de la RecyclerView adaptador de manera que se mostrarán los mensajes nuevos.
  • La adición de las variables de instancia de base de datos con sus otras variables de instancia en la base de fuego MainActivity clase:

MainActivity.kt

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

Modificar de su MainActivity onCreate() método en el comentario // Initialize Realtime Database and FirebaseRecyclerAdapter con el código se define a continuación. Este código agrega todos los mensajes existentes de la base de datos en tiempo real y luego escucha para nuevas entradas de niño de menos messages de ruta en su base de datos en tiempo real Firebase. 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 FriendlyMessageAdapter.kt clase implementar el bind() método 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 a los mensajes de visualización que sean imágenes, así también implementar el bind() método 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)
        }
    }
}

Por último, de vuelta en MainActivity , iniciar y detener la espera de actualizaciones en tiempo real de Firebase base de datos. Actualización de la onPause() y onResume() métodos 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 el emulador Suite de interfaz de usuario, vuelva a la ficha Base de datos en tiempo real, a continuación, añadir manualmente un nuevo mensaje. 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 escuchas de eventos de clic en el botón Enviar, crea un nuevo FriendlyMessage objeto con el contenido del campo del mensaje, y empuja el mensaje a la base de datos. El push() método añade un ID generado automáticamente para el trazado del objeto empujado. Estos ID son secuenciales, lo que garantiza que los nuevos mensajes se agreguen al final de la lista.

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

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, la selección de imagen Intent se puso en marcha. Esto ya está implementada en el código al final de la onCreate() método. Cuando haya terminado llama al MainActivity 's onImageSelected() método. 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

Añadir el método putImageInStorage() a MainActivity . Se le 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.

9. ¡Felicitaciones!

¡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 quieres aprender cómo configurar un proyecto real Firebase y el uso de los recursos base de fuego reales (en lugar de un proyecto de demostración y los recursos sólo se emulados), continúe con el siguiente paso.

Nota: Incluso después de configurar un proyecto Firebase real y sobre todo cuando a empezar la construcción de una aplicación real, se recomienda utilizar el emulador suite Firebase local para el desarrollo y pruebas.

10. Opcional: crea y configura 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 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 el navegador, vaya a la consola Firebase .
  2. Elija un proyecto de complemento.
  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 el 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 el local de build-android-start directorio 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 la SHA1 hash. Si usted no puede encontrar su 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, introduzca com.google.firebase.codelab.friendlychat como el nombre del paquete para su aplicación.
  3. Haga clic en Registrar la aplicación, a continuación, haga clic en Descargar Google-services.json para descargar el archivo de configuración Firebase.
  4. Copiar el google-services.json archivo en la app del directorio de su proyecto Android.
  5. Saltar los próximos pasos que se muestran en el flujo de trabajo de configuración de la consola (que ya ha sido hecho para usted en la build-android-start del proyecto).
  6. Asegúrese de que todas las dependencias estén disponibles para su aplicación sincronizando su proyecto con los archivos de Gradle. Desde la barra de herramientas de Android Studio, seleccione Archivo> Proyecto de sincronización con Gradle archivos.

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 la consola de Firebase , seleccione Autenticación desde el panel de navegación del lado izquierdo.
  2. Seleccione la pestaña de inicio de sesión en el método.
  3. Haga clic en Correo electrónico / contraseña, luego cambie el interruptor de activado (azul).
  4. Haga clic en Google, luego cambie el interruptor de activado (azul) y establecer un correo electrónico de apoyo al 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 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 la consola de Firebase , seleccione la base de datos en tiempo real desde 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 us-central1 región, a continuación, haga clic en Siguiente.
  3. Cuando se le pregunte acerca de las reglas de seguridad, seleccione el modo de bloqueo, a continuación, haga clic en Habilitar.
  4. Una vez se ha creado la instancia de base de datos, seleccione la ficha Reglas, a continuación, actualizar 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 Reglas de seguridad de trabajo (incluida la documentación sobre la variable "auth"), consulte la documentación de seguridad de base de datos en tiempo real .

Configurar Cloud Storage para Firebase

  1. En la consola de Firebase , seleccione Almacenamiento en el panel de navegación del lado izquierdo.
  2. Haga clic en Comenzar para permitir almacenamiento en la nube 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 una etapa anterior de este laboratorio de programación, se añade el texto siguiente 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 Firebase real y sus recursos reales base de fuego, puede eliminar ya sea este bloque o ejecutar la aplicación en modo de liberación de modo que BuildConfig.DEBUG es false .