Comece a usar o Firebase Crashlytics

Este guia de início rápido descreve como configurar o Firebase Crashlytics no 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

Adicione o Firebase ao seu projeto Apple, caso ainda não o tenha feito. Se você não tiver um aplicativo da Apple, poderá baixar um aplicativo de amostra .
Recomendado : para obter automaticamente registros de localização atual para entender as ações do usuário que levam a um evento de falha, não fatal ou ANR, você precisa ativar o Google Analytics em seu projeto do Firebase.
- Se o seu projeto existente do Firebase não tiver o Google Analytics ativado, você poderá ativar o Google Analytics na guia Integrações do seu > 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.
Observe que os logs de navegação estão disponíveis para todas as plataformas Apple suportadas pelo Crashlytics, exceto watchOS.

Etapa 1 : adicione o SDK do Crashlytics ao seu aplicativo

Use o Swift Package Manager para instalar e gerenciar dependências do Firebase.

No Xcode, com o projeto do seu aplicativo aberto, navegue até File > Add Packages .
Quando solicitado, adicione o repositório SDK das plataformas Apple do Firebase:

  https://github.com/firebase/firebase-ios-sdk.git

Escolha a biblioteca Crashlytics.

Para aproveitar os registros de localização atual , adicione também o SDK do Firebase para Google Analytics ao seu aplicativo. Certifique-se de que o Google Analytics esteja ativado em seu projeto Firebase.

Adicione o sinalizador -ObjC à seção Outros sinalizadores de vinculador das configurações de compilação do seu destino.

(somente macOS) Em seu Info.plist , adicione a chave NSApplicationCrashOnExceptions e defina-a como YES .

Quando terminar, o Xcode começará automaticamente a resolver e baixar suas dependências em segundo plano.

A seguir, configure o módulo Firebase:

Importe o módulo Firebase em sua App struct ou UIApplicationDelegate :
Rápido
```
import Firebase
```
Objetivo-C
```
@import Firebase;
```
Configure uma instância compartilhada FirebaseApp , normalmente no método application(_:didFinishLaunchingWithOptions:) do delegado do seu aplicativo:
Rápido
```
// Use the Firebase library to configure APIs.
FirebaseApp.configure()
```
Objetivo-C
```
// Use the Firebase library to configure APIs.
[FIRApp configure];
```

Etapa 2 : configurar o Xcode para fazer upload automático de arquivos dSYM

Para gerar relatórios de falhas legíveis por humanos, o Crashlytics precisa dos arquivos de símbolo de depuração (dSYM) do seu projeto. As etapas a seguir descrevem como configurar o Xcode para produzir automaticamente seus dSYMs, processá-los e fazer upload dos arquivos sempre que você criar seu aplicativo.

Abra o espaço de trabalho Xcode do seu projeto e selecione o arquivo do projeto no navegador esquerdo.
Na lista TARGETS , selecione seu destino de construção principal.
Clique na guia Configurações de compilação e conclua as etapas a seguir para que o Xcode produza dSYMs para suas compilações.
1. Clique em Todos e procure debug information format .
2. Defina o formato de informações de depuração como DWARF with dSYM File para todos os seus tipos de compilação.
Clique na guia Build Phases e conclua as etapas a seguir para que o Xcode possa processar seus dSYMs e fazer upload dos arquivos.
1. Clique em > Nova fase de execução de script .
  Certifique-se de que esta nova fase Run Script seja a última fase de construção do seu projeto; caso contrário, o Crashlytics não poderá processar dSYMs adequadamente.
2. Expanda a nova seção Executar Script .
  Nota: Para as subetapas restantes, copie e cole os caminhos exatamente como especificado e o Xcode os resolverá. No entanto, se você tiver problemas com o Xcode para resolver esses caminhos ou com uma estrutura de projeto exclusiva, poderá especificar manualmente os caminhos.
3. No campo script (localizado sob o rótulo Shell ), adicione o script de execução a seguir.
  Este script processa os arquivos dSYM do seu projeto e carrega os arquivos no Crashlytics.
```
"${BUILD_DIR%/Build/*}/SourcePackages/checkouts/firebase-ios-sdk/Crashlytics/run"
```
4. Na seção Arquivos de entrada , adicione os caminhos para os locais dos seguintes arquivos:
```
${DWARF_DSYM_FOLDER_PATH}/${DWARF_DSYM_FILE_NAME}
```
```
${DWARF_DSYM_FOLDER_PATH}/${DWARF_DSYM_FILE_NAME}/Contents/Resources/DWARF/${PRODUCT_NAME}
```
```
${DWARF_DSYM_FOLDER_PATH}/${DWARF_DSYM_FILE_NAME}/Contents/Info.plist
```
```
$(TARGET_BUILD_DIR)/$(UNLOCALIZED_RESOURCES_FOLDER_PATH)/GoogleService-Info.plist
```
```
$(TARGET_BUILD_DIR)/$(EXECUTABLE_PATH)
```
  Entenda por que as localizações desses arquivos são necessárias
  O Xcode procura esses arquivos de entrada nos locais especificados para garantir que os arquivos de construção estejam disponíveis para o script de execução. Além disso, se o User Script Sandboxing estiver ativado, o Xcode permitirá apenas que o script de execução acesse os arquivos especificados em Input Files .
  - Fornecer a localização dos arquivos dSYM do seu projeto permite que o Crashlytics processe dSYMs.
  - Fornecer a localização do arquivo GoogleService-Info.plist criado pelo seu aplicativo permite que o Crashlytics associe os dSYMs ao seu aplicativo Firebase.
  - Fornecer a localização do executável do seu aplicativo permite que o script de execução evite uploads duplicados do mesmo dSYM. Observe que os binários do aplicativo não são carregados .

Para obter informações mais detalhadas sobre arquivos dSYM e Crashlytics (incluindo como fazer upload manual de arquivos dSYM), visite Obter relatórios de falhas desofuscados .

Etapa 3 : 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.

Adicione código ao seu aplicativo que você pode usar para forçar uma falha de teste.

Você pode usar o código a seguir para adicionar um botão ao seu aplicativo que, quando pressionado, causa uma falha. O botão é denominado "Test Crash".

SwiftUI

Button("Crash") {
  fatalError("Crash was triggered")
}

UI Kit

Rápido

import UIKit

class ViewController: UIViewController {
  override func viewDidLoad() {
      super.viewDidLoad()

      // Do any additional setup after loading the view, typically from a nib.

      let button = UIButton(type: .roundedRect)
      button.frame = CGRect(x: 20, y: 50, width: 100, height: 30)
      button.setTitle("Test Crash", for: [])
      button.addTarget(self, action: #selector(self.crashButtonTapped(_:)), for: .touchUpInside)
      view.addSubview(button)
  }

  @IBAction func crashButtonTapped(_ sender: AnyObject) {
      let numbers = [0]
      let _ = numbers[1]
  }
}

Objetivo-C

#import "ViewController.h"

@implementation ViewController
‐ (void)viewDidLoad {
    [super viewDidLoad];

    // Do any additional setup after loading the view, typically from a nib.

    UIButton* button = [UIButton buttonWithType:UIButtonTypeRoundedRect];
    button.frame = CGRectMake(20, 50, 100, 30);
    [button setTitle:@"Test Crash" forState:UIControlStateNormal];
    [button addTarget:self action:@selector(crashButtonTapped:)
        forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:button];
}

‐ (IBAction)crashButtonTapped:(id)sender {
    @[][1];
}

@end

Crie e execute seu aplicativo no Xcode com o depurador Xcode desconectado.
O depurador Xcode evita que relatórios de falhas sejam enviados ao Crashlytics. Conclua as etapas a seguir para desconectar seu dispositivo de teste ou simulador do depurador Xcode antes de forçar uma falha.
1. Clique em Build e execute o esquema atual para criar seu aplicativo em um dispositivo de teste ou simulador.
2. Aguarde até que seu aplicativo esteja em execução e clique em Parar de executar o esquema ou ação para fechar a instância inicial do seu aplicativo. Esta instância inicial incluía o depurador que interfere no Crashlytics.
Force a falha do teste para enviar o primeiro relatório de falha do seu aplicativo:
1. Abra seu aplicativo na tela inicial do seu dispositivo de teste ou simulador.
2. No seu aplicativo, pressione o botão "Test Crash" que você adicionou usando o código acima.
3. Depois que seu aplicativo travar, execute-o novamente no Xcode para que seu aplicativo possa enviar o relatório de falha ao Firebase.
Acesse o painel do Crashlytics do console do Firebase para ver a falha do teste.
Se você atualizou o console e ainda não vê a falha do teste após cinco minutos, habilite o registro 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

Personalize a configuração do seu relatório de falhas adicionando relatórios opcionais, registros, chaves e rastreamento de erros não fatais.