Firebase Android Codelab - bate-papo amigável

1. Visão Geral

captura de tela

Imagem: app Working Friendly Chat.

Bem-vindo ao codelab do Chat Amigável. Neste codelab, você aprenderá a usar a plataforma Firebase para criar um aplicativo de bate-papo no Android.

O que você aprenderá

  • Como usar o Firebase Authentication para permitir que os usuários façam login.
  • Como sincronizar dados usando o Firebase Realtime Database.
  • Como armazenar arquivos binários no Cloud Storage para Firebase.
  • Como usar o Firebase Local Emulator Suite para desenvolver um aplicativo Android com Firebase.

O que você precisará

  • Android Estúdio versão 4.2+.
  • Um emulador Android com Android 5.0+.
  • Java 7 ou superior. Para instalar o Java usar essas instruções ; para verificar a sua versão, run java -version .
  • Familiaridade com a linguagem de programação Kotlin.

2. Obtenha o código de amostra

Clone o repositório

Clone o repositório GitHub a partir da linha de comando:

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

Importar para Android Studio

Em Android Studio, selecione Arquivo> Abrir e selecione o build-android-start diretório ( android_studio_folder ) do diretório onde você baixou o código de amostra.

Agora você deve ter o build-android-start projeto aberto no Android Studio. Se você ver um aviso sobre um google-services.json arquivo ausente, não se preocupe. Ele será adicionado em uma etapa posterior.

Verifique as dependências

Neste codelab, todas as dependências de que você precisa já foram adicionadas, mas é importante entender como adicionar o SDK do Firebase ao seu aplicativo:

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. Instale a Firebase CLI

A fim de executar o Firebase Emulator Suíte , você precisa instalar e usar o Firebase CLI .

Instale o CLI

Opção 1 - Instalar com npm

Se você já tem Node.js e npm instalados em sua máquina, pode instalar a CLI com o seguinte comando:

npm install -g firebase-tools@latest

Opção 2 - instalar binário autônomo

Se você não tem Node.js / npm ou você é novo no desenvolvimento de aplicativos, você pode instalar o CLI como um binário autônomo seguindo as instruções para a sua plataforma aqui .

Verifique a instalação

Assim que tiver o Firebase CLI instalado, execute o seguinte comando para certificar-se de que você tem a versão 9.11.0 ou superior:

firebase --version

4. Conecte-se ao Firebase Emulator Suite

Inicie os emuladores

Em seu terminal, execute o seguinte comando a partir da raiz do seu local de codelab-friendlychat-android diretório:

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

Você deve ver alguns logs como este. Os valores de porta foram definidos na firebase.json ficheiro, o qual foi incluído no código de exemplo 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 até http: // localhost: 4000 no seu navegador web para ver o Firebase Emulator Suíte UI:

Página inicial do Emulator Suite UI

Deixar os emulators:start comando de execução para o resto do codelab.

Conecte seu aplicativo

Em Android Studio, aberto MainActivity.kt , em seguida, adicione o seguinte código dentro do 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. Execute o aplicativo inicial

Adicionar google-services.json

Para que seu aplicativo Android para se conectar ao Firebase, você deve adicionar um google-services.json arquivo dentro do app pasta do seu projeto Android. Para os fins deste codelab, fornecemos um arquivo JSON simulado que permitirá que você se conecte ao Firebase Emulator Suite.

Copie o mock-google-services.json arquivo para o build-android-start/app pasta como google-services.json :

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

Na etapa final deste codelab, você aprenderá a criar um projeto Firebase real e um aplicativo Firebase Android para poder substituir esse arquivo JSON simulado por sua própria configuração.

Execute o aplicativo

Agora que importou o projeto para o Android Studio e adicionou um arquivo JSON de configuração do Firebase, você está pronto para executar o aplicativo pela primeira vez.

  1. Inicie o seu emulador Android.
  2. Em Android Studio, clique em Executar (executar ) na barra de ferramentas.

O aplicativo deve ser iniciado em seu emulador Android. Neste ponto, você deve ver uma lista de mensagens vazia e enviar e receber mensagens não funcionará. Na próxima etapa deste codelab, você autenticará os usuários para que eles possam usar o Chat Amigável.

6. Ative a autenticação

Este aplicativo usará o Firebase Realtime Database para armazenar todas as mensagens de bate-papo. Antes de adicionar dados, no entanto, devemos ter certeza de que o aplicativo é seguro e que apenas usuários autenticados podem postar mensagens. Nesta etapa, habilitaremos o Firebase Authentication e configuraremos as regras de segurança do Realtime Database.

Adicionar funcionalidade básica de login

A seguir, adicionaremos alguns códigos básicos do Firebase Authentication ao aplicativo para detectar usuários e implementar uma tela de login.

Verificar o usuário atual

Primeiro adicione a seguinte variável de instância para o MainActivity.kt classe:

MainActivity.kt

// Firebase instance variables
private lateinit var auth: FirebaseAuth

Agora vamos modificar MainActivity para enviar o usuário para a tela de login sempre que abrir o aplicativo e são não autenticado. Adicionar o seguinte para o onCreate() método após a binding é anexado à 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
}

Nós também queremos verificar se o usuário está conectado 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
    }
}

Em seguida, implementar o getUserPhotoUrl() e getUserName() métodos para retornar as informações apropriadas sobre o usuário Firebase atualmente 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
}

Em seguida, implementar o signOut() método para manipular o sinal para fora botão:

MainActivity.kt

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

Agora temos toda a lógica para enviar o usuário à tela de login quando necessário. Em seguida, precisamos implementar a tela de login para autenticar os usuários adequadamente.

Implementar a tela de login

Abra o arquivo SignInActivity.kt . Aqui, um botão Sign-In simples é usado para iniciar a autenticação. Nesta seção, você usará FirebaseUI para implementar a lógica de login.

Adicionar uma variável de instância Auth no SignInActivity classe sob a // Firebase instance variables comentário:

SignInActivity.kt

// Firebase instance variables
private lateinit var auth: FirebaseAuth

Em seguida, editar o onCreate() método para inicializar Firebase da mesma forma que fez no MainActivity :

SignInActivity.kt

// Initialize FirebaseAuth
auth = Firebase.auth

Adicionar um ActivityResultLauncher campo para SignInActivity :

SignInActivity.kt

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

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

Em seguida, editar o onStart() método para lançar o sinal FirebaseUI no fluxo:

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

Em seguida, implementar o onSignInResult método para manipular o sinal no resultado. Se o resultado do início de sessão foi bem sucedida, continuar a 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)
        }
    }
}

É isso! Você implementou a autenticação com FirebaseUI em apenas algumas chamadas de método e sem precisar gerenciar nenhuma configuração do lado do servidor.

Teste o seu trabalho

Execute o aplicativo em seu emulador Android. Você será enviado imediatamente para a tela de login. Toque no Entrar com o botão e-mail, em seguida, criar uma conta. Se tudo estiver implementado corretamente, você deverá ser encaminhado para a tela de mensagens.

Depois de entrar, abrir a Firebase Emulator Suíte UI em seu navegador, em seguida, clique na guia Autenticação para ver este primeiro-assinado na conta do usuário.

7. Leia as mensagens

Nesta etapa, adicionaremos funcionalidade para ler e exibir mensagens armazenadas no Realtime Database.

Importar mensagens de amostra

  1. No Firebase Emulator Suíte UI, selecione a guia banco de dados em tempo real.
  2. Arraste e solte o initial_messages.json arquivo de sua cópia local do repositório codelab para o visualizador de dados.

Agora você deve ter algumas mensagens sob a messages nó do banco de dados.

Leia os dados

Sincronizar mensagens

Nesta seção, adicionamos o código que sincroniza as mensagens recém-adicionadas à IU do aplicativo por:

  • Inicializar o Firebase Realtime Database e adicionar um listener para lidar com as alterações feitas nos dados.
  • Atualizando o RecyclerView adaptador para que novas mensagens serão mostradas.
  • Adicionando as variáveis de instância de banco de dados com as outras variáveis de instância Firebase no MainActivity classe:

MainActivity.kt

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

Modificar do seu MainActivity onCreate() método sob o comentário // Initialize Realtime Database and FirebaseRecyclerAdapter com o código definido abaixo. Este código adiciona todas as mensagens existentes da Realtime banco de dados e, em seguida, escuta para novas entradas criança com messages caminho em sua base de dados Firebase Realtime. Ele adiciona um novo elemento à IU para cada mensagem:

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

Em seguida na FriendlyMessageAdapter.kt classe implementar o bind() método dentro da classe 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)
        }
    }
    ...
}

Precisamos também de exibir mensagens que são imagens, assim também implementar o bind() método dentro da classe 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 volta MainActivity , iniciar e parar de ouvir para atualização de Firebase Realtime banco de dados. Actualizar a onPause() e onResume() métodos em MainActivity como mostrado abaixo:

MainActivity.kt

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

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

Mensagens de sincronização de teste

  1. Clique em Executar (executar )
  2. No emulador Suíte UI, volte para a guia banco de dados em tempo real, em seguida, adicionar manualmente uma nova mensagem. Confirme se a mensagem aparece em seu aplicativo Android:

Parabéns, você acabou de adicionar um banco de dados em tempo real ao seu aplicativo!

8. Envie mensagens

Implementar o envio de mensagens de texto

Nesta seção, você adicionará a capacidade de os usuários do aplicativo enviarem mensagens de texto. O trecho de código abaixo escutas para eventos clique no botão de envio, cria um novo FriendlyMessage objeto com o conteúdo do campo de mensagem, e empurra a mensagem para o banco de dados. O push() método adiciona um ID gerado automaticamente para o caminho do objeto empurrado. Esses IDs são sequenciais, o que garante que as novas mensagens serão adicionadas ao final da lista.

Atualize o ouvinte clique do botão de envio no onCreate() método na MainActivity classe. Este código está na parte inferior do onCreate() método já. Atualizar o onClick() do corpo para coincidir com o código abaixo:

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 o envio de mensagem de imagem

Nesta seção, você adicionará a capacidade de os usuários do aplicativo enviarem mensagens de imagem. A criação de uma mensagem de imagem é feita com estas etapas:

  • Selecione a imagem
  • Lidar com a seleção de imagens
  • Grave uma mensagem de imagem temporária no Realtime Database
  • Comece a carregar a imagem selecionada
  • Atualize o URL da mensagem da imagem para o da imagem carregada, assim que o upload for concluído

Selecione a imagem

Para adicionar imagens, este codelab usa o Cloud Storage para Firebase. O Cloud Storage é um bom lugar para armazenar os dados binários do seu aplicativo.

Lidar com a seleção de imagens e escrever mensagens temporárias

Uma vez que o usuário tenha selecionado uma imagem, a selecção de imagem Intent é lançado. Isso já está implementado no código no final do onCreate() método. Quando terminar ele chama o MainActivity 's onImageSelected() método. Usando o trecho de código abaixo, você escreverá uma mensagem com uma url de imagem temporária para o banco de dados, indicando que a imagem está sendo carregada.

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

Carregar imagem e atualizar mensagem

Adicione o método putImageInStorage() para MainActivity . Ele é chamado em onImageSelected() para iniciar o upload da imagem selecionada. Assim que o upload for concluído, você atualizará a mensagem para usar a imagem apropriada.

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

Teste o envio de mensagens

  1. No Android Studio, clique noexecutar Botão Executar.
  2. Em seu emulador Android, digite uma mensagem e toque no botão enviar. A nova mensagem deve estar visível na IU do aplicativo e na IU do Firebase Emulator Suite.
  3. No Android Emulator, toque na imagem "+" para selecionar uma imagem do seu dispositivo. A nova mensagem deve ser visível primeiro com uma imagem de espaço reservado e, em seguida, com a imagem selecionada quando o upload da imagem for concluído. A nova mensagem também deve estar visível na IU do Emulator Suite, especificamente como um objeto na guia Realtime Database e como um blob na guia Storage.

9. Parabéns!

Você acabou de criar um aplicativo de bate-papo em tempo real usando o Firebase!

O que você aprendeu

  • Firebase Authentication
  • Firebase Realtime Database
  • Cloud Storage para Firebase

Em seguida, tente usar o que você aprendeu neste codelab para adicionar o Firebase ao seu próprio aplicativo Android! Para saber mais sobre Firebase, visite firebase.google.com .

Se você quiser aprender como configurar um projeto Firebase real e usar recursos Firebase reais (em vez de um projeto de demonstração e de recursos única emulados), continue para a próxima etapa.

Nota: Mesmo depois de configurar um projeto Firebase real e especialmente quando você começar a construir uma aplicação real, é recomendável usar o emulador Suíte Firebase local para desenvolvimento e teste.

10. Opcional: crie e configure um projeto Firebase

Nesta etapa, você criará um projeto Firebase real e um aplicativo Firebase Android para usar com este codelab. Você também adicionará a configuração do Firebase específica do aplicativo ao seu aplicativo. E, finalmente, você configurará recursos reais do Firebase para usar com seu aplicativo.

Crie um projeto Firebase

  1. No seu navegador, vá para o console de Firebase .
  2. Selecione Adicionar projeto.
  3. Selecione ou insira um nome de projeto. Você pode usar o nome que quiser.
  4. Você não precisa do Google Analytics para este codelab, portanto, pode pular a ativação para seu projeto.
  5. Clique em Criar Projeto. Quando o projeto estiver pronto, clique em Continuar.

Adicione o Firebase ao seu projeto Android

Antes de iniciar esta etapa, obtenha o hash SHA1 do seu aplicativo. Execute o seguinte comando a partir de seu local de build-android-start diretório para determinar o SHA1 de sua chave de depuração:

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

Você deve ver alguma saída como a acima. A linha importante é o SHA1 de hash. Se você é incapaz de encontrar o seu hash SHA1, consulte esta página para mais informações.

Volte para o console do Firebase e siga estas etapas para registrar seu projeto Android com seu projeto Firebase:

  1. Na tela de visão geral do seu novo projeto, clique no ícone do Android para iniciar o fluxo de trabalho de configuração: adicionar aplicativo android
  2. Na próxima tela, digite com.google.firebase.codelab.friendlychat como o nome do pacote para seu aplicativo.
  3. Clique Register App, clique em Download google-services.json fazer o download do arquivo de configuração Firebase.
  4. Copie o google-services.json arquivo para o app diretório do seu projeto Android.
  5. Ignorar os próximos passos mostrados no fluxo de trabalho de configuração do console (que já foi feito para você no build-android-start do projeto).
  6. Certifique-se de que todas as dependências estejam disponíveis para seu aplicativo, sincronizando seu projeto com arquivos Gradle. Na barra de ferramentas Android Studio, selecione File> Projeto sincronização com arquivos Gradle.

Configurar Firebase Authentication

Antes que seu aplicativo possa acessar as APIs do Firebase Authentication em nome dos seus usuários, você precisa habilitar o Firebase Authentication e os provedores de login que deseja usar no seu aplicativo.

  1. Na consola Firebase , selecione Autenticação do painel de navegação do lado esquerdo.
  2. Selecione o Sign-in guia método.
  3. Clique E-mail / senha, em seguida, mude o botão para habilitado (azul).
  4. Clique em Google, em seguida, mude o botão para habilitado (azul) e definir um email apoio ao projecto.

Se você receber erros posteriormente neste codelab com a mensagem "CONFIGURATION_NOT_FOUND", volte a esta etapa e verifique seu trabalho.

Configurar o Realtime Database

O aplicativo neste codelab armazena mensagens de bate-papo no Firebase Realtime Database. Nesta seção, criaremos um banco de dados e configuraremos sua segurança por meio de uma linguagem de configuração JSON chamada Firebase Security Rules.

  1. Na consola Firebase , selecione Realtime banco de dados a partir do painel de navegação do lado esquerdo.
  2. Clique em Criar banco de dados para criar uma nova instância de banco de dados em tempo real. Quando solicitado, selecione o us-central1 região e clique em Avançar.
  3. Quando solicitado sobre as regras de segurança, escolha o modo bloqueado, em seguida, clique em Ativar.
  4. Uma vez que a instância de banco de dados foi criado, selecione a guia Regras, em seguida, atualizar a configuração regras com o seguinte:
     {
       "rules": {
         "messages": {
           ".read": "auth.uid != null",
           ".write": "auth.uid != null"
         }
       }
     }
    

Para mais informações sobre como regras de segurança de trabalho (incluindo a documentação sobre a variável "auth"), consulte a documentação de segurança de banco de dados em tempo real .

Configure o Cloud Storage para Firebase

  1. Na consola Firebase , selecione Armazenamento a partir do painel de navegação do lado esquerdo.
  2. Clique Get Started para permitir Cloud Storage para seu projeto.
  3. Siga as etapas na caixa de diálogo para configurar seu intervalo, usando os padrões sugeridos.

Conecte-se aos recursos do Firebase

Em uma etapa anterior deste codelab, você adicionou o seguinte para MainActivity.kt . Este bloco condicional conectou seu projeto Android ao 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)
}

Se você deseja se conectar seu aplicativo para seu novo projeto Firebase real e seus recursos reais Firebase, você pode remover este bloco ou executar o aplicativo no modo de versão para que BuildConfig.DEBUG é false .