Codelab do Firebase para Android: criação de chat fácil de usar

1. Visão geral

captura de tela

Imagem: app Chat amigável.

Este é o codelab do Friendly Chat. Neste codelab, você aprenderá a usar a plataforma do Firebase para criar um app de chat no Android.

O que você vai 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 Pacote de emuladores locais do Firebase para desenvolver um app Android com o Firebase.

Pré-requisitos

  • Versão mais recente do Android Studio.
  • Um Android Emulator com o Android 5.0 ou uma versão mais recente.
  • Node.js versão 10 ou mais recente (para usar o Pacote de emuladores).
  • Java 8 ou mais recente. Para instalar o Java, siga estas instruções. Para verificar sua versão, execute java -version.
  • Familiaridade com a linguagem de programação Kotlin.

2. Acessar o exemplo de código

Clonar o repositório

Clone o repositório do GitHub na linha de comando:

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

Importar para o Android Studio

No Android Studio, selecione File > Open e, em seguida, selecione o diretório build-android-start ( android_studio_folder) do diretório em que você fez o download do exemplo de código.

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

Verificar dependências

Neste codelab, todas as dependências necessárias já foram adicionadas, mas é importante entender como adicionar o SDK do Firebase ao app:

build.gradle.kts (link em inglês)

plugins {
    id("com.android.application") version "8.0.0" apply false
    id("com.android.library") version "8.0.0" apply false
    id("org.jetbrains.kotlin.android") version "1.8.20" apply false

    // The google-services plugin is required to parse the google-services.json file
    id("com.google.gms.google-services") version "4.3.15" apply false
}

app/build.gradle.kts

plugins {
    id("com.android.application")
    id("kotlin-android")
    id("com.google.gms.google-services")
}

android {
    // ...
}

dependencies {
    // ...

    // Google Sign In SDK
    implementation("com.google.android.gms:play-services-auth:20.5.0")

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

    // Firebase UI Library
    implementation("com.firebaseui:firebase-ui-auth:8.0.2")
    implementation("com.firebaseui:firebase-ui-database:8.0.2")
}

3. Instalar a CLI do Firebase

Neste codelab, você vai usar o pacote do emulador do Firebase para emular localmente o Firebase Auth, o Realtime Database e o Cloud Storage. Isso oferece um ambiente de desenvolvimento local seguro, rápido e sem custos para criar seu app.

Instalar a CLI do Firebase

Primeiro, você precisa instalar a CLI do Firebase. Se estiver usando macOS ou Linux, você poderá executar o seguinte comando cURL:

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

Se você estiver usando o Windows, leia as instruções de instalação para instalar um binário autônomo ou via npm.

Depois de instalar a CLI, a execução de firebase --version vai informar uma versão de 9.0.0 ou mais recente:

$ firebase --version
9.0.0

Fazer login

Execute firebase login para conectar a CLI à sua Conta do Google. Uma nova janela do navegador será aberta para concluir o processo de login. Escolha a mesma conta usada para criar seu projeto do Firebase.

4. Conectar-se ao Pacote de emuladores do Firebase

Iniciar os emuladores

No seu terminal, execute o seguinte comando na raiz do seu diretório codelab-friendlychat-android local:

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

Você vai encontrar alguns registros como este. Os valores da porta foram definidos no arquivo firebase.json, que foi incluído no exemplo de código 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.

Acesse http://localhost:4000 no navegador da Web para visualizar a interface do Pacote de emuladores do Firebase:

Página inicial da IU do Pacote de emuladores

Deixe o comando emulators:start em execução pelo resto do codelab.

Conecte seu aplicativo

No Android Studio, abra MainActivity.kt e adicione o código abaixo ao 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. Executar o app inicial

Adicionar o google-services.json

Para que o app Android se conecte ao Firebase, é necessário adicionar um arquivo google-services.json na pasta app do projeto. Para este codelab, fornecemos um arquivo JSON simulado que permite conectar ao conjunto de emuladores do Firebase.

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

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

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

Execute o aplicativo

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

  1. Inicie o Android Emulator.
  2. No Android Studio, clique em Run (execute) na barra de ferramentas.

O app vai ser iniciado no Android Emulator. Nesse ponto, você vai encontrar uma lista de mensagens vazia, e o envio e a recepção de mensagens não vão funcionar. Na próxima etapa deste codelab, você vai autenticar usuários para que eles possam usar o Friendly Chat.

6. Ativar a autenticação

Esse app vai usar o Firebase Realtime Database para armazenar todas as mensagens de chat. Antes de adicionar dados, porém, devemos nos certificar de que o aplicativo seja seguro e que apenas usuários autenticados possam postar mensagens. Nesta etapa, vamos ativar o Firebase Authentication e configurar as regras de segurança do Realtime Database.

Adicionar a funcionalidade básica de login

Em seguida, adicionaremos um código básico do Firebase Authentication ao app para detectar usuários e implementar uma tela de login.

Verificar o usuário atual

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

MainActivity.kt (link em inglês)

// Firebase instance variables
private lateinit var auth: FirebaseAuth

Agora, vamos modificar MainActivity para enviar o usuário à tela de login sempre que ele abrir o app e não estiver autenticado. Adicione o seguinte ao método onCreate() depois de a binding ser anexada à visualização:

MainActivity.kt (link em inglês)

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

Também queremos verificar se o usuário fez login 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, implemente os métodos getUserPhotoUrl() e getUserName() para retornar as informações adequadas sobre o usuário do Firebase 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, implemente o método signOut() para processar o botão de logout:

MainActivity.kt (link em inglês)

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

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

Implementar a tela de login

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

Adicione uma variável de instância do Auth na classe SignInActivity no comentário // Firebase instance variables:

SignInActivity.kt

// Firebase instance variables
private lateinit var auth: FirebaseAuth

Em seguida, edite o método onCreate() para inicializar o Firebase da mesma forma que você fez em MainActivity:

SignInActivity.kt

// Initialize FirebaseAuth
auth = Firebase.auth

Adicione um campo ActivityResultLauncher a SignInActivity:

SignInActivity.kt (link em inglês)

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

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

Em seguida, edite o método onStart() para iniciar o fluxo de login da 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()
    }
}

Em seguida, implemente o método onSignInResult para processar o resultado do login. Se o resultado do login for bem-sucedido, continue para 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)
        }
    }
}

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

Testar seu trabalho

Execute o app no Android Emulator. Você será direcionado imediatamente para a tela de login. Toque no botão Fazer login com e-mail e crie uma conta. Se tudo estiver implementado corretamente, você será direcionado para a tela de mensagens.

Depois de fazer login, abra a IU do Pacote de emuladores do Firebase no navegador e clique na guia Autenticação para ver a primeira conta de usuário.

7. Leia mensagens

Nesta etapa, vamos adicionar a funcionalidade para ler e mostrar mensagens armazenadas no Realtime Database.

Importar mensagens de amostra

  1. Na interface do Firebase Emulator Suite, selecione a guia Realtime Database.
  2. Arraste e solte o arquivo initial_messages.json da sua cópia local do repositório do codelab no visualizador de dados.

Agora você tem algumas mensagens no nó messages do banco de dados.

Ler dados

Sincronizar mensagens

Nesta seção, adicionamos um código que sincroniza mensagens recém-adicionadas à interface do usuário do aplicativo por:

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

MainActivity.kt

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

Modifique o método onCreate() da MainActivity no comentário // Initialize Realtime Database and FirebaseRecyclerAdapter com o código definido abaixo. Esse código adiciona todas as mensagens existentes do Realtime Database e detecta novas entradas filhas no caminho messages no Firebase Realtime Database. Ele adiciona um novo elemento à interface 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 classe FriendlyMessageAdapter.kt, implemente o método bind() na 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)
        }
    }
    ...
}

Também precisamos mostrar mensagens que são imagens. Portanto, implemente o método bind() na classe interna ImageMessageViewHolder():

FriendlyMessageAdapter.kt (link em inglês)

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 fim, de volta ao MainActivity, inicie e pare de detectar atualizações do Firebase Realtime Database. Atualize os métodos onPause() e onResume() em MainActivity, conforme mostrado abaixo:

MainActivity.kt

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

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

Testar a sincronização de mensagens

  1. Clique em Run (execute).
  2. Na interface do Pacote de emuladores, retorne à guia Realtime Database e adicione manualmente uma nova mensagem. Confirme se a mensagem aparece no app Android:

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

8. Enviar mensagens

Implementar o envio de mensagens de texto

Nesta seção, você vai adicionar a capacidade de enviar mensagens de texto aos usuários do app. O snippet de código abaixo detecta eventos de clique no botão de envio, cria um novo objeto FriendlyMessage com o conteúdo do campo de mensagem e envia a mensagem para o banco de dados. O método push() adiciona um ID gerado automaticamente ao caminho do objeto enviado. Esses IDs são sequenciais, o que garante que as novas mensagens sejam adicionadas ao final da lista.

Atualize o listener de clique do botão de envio no método onCreate() da classe MainActivity. Esse código já está na parte de baixo do método onCreate(). Atualize o corpo de onClick() para corresponder ao código abaixo:

MainActivity.kt (link em inglês)

// 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 mensagens de imagem

Nesta seção, você vai adicionar um recurso para que os usuários do app enviem mensagens de imagem. Para criar uma mensagem de imagem, siga estas etapas:

  • Selecione uma imagem
  • Processar a seleção de imagens
  • Gravar uma mensagem de imagem temporária no Realtime Database
  • Começar a fazer upload da imagem selecionada
  • Atualizar o URL da mensagem da imagem para o URL da imagem enviada, depois que o upload for concluído

Selecionar imagem

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

Processar a seleção de imagem e gravar a mensagem temporária

Depois que o usuário seleciona uma imagem, a seleção de imagem Intent é iniciada. Isso já está implementado no código ao final do método onCreate(). Quando terminar, ele chama o método onImageSelected() do MainActivity. Usando o snippet de código abaixo, você escreverá uma mensagem com um URL de imagem temporário no banco de dados indicando que a imagem está sendo enviada.

MainActivity.kt (link em inglês)

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

Fazer upload de imagem e atualizar mensagem

Adicione o método putImageInStorage() a MainActivity. Ele é chamado em onImageSelected() para iniciar o upload da imagem selecionada. Quando 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 no botão executeRun.
  2. No Android Emulator, digite uma mensagem e toque no botão "Send". A nova mensagem deve aparecer na interface do app e do Pacote de emuladores do Firebase.
  3. No Android Emulator, toque na imagem "+" para selecionar uma imagem do seu dispositivo. A nova mensagem deve ficar visível primeiro com uma imagem de marcador e, em seguida, com a imagem selecionada quando o upload da imagem for concluído. A nova mensagem também precisa estar visível na interface do pacote de emuladores, especificamente como um objeto na guia &quot;Realtime Database&quot; e como um blob na guia &quot;Storage&quot;.

9. Parabéns!

Você acabou de criar um aplicativo de chat em tempo real usando o Firebase.

O que você aprendeu

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

Em seguida, use o que você aprendeu neste codelab para adicionar o Firebase ao seu app Android. Para saber mais sobre o Firebase, acesse firebase.google.com.

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

Observação: mesmo depois de configurar um projeto real do Firebase e, principalmente, quando começar a criar um app real, recomendamos usar o Pacote de emuladores locais do Firebase para desenvolvimento e testes.

10. Opcional: criar e configurar um projeto do Firebase

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

Criar um projeto do Firebase

  1. No navegador, acesse o Console do Firebase.
  2. Selecione Adicionar projeto.
  3. Selecione ou digite o nome de um projeto. Use o nome que quiser.
  4. Você não precisa do Google Analytics para este codelab. Portanto, pule a ativação dele no seu projeto.
  5. Clique em Criar projeto. Quando o projeto estiver pronto, clique em Continuar.

Fazer upgrade do plano de preços do Firebase

Para usar o Cloud Storage para Firebase, seu projeto do Firebase precisa estar no plano de preços pague conforme o uso (Blaze), ou seja, vinculado a uma conta do Cloud Billing.

  • Uma conta do Cloud Billing exige uma forma de pagamento, como cartão de crédito.
  • Se você ainda não conhece o Firebase e o Google Cloud, confira se tem qualificação para receber um crédito de US$ 300 e uma conta de teste gratuito do Cloud Billing.
  • Se você estiver fazendo este codelab como parte de um evento, pergunte ao organizador se há créditos do Cloud disponíveis.

Para fazer upgrade do seu projeto para o plano Blaze, siga estas etapas:

  1. No console do Firebase, selecione Fazer upgrade do seu plano.
  2. Selecione o plano Blaze. Siga as instruções na tela para vincular uma conta do Cloud Billing ao seu projeto.
    Se você precisou criar uma conta do Cloud Billing como parte desse upgrade, talvez seja necessário voltar ao fluxo de upgrade no console do Firebase para concluir o upgrade.

Adicionar o Firebase ao projeto para Android

Antes de iniciar esta etapa, extraia o hash SHA1 do app. Execute o comando a seguir no diretório build-android-start local para determinar o SHA1 da 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

O resultado deve ser semelhante ao mostrado acima. A linha importante é o hash SHA1. Se você não conseguir encontrar o hash SHA-1, consulte esta página para mais informações.

Volte ao Console do Firebase e siga estas etapas para registrar o projeto do Android no projeto do Firebase:

  1. Na tela de visão geral do novo projeto, clique no ícone do Android para iniciar o fluxo de trabalho de configuração: adicionar app Android
  2. Na próxima tela, digite com.google.firebase.codelab.friendlychat como o nome do pacote do app.
  3. Clique em Registrar app e depois em Fazer o download do google-services.json para salvar o arquivo de configuração do Firebase.
  4. Copie o arquivo google-services.json para o diretório app do projeto Android.
  5. Ignore as próximas etapas mostradas no fluxo de trabalho de configuração do console (elas já foram feitas para você no projeto build-android-start).
  6. Sincronize seu projeto com os arquivos do Gradle para garantir que todas as dependências estejam disponíveis para o app. Na barra de ferramentas do Android Studio, selecione File > Sync Project with Gradle Files. Talvez seja necessário executar Build/Clean Project e Build/Rebuild Project para que as mudanças de configuração sejam aplicadas.

Configure o Firebase Authentication

Para que seu app possa acessar as APIs do Firebase Authentication em nome dos usuários, você precisa ativar o Firebase Authentication e os provedores de login que quer usar no app.

  1. No Console do Firebase, selecione Autenticação no painel de navegação à esquerda.
  2. Selecione a guia Método de login.
  3. Clique em E-mail/senha e mude a opção para "Ativada" (azul).
  4. Clique em Google, ative a chave (azul) e defina um e-mail de suporte do projeto.

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

Configurar o Realtime Database

O app neste codelab armazena mensagens de chat no Firebase Realtime Database. Nesta seção, vamos criar um banco de dados e configurar a segurança dele usando uma linguagem de configuração JSON chamada Regras de segurança do Firebase.

  1. No painel esquerdo do Console do Firebase, expanda Criação e selecione Realtime Database.
  2. Clique em Criar banco de dados.
  3. Selecione um local para o banco de dados e clique em Próxima.
    No caso de apps reais, escolha um local próximo aos usuários.
  4. Clique em Iniciar no modo de teste. Leia a exoneração de responsabilidade sobre as regras de segurança.
    Nas próximas etapas deste codelab, você vai adicionar regras de segurança para proteger seus dados. Não distribua ou exponha um aplicativo publicamente sem adicionar regras de segurança ao seu banco de dados.
  5. Clique em Criar.
  6. Depois que a instância do banco de dados for criada, selecione a guia Regras e atualize a configuração das regras da seguinte forma:
     {
   "rules": {
     "messages": {
       ".read": "auth.uid != null",
       ".write": "auth.uid != null"
     }
   }
 }

Para mais informações sobre como as regras de segurança funcionam, incluindo a documentação sobre a variável "auth", consulte a documentação de segurança do Realtime Database.

Configurar o Cloud Storage para Firebase

  1. No painel esquerdo do Console do Firebase, abra Build e selecione Armazenamento.
  2. Clique em Começar.
  3. Selecione um local para o bucket padrão do Storage.
    Buckets em US-WEST1, US-CENTRAL1 e US-EAST1 podem aproveitar o nível "Sempre sem custo financeiro" do Google Cloud Storage. Os buckets em todos os outros locais seguem os preços e o uso do Google Cloud Storage.
  4. Clique em Iniciar no modo de teste. Leia o aviso sobre as regras de segurança.
    Mais adiante neste codelab, você vai adicionar regras de segurança para proteger seus dados. Não distribua ou exponha um aplicativo publicamente sem adicionar regras de segurança ao bucket do Storage.
  5. Clique em Criar.

Conectar-se aos recursos do Firebase

Em uma etapa anterior deste codelab, você adicionou o seguinte à MainActivity.kt. Esse bloco condicional conectou seu projeto Android ao Pacote de emuladores do Firebase.

// 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ê quiser conectar seu app ao novo projeto real do Firebase e os recursos reais do Firebase, remova esse bloqueio ou execute o app no modo de lançamento para que BuildConfig.DEBUG seja false.