Participe do Firebase Summit on-line e presencialmente em 18 de outubro de 2022. Veja como o Firebase pode ajudar. Usando essa plataforma, você pode acelerar o desenvolvimento de apps, lançar seu aplicativo com confiança e fazer o escalonamento facilmente. Inscreva-se agora

Primeiros passos com o Firebase Crashlytics

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Neste guia de início rápido, descrevemos como configurar o Firebase Crashlytics no seu app com o SDK do Firebase Crashlytics para que você receba relatórios de erros abrangentes no Console do Firebase.

A configuração do Crashlytics exige tarefas no Console do Firebase e no ambiente de desenvolvimento integrado, como adicionar um arquivo de configuração do Firebase e o SDK do Crashlytics. Para concluir a configuração, você precisará forçar uma falha de teste para enviar seu primeiro relatório de erros ao Firebase.

Antes de começar

  1. Adicione o Firebase ao seu projeto do Unity, caso ainda não tenha feito isso. Se você não tiver um projeto do Unity, faça o download de um app de exemplo.

  2. Recomendado: para ter recursos como usuários sem falhas, registros de navegação estrutural e alertas de velocidade, ative o Google Analytics no seu projeto do Firebase.

    • Caso seu projeto do Firebase não tenha o Google Analytics ativado, faça a ativação na guia Integrações das suas > Configurações do projeto no Console do Firebase.

    • Se você estiver criando um novo projeto do Firebase, ative o Google Analytics durante o fluxo de trabalho de criação do projeto.

Etapa 1: adicionar o SDK do Crashlytics ao seu app

Observe que quando você registrou seu projeto do Unity com o projeto do Firebase, talvez já tenha feito o download do SDK do Firebase para Unity e adicionado o pacote do Crashlytics.

  1. Faça o download do SDK do Firebase para Unity e descompacte o SDK em um local prático.

    O SDK do Firebase para Unity não é específico da plataforma.

  2. No seu projeto aberto do Unity, acesse Assets > Import Package > Custom Package.

  3. No SDK descompactado, selecione a opção para importar o SDK do Crashlytics (FirebaseCrashlytics.unitypackage).

    Também é possível importar qualquer outro produto do Firebase compatível.

  4. Na janela Import Unity Package, clique em Import.

Etapa 2: inicializar o Crashlytics

  1. Crie um novo script em C# e adicione-o a um GameObject no cenário.

    1. Abra seu primeiro cenário e crie um GameObject em branco chamado CrashlyticsInitializer.

    2. Clique em Adicionar componente no Inspetor para o novo objeto.

    3. Selecione seu script CrashlyticsInit para adicioná-lo ao objeto CrashlyticsInitializer.

  2. Inicialize o Crashlytics no método Start do script:

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    // Import Firebase
    using Firebase;
    
    public class CrashlyticsInit : MonoBehaviour {
        // Use this for initialization
        void Start () {
            // Initialize Firebase
            Firebase.FirebaseApp.CheckAndFixDependenciesAsync().ContinueWith(task => {
                var dependencyStatus = task.Result;
                if (dependencyStatus == Firebase.DependencyStatus.Available)
                {
                    // Create and hold a reference to your FirebaseApp,
                    // where app is a Firebase.FirebaseApp property of your application class.
                    // Crashlytics will use the DefaultInstance, as well;
                    // this ensures that Crashlytics is initialized.
                    Firebase.FirebaseApp app = Firebase.FirebaseApp.DefaultInstance;
    
                    // Set a flag here for indicating that your project is ready to use Firebase.
                }
                else
                {
                    UnityEngine.Debug.LogError(System.String.Format(
                      "Could not resolve all Firebase dependencies: {0}",dependencyStatus));
                    // Firebase Unity SDK is not safe to use here.
                }
            });
        }
    
      // Update is called once per frame
      void Update()
        // ...
    }

Etapa 3: (somente Android) configurar o upload de símbolos

As etapas nesta seção são obrigatórias apenas para apps Android que usam IL2CPP.

  • Essas etapas não são necessárias para apps Android que usam o back-end de script Mono do Unity.

  • Essas etapas não são necessárias para apps da plataforma Apple porque o plug-in do Editor do Firebase para Unity configura automaticamente o projeto Xcode para fazer upload dos símbolos.

O SDK 8.6.1+ do Crashlytics para Unity inclui automaticamente os relatórios de erros do NDK, que permitem ao Crashlytics reportar automaticamente as falhas do IL2CPP do Unity no Android. No entanto, para ver stack traces simbolizados para falhas da biblioteca nativa no painel do Crashlytics, faça upload das informações de símbolos no tempo de compilação usando a CLI do Firebase.

Conclua estas etapas para configurar o upload de símbolos:

  1. Siga as instruções para instalar a CLI do Firebase.

    Se você já instalou a CLI, atualize-a para a versão mais recente.

  2. (somente para apps que usam o nível 30 da API do Android ou níveis acima desse) Atualize o modelo AndroidManifest.xml do seu app para desativar a inclusão de tags do ponteiro:

    1. Marque a caixa de seleção de Android Player Settings > Publishing Settings > Build > Custom Main Manifest.

    2. Abra o modelo de manifesto localizado em Assets/Plugins/Android/AndroidManifest.xml.

    3. Adicione o seguinte atributo à tag do aplicativo: <application android:allowNativeHeapPointerTagging="false" ... />

Etapa 4: criar seu projeto e fazer upload de símbolos

iOS+ (plataforma Apple)

  1. Na caixa de diálogo Build Settings, exporte seu projeto para um espaço de trabalho do Xcode.

  2. Crie seu app.

    Para plataformas Apple, o plug-in do Editor do Firebase para Unity configura automaticamente seu projeto do Xcode para gerar e fazer upload de um arquivo de símbolo compatível com o Crashlytics para os servidores do Firebase em cada build.

Android

  1. Na caixa de diálogo Build Settings, siga um destes procedimentos:

    • Exporte para o Android Studio para criar seu projeto ou

    • Crie seu APK diretamente no Editor do Unity.
      Antes de começar a criar, verifique se a caixa de seleção Create symbol.zip está marcada na caixa de diálogo Build Settings.

  2. Quando o build estiver concluído, gere um arquivo de símbolo compatível com o Crashlytics e faça upload dele para os servidores do Firebase. Para isso, execute o seguinte comando da CLI do Firebase:

    firebase crashlytics:symbols:upload --app=FIREBASE_APP_ID PATH/TO/SYMBOLS
    • FIREBASE_APP_ID: seu ID do app Android do Firebase (não o nome do pacote)
      Exemplo de ID do app Android do Firebase: 1:567383003300:android:17104a2ced0c9b9b

    • PATH/TO/SYMBOLS: o caminho para o arquivo de símbolo gerado pela CLI

      • Exportado para um projeto do Android Studio: PATH/TO/SYMBOLS é o diretório unityLibrary/symbols, que é criado na raiz do projeto exportado depois que você cria o app usando o Gradle ou o Android Studio.

      • Crie o APK diretamente no Unity: PATH/TO/SYMBOLS é o caminho do arquivo de símbolo compactado gerado no diretório raiz do projeto quando o build foi concluído (por exemplo: myproject/myapp-1.0-v100.symbols.zip).

    Veja opções avançadas para usar o comando da CLI do Firebase para gerar e fazer upload de arquivos de símbolos

    Sinalização Descrição
    --generator=csym

    Usa o gerador de arquivos de símbolo legado do cSYM em vez do gerador padrão do Breakpad.

    Não recomendado. Recomendamos o uso do gerador de arquivos de símbolo padrão do Breakpad.

    --generator=breakpad

    Usa o gerador de arquivos de símbolo do Breakpad

    O padrão para a geração de arquivos de símbolo é o Breakpad. Use essa sinalização apenas se você tiver adicionado symbolGenerator { csym() } à configuração do build e quiser substituí-la para utilizar o Breakpad.

    --dry-run

    Gera os arquivos de símbolo, mas não faz upload deles

    Essa sinalização é útil se você quiser inspecionar o conteúdo dos arquivos enviados.

    --debug Fornece informações de depuração adicionais

Etapa 5: forçar uma falha no teste para concluir a configuração

Para concluir a configuração do Crashlytics e ver os dados iniciais no painel do Console do Firebase, é necessário forçar uma falha de teste.

  1. Encontre um GameObject existente e adicione-o ao script a seguir. Esse script causa uma falha no teste alguns segundos depois da execução do app.

    using System;
    using UnityEngine;
    
    public class CrashlyticsTester : MonoBehaviour {
    
        int updatesBeforeException;
    
        // Use this for initialization
        void Start () {
          updatesBeforeException = 0;
        }
    
        // Update is called once per frame
        void Update()
        {
            // Call the exception-throwing method here so that it's run
            // every frame update
            throwExceptionEvery60Updates();
        }
    
        // A method that tests your Crashlytics implementation by throwing an
        // exception every 60 frame updates. You should see non-fatal errors in the
        // Firebase console a few minutes after running your app with this method.
        void throwExceptionEvery60Updates()
        {
            if (updatesBeforeException > 0)
            {
                updatesBeforeException--;
            }
            else
            {
                // Set the counter to 60 updates
                updatesBeforeException = 60;
    
                // Throw an exception to test your Crashlytics implementation
                throw new System.Exception("test exception please ignore");
            }
        }
    }
    
  2. Crie seu app e, em seguida, faça upload das informações de símbolo.

    • iOS+: o plug-in do Editor do Firebase para Unity configura automaticamente seu projeto do Xcode para fazer upload do arquivo de símbolo.

    • Android: para apps Android que usam IL2CPP, execute o comando crashlytics:symbols:upload da CLI do Firebase para fazer upload do seu arquivo de símbolo.

  3. Execute o app. Quando seu aplicativo estiver em execução, observe o registro do dispositivo e aguarde a exceção ser acionada a partir do CrashlyticsTester.

    • iOS+: veja os registros no painel inferior do Xcode.

    • Android: veja os registros executando o comando adb logcat no terminal.

  4. Quando você vir a exceção no registro do dispositivo, reinicie o app para que ele possa enviar o relatório de erros ao Firebase.

  5. Acesse o painel do Crashlytics no Console do Firebase para ver a falha do teste.

    Se você atualizou o console e ainda não consegue ver a falha de teste após cinco minutos, ative a geração de registros de depuração para ver se o app está enviando relatórios de falha.


Pronto. O Crashlytics está monitorando seu app em busca de falhas. Acesse o painel do Crashlytics para ver e analisar todos os relatórios e estatísticas.

Próximas etapas

  • Faça a integração com o Google Play para filtrar os relatórios de erros do app Android pela faixa do Google Play diretamente no painel do Crashlytics. Isso permite que você configure o painel para verificar versões específicas.