Fazer upgrade de um app para Android no Firebase.com

Este documento ajuda você a fazer upgrade do seu aplicativo Firebase.com para o novo Console do Firebase e as novas APIs.

É preciso executar quatro etapas:

  1. Fazer upgrade do projeto para o novo Console do Firebase.
  2. Instalar o SDK do Firebase.
  3. Atualizar o código do banco de dados.
  4. Atualizar o código de autenticação.

Você pode fazer upgrade para o novo console firebase.google.com a qualquer momento. Seus aplicativos continuarão funcionando. Atualize seu código quando você estiver pronto para usar alguns dos novos recursos do Firebase no seu aplicativo.

Importar o projeto para o novo Console do Firebase

  • Acesse o Console do Firebase e localize seu projeto em "Projetos atualmente no Firebase.com".
  • Clique em Importar no projeto em que quer fazer upgrade.
    • Caso seu projeto esteja em um plano pago do firebase.com, você precisará configurar o faturamento dele no novo console. Suas informações de faturamento não são migradas automaticamente.
    • Selecione ou crie uma conta de faturamento. Após a importação, essa conta será responsável por todas as cobranças do projeto.
  • Seu conteúdo do Realtime Database e do Hosting é importado automática e instantaneamente para o Console do Firebase.
  • Seus dados de usuário são migrados automaticamente para o novo back-end de autenticação. Isso acontece em segundo plano, e seus usuários continuam a usar o aplicativo enquanto os dados são migrados. As inscrições e os logins dos usuários não são afetados. Durante a migração das contas de usuário pelo sistema, você verá um ícone de carregamento na guia "Auth" do Console do Firebase.
  • Caso você tenha um código promocional ativo para um aplicativo do Firebase.com, entre em contato conosco.

Instalar o novo SDK do Firebase

Não é necessário atualizar o código dos aplicativos imediatamente. O banco de dados e o código de autenticação existentes continuarão funcionando no seu projeto migrado. Porém, quando estiver pronto para usar alguns recursos novos do Firebase no seu aplicativo, você poderá Instalar o novo SDK do Firebase. Lembre-se de fazer o download do novo arquivo google-services.json e adicione o plug-in google-services ao seu arquivo gradle.

Observe que, ao iniciar o uso do novo SDK, o Google Analytics para Firebase será ativado automaticamente. Por padrão, os dados do Analytics aprimorarão outros recursos do Firebase e outros produtos do Google. Você pode controlar como os dados do Analytics são compartilhados nas suas configurações a qualquer momento. Saiba mais

Atualizar o código do banco de dados

Atualizar as dependências do Gradle

A maneira mais fácil de começar é alterando a dependência do Gradle:

ANTES

dependencies {
  compile 'com.firebase:firebase-client-android:x.x.x'
}
DEPOIS

dependencies {
  compile "com.google.firebase:firebase-database:19.2.0"
}

Corrigir as referências de classe

Seu aplicativo provavelmente terá agora uma série de erros de compilação por causa de classes renomeadas ou movidas. É possível corrigir muitos deles com algumas substituições diretas:

Antes Depois
com.firebase.client com.google.firebase.database
FirebaseError DatabaseError
FirebaseException DatabaseException
Firebase.AuthStateListener FirebaseAuth.AuthStateListener
Firebase DatabaseReference

Se você não encontrar a classe ou método que está procurando, consulte a documentação de referência do Database.

Configurar o Contexto do Android e ativar a Persistência off-line

No novo SDK, não é mais necessário chamar Firebase.setAndroidContext(), portanto, você pode removê-lo do seu código.

Se seu aplicativo usar a persistência em disco, ative-a por meio do objeto FirebaseDatabase:

ANTES

Firebase.getDefaultConfig().setPersistenceEnabled(true);
DEPOIS

FirebaseDatabase.getInstance().setPersistenceEnabled(true);

Como no SDK 2.x, a ativação da persistência em disco precisa ser feita antes de qualquer outra chamada ao banco de dados.

Receber uma referência do banco de dados

No novo SDK, as referências de Firebase são substituídas por DatabaseReference e a classe FirebaseDatabase é usada para obter uma referência inicial para seu banco de dados. Portanto, você pode ver a referência do banco de dados em seu código da seguinte forma:

ANTES

Firebase rootRef = new Firebase("https://<your-app>.firebaseio.com/");
DEPOIS

DatabaseReference rootRef = FirebaseDatabase.getInstance().getReference();

Observe que o URL do Database é determinado automaticamente pelo arquivo google-services.json de que você fez o download. Portanto, não será preciso especificá-lo. No entanto, se quiser especificá-lo, ainda é possível, já que isso pode ser conveniente para fins de migração:

ANTES

Firebase ref = new Firebase("https://<your-app>.firebaseio.com/path/to/data");
DEPOIS

DatabaseReference ref = FirebaseDatabase.getInstance()
    .getReferenceFromUrl("https://<your-app>.firebaseio.com/path/to/data");

Atualizar objetos do modelo Java

Assim como o SDK 2.x, o Firebase Database converte automaticamente objetos Java que você transmite para DatabaseReference.setValue() em JSON e pode ler JSON em objetos Java usando DataSnapshot.getValue().

No novo SDK, ao ler JSON em um objeto Java com DataSnapshot.getValue(), as propriedades desconhecidas no JSON são ignoradas por padrão. Portanto, você não precisa mais de @JsonIgnoreExtraProperties(ignoreUnknown=true).

Para excluir campos/getters ao gravar um objeto Java em JSON, a anotação agora é chamada de @Exclude em vez de @JsonIgnore.

ANTES

@JsonIgnoreExtraProperties(ignoreUnknown=true)
public class ChatMessage {
   public String name;
   public String message;
   @JsonIgnore
   public String ignoreThisField;
}

dataSnapshot.getValue(ChatMessage.class)
DEPOIS

public class ChatMessage {
   public String name;
   public String message;
   @Exclude
   public String ignoreThisField;
}

dataSnapshot.getValue(ChatMessage.class)

Se houver uma propriedade extra em seu JSON que não está na classe Java, você verá este alerta nos arquivos de registro:

W/ClassMapper: No setter/field for ignoreThisProperty found on class com.firebase.migrationguide.ChatMessage

Você pode remover esse alerta colocando uma anotação @IgnoreExtraProperties na sua classe. Se você quiser que o Firebase Database se comporte como no SDK 2.x e lance uma exceção se houver propriedades desconhecidas, coloque uma anotação @ThrowOnExtraProperties na sua classe.

Atualizar o código de autenticação

A funcionalidade do Firebase Authentication agora está em sua própria classe FirebaseAuth. Portanto, as operações de autenticação agora são realizadas em uma instância e não por meio de uma referência Firebase.

Atualizar as dependências do Gradle

Agora que a Authentication reside no próprio módulo, primeiro você precisa adicionar uma dependência ao seu build.gradle:

dependencies {
  compile 'com.google.firebase:firebase-auth:19.1.0'
}

Atualizar as importações

ANTES

import com.firebase.client.AuthData;
DEPOIS

import com.google.firebase.auth.FirebaseAuth;
import com.google.firebase.auth.FirebaseUser;

Fazer login de um usuário como anônimo

Os métodos de autenticação funcionam de maneira semelhante a como funcionavam antes, mas agora existem como métodos no objeto FirebaseAuth com novos nomes, e AuthData foi substituído por FirebaseUser. Por exemplo, veja a seguir como funciona fazer o login anonimamente na API 2.x e na nova API:

ANTES

ref.authAnonymously(new Firebase.AuthResultHandler() {
   public void onAuthenticated(AuthData authData) { }
   public void onAuthenticationError(FirebaseError firebaseError) {
       throw firebaseError.toException();
   }
});
DEPOIS

FirebaseAuth auth = FirebaseAuth.getInstance();
auth.signInAnonymously().addOnFailureListener(new OnFailureListener() {
   public void onFailure(Throwable throwable) {
       throw new RuntimeException(throwable);
   }
});

Fazer login de um usuário com um token personalizado

A autenticação com tokens personalizados pelo cliente também funciona de forma semelhante à anterior. Este é um exemplo de como o login com um token personalizado funciona tanto na API 2.x como na nova:

ANTES

ref.authWithCustomToken(AUTH_TOKEN, new Firebase.AuthResultHandler() {
   public void onAuthenticated(AuthData authData) { }
   public void onAuthenticationError(FirebaseError firebaseError) {
       throw firebaseError.toException();
   }
});
DEPOIS

FirebaseAuth auth = FirebaseAuth.getInstance();
auth.signInWithCustomToken(AUTH_TOKEN)
        .addOnCompleteListener(this, new OnCompleteListener() {
            @Override
            public void onComplete(@NonNull Task task) {
            }
        });

Os tokens personalizados gerados por você no seu servidor têm um novo formato. Use os SDKs Admin do Firebase para Node.js e Java para criar tokens personalizados compatíveis com a nova API. Se preferir, é possível criar tokens personalizados usando uma biblioteca JWT de terceiros.

Os SDKs de administrador do Firebase geram tokens personalizados que expiram depois de uma hora, diferentemente das bibliotecas de ajuda da API 2.x que, por padrão, geram tokens que expiram após 24 horas.

Fazer login de usuário com um provedor de rede social

Para provedores sociais, como Google, Facebook ou Twitter, as alterações são mais significativas.

O fluxo para os provedores sociais continua igual: primeiro você recebe do provedor as credenciais do usuário para depois usá-las para autenticar com o Firebase:

ANTES

ref.authWithOAuthToken(provider, token, authResultHandler);
DEPOIS

AuthCredential credential = GoogleAuthProvider.getCredential(acct.getIdToken(), null);
mAuth.signInWithCredential(credential)

Para mais informações, consulte a documentação sobre como usar a autenticação do Facebook com o Firebase e como usar a autenticação do Google com o Firebase.

A autenticação do Twitter é um pouco diferente:

ANTES

Map options = new HashMap<>();
options.put("oauth_token", oauth_token);
options.put("oauth_token_secret", oauth_token_secret);
options.put("user_id", user_id);
ref.authWithOAuthToken(token.provider, options, authResultHandler);
DEPOIS

AuthCredential credential = TwitterAuthProvider.getCredential(token, secret);
mAuth.signInWithCredential(credential)

Para mais informações, consulte Autenticar usando o Twitter

Desconectar um usuário

ANTES

ref.unauth()
DEPOIS

FirebaseAuth.getInstance().signOut();

Monitorar estado da autenticação

ANTES

ref.addAuthStateListener(new Firebase.AuthStateListener() {
   @Override
   public void onAuthStateChanged(final AuthData authData) {
       if (authData != null) {
           Log.i("AuthStateChanged", "User is signed in with uid: " + authData.getUid());
       } else {
           Log.i("AuthStateChanged", "No user is signed in.");
       }
   }
});
DEPOIS

FirebaseAuth auth = FirebaseAuth.getInstance();
auth.addAuthStateListener(new FirebaseAuth.AuthStateListener() {
   @Override
   public void onAuthStateChanged(@NonNull final FirebaseAuth firebaseAuth) {
       final FirebaseUser user = firebaseAuth.getCurrentUser();
       if (user != null) {
           Log.i("AuthStateChanged", "User is signed in with uid: " + user.getUid());
       } else {
           Log.i("AuthStateChanged", "No user is signed in.");
       }
   }
});

Migrar logins existentes

Se os usuários tiverem feito login no seu aplicativo com um SDK legado, você precisará de um código para mantê-los conectados com o novo SDK. Sem isso, eles terão que fazer login novamente. Consulte uma amostra de código aberto para fazer isso no repositório Firebase Auth Migration Helpers do GitHub.

Atualizar o novo modelo de redefinição de senha

Se o aplicativo permitir que usuários façam login com autenticação de e-mail e senha, você provavelmente dará a eles a opção de redefinir senha.

Depois do upgrade para o SDK novo, esses e-mails de redefinição de senha usam os novos modelos especificados no Console do Firebase. Atualize-os conforme as necessidades do seu aplicativo.

Atualizar as bibliotecas do Firebase

Se você usa uma das bibliotecas abaixo, será preciso fazer upgrade para a versão mais recente.

Biblioteca Versão aceita Recurso
GeoFire 1.2.x Github