Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

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.

Este início rápido descreve como configurar o Firebase Crashlytics em seu aplicativo com o SDK do Firebase Crashlytics para que você possa obter relatórios de falhas abrangentes no console do Firebase.

A configuração do Crashlytics requer tarefas no console do Firebase e no seu IDE (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 falha ao Firebase.

Antes de você começar

  1. Se ainda não o fez, adicione o Firebase ao seu projeto Unity. Se você não tiver um projeto Unity, poderá baixar um aplicativo de exemplo .

  2. Recomendado : para obter recursos como usuários sem falhas, registros de navegação e alertas de velocidade, você precisa ativar o Google Analytics em seu projeto Firebase.

    • Se o seu projeto Firebase existente não tiver o Google Analytics ativado, você pode ativar o Google Analytics na guia Integrações de 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 aplicativo

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

  1. Baixe o Firebase Unity SDK e descompacte o SDK em algum lugar conveniente.

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

  2. Em seu projeto Unity aberto, navegue até Assets > Import Package > Custom Package .

  3. No SDK descompactado, selecione para importar o Crashlytics SDK ( FirebaseCrashlytics.unitypackage ).

    Você também pode importar qualquer outro produto Firebase compatível .

  4. Na janela Importar pacote do Unity , clique em Importar .

Etapa 2 : inicializar o Crashlytics

  1. Crie um novo script C# e adicione-o a um GameObject na cena.

    1. Abra sua primeira cena e crie um GameObject vazio 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) Prepare-se para o upload de símbolos

As etapas nesta seção são necessárias apenas para aplicativos Android que usam IL2CPP.

  • Para aplicativos Android que usam o back-end de script Mono do Unity, essas etapas não são necessárias.

  • Para aplicativos da plataforma Apple, essas etapas não são necessárias porque o plug-in Firebase Unity Editor configura automaticamente seu projeto Xcode para carregar símbolos.

O Unity SDK 8.6.1+ da Crashlytics inclui automaticamente relatórios de falhas do NDK, que permitem que a Crashlytics relate automaticamente as falhas do Unity IL2CPP no Android. No entanto, para ver os rastreamentos de pilha simbolizados para falhas da biblioteca nativa no painel do Crashlytics, você deve fazer upload das informações do símbolo no momento da compilação usando a Firebase CLI.

Conclua as etapas a seguir para configurar o upload de símbolos:

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

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

  2. (somente para aplicativos que usam Android API de nível 30 ou superior) Atualize o modelo AndroidManifest.xml do seu aplicativo para desativar a marcação de ponteiro:

    1. Marque a caixa 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" ... />

Passo 4 : Crie seu projeto e carregue os 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 aplicativo.

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

Android

  1. Na caixa de diálogo Configurações de compilação , siga um destes procedimentos:

    • Exporte para um projeto do Android Studio para construir seu projeto; ou

    • Crie seu APK diretamente do Unity Editor.
      Antes de construir, certifique-se de que a caixa de seleção Criar símbolos.zip esteja marcada na caixa de diálogo Configurações de construção.

  2. Após a conclusão da compilação, gere um arquivo de símbolo compatível com o Crashlytics e faça o upload dele para os servidores Firebase executando o seguinte comando Firebase CLI:

    firebase crashlytics:symbols:upload --app=FIREBASE_APP_ID PATH/TO/SYMBOLS
    • FIREBASE_APP_ID : seu ID do aplicativo Firebase para Android (não o nome do seu pacote)
      Exemplo de ID do aplicativo Firebase para Android: 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 aplicativo via Gradle ou Android Studio.

      • Construa o APK diretamente de dentro do Unity — PATH/TO/SYMBOLS é o caminho do arquivo de símbolo compactado gerado no diretório raiz do projeto quando sua compilação for concluída (por exemplo: myproject/myapp-1.0-v100.symbols.zip ).

    Veja opções avançadas para usar o comando Firebase CLI para geração e upload de arquivos de símbolo

    Bandeira Descrição
    --generator=csym

    Usa o gerador de arquivo de símbolo cSYM herdado em vez do gerador Breakpad padrão

    Não recomendado para uso. Recomendamos usar o gerador de arquivo de símbolo padrão do Breakpad.

    --generator=breakpad

    Usa o gerador de arquivo de símbolo Breakpad

    Observe que o padrão para geração de arquivo de símbolo é Breakpad. Use esse sinalizador apenas se tiver adicionado symbolGenerator { csym() } em sua configuração de compilação e quiser substituí-lo para usar o Breakpad.

    --dry-run

    Gera os arquivos de símbolos, mas não os carrega

    Este sinalizador é útil se você deseja inspecionar o conteúdo dos arquivos enviados.

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

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

Para concluir a configuração do Crashlytics e ver os dados iniciais no painel do Crashlytics do console do Firebase, você precisa forçar uma falha de teste.

  1. Encontre um GameObject existente e adicione a ele o seguinte script. Este script causará uma falha de teste alguns segundos depois que você executar seu aplicativo.

    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 aplicativo e carregue as informações do símbolo após a conclusão da compilação.

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

    • Android : para seus aplicativos Android que usam IL2CPP, execute o comando Firebase CLI crashlytics:symbols:upload para carregar seu arquivo de símbolo.

  3. Execute seu aplicativo. Depois que seu aplicativo estiver em execução, observe o log do dispositivo e aguarde até que a exceção seja acionada no CrashlyticsTester .

    • iOS+ : visualize os logs no painel inferior do Xcode.

    • Android : visualize os logs executando o seguinte comando no terminal: adb logcat .

  4. Ao ver a exceção no registro do dispositivo, reinicie o aplicativo para que ele possa enviar o relatório de falha ao Firebase.

  5. Acesse o painel do Crashlytics do console do Firebase para ver a falha do seu teste.

    Se você atualizou o console e ainda não está vendo a falha de teste após cinco minutos, habilite o log de depuração para ver se seu aplicativo está enviando relatórios de falha.


E é isso! O Crashlytics agora está monitorando seu aplicativo em busca de falhas. Visite o painel do Crashlytics para visualizar e investigar todos os seus relatórios e estatísticas.

Próximos passos

  • Integre-se com o Google Play para que você possa filtrar os relatórios de falhas do seu aplicativo Android pela trilha do Google Play diretamente no painel do Crashlytics. Isso permite que você concentre melhor seu painel em compilações específicas.