Arresti anomali di App Center (React Native)

Gli arresti anomali di App Center genereranno automaticamente un log di arresto anomalo ogni volta che l'app si arresta in modo anomalo. Il log viene prima scritto nella risorsa di archiviazione del dispositivo e quando l'utente avvia nuovamente l'app, il report di arresto anomalo verrà inviato ad App Center. La raccolta di arresti anomali funziona sia per le app beta che per quelle attive, ovvero quelle inviate a Google Play. I log di arresto anomalo contengono informazioni utili per risolvere l'arresto anomalo del sistema.

Se non è ancora stato configurato l'SDK nell'applicazione, seguire la sezione Introduzione.

Ovunque si usiNo arresti anomali di App Center, aggiungere l'importazione seguente all'inizio del file.

// Import App Center Crashes at the top of the file.
import Crashes from 'appcenter-crashes';

Generare un arresto anomalo del test

Gli arresti anomali di App Center offrono un'API per generare un arresto anomalo del test per semplificare il test dell'SDK. Questa API può essere usata solo nelle app di test/beta e non esegue alcuna operazione nelle app di produzione.

Crashes.generateTestCrash();

È anche facile generare un arresto anomalo di JavaScript. Aggiungere la riga seguente al codice, che genera un errore JavaScript e causa un arresto anomalo.

throw new Error('This is a test javascript crash!');

Ottenere altre informazioni su un arresto anomalo precedente

Gli arresti anomali di App Center hanno due API che forniscono altre informazioni in caso di arresto anomalo dell'app.

L'app ha ricevuto un avviso di memoria insufficiente nella sessione precedente?

In qualsiasi momento dopo l'avvio dell'SDK, è possibile verificare se l'app ha ricevuto un avviso di memoria nella sessione precedente:

const hadLowMemoryWarning = await Crashes.hasReceivedMemoryWarningInLastSession();

L'arresto anomalo dell'app nella sessione precedente?

In qualsiasi momento dopo l'avvio dell'SDK, è possibile verificare se l'app si è arrestata in modo anomalo nell'avvio precedente:

const didCrash = await Crashes.hasCrashedInLastSession();

Questo è utile nel caso in cui vuoi modificare il comportamento o l'interfaccia utente della tua app dopo che si è verificato un arresto anomalo. Alcuni sviluppatori hanno scelto di mostrare un'interfaccia utente aggiuntiva per scusarsi con gli utenti o desiderano entrare in contatto dopo che si è verificato un arresto anomalo.

Dettagli sull'ultimo arresto anomalo

Se l'app si è arrestata in modo anomalo in precedenza, è possibile ottenere dettagli sull'ultimo arresto anomalo.

const crashReport = await Crashes.lastSessionCrashReport();

Personalizzare l'utilizzo degli arresti anomali di App Center

Gli arresti anomali di App Center forniscono callback per gli sviluppatori per eseguire azioni aggiuntive prima e quando si inviano log di arresto anomalo ad App Center.

Arresto anomalo dell'elaborazione in JavaScript

Affinché i Crash.setListener metodi funzionino come previsto, è necessario verificare se l'applicazione è configurata correttamente.

1. Aprire il file del ios/YourAppName/AppDelegate.m progetto e verificare di avere [AppCenterReactNativeCrashes register]; invece di [AppCenterReactNativeCrashes registerWithAutomaticProcessing];.
2. Aprire il file del android/app/src/main/res/values/strings.xml progetto e verificare che appCenterCrashes_whenToSendCrashes sia impostato su ASK_JAVASCRIPT.

Tutti i diversi callback del listener di eventi vengono discussi uno per uno in questo documento, ma è necessario impostare un listener di eventi che definiscano tutti i callback contemporaneamente.

L'arresto anomalo deve essere elaborato?

Implementare questo callback se si vuole decidere se un determinato arresto anomalo deve essere elaborato o meno. Ad esempio, potrebbe verificarsi un arresto anomalo a livello di sistema che si vuole ignorare e che non si vuole inviare ad App Center.

Crashes.setListener({

    shouldProcess: function (report) {
        return true; // return true if the crash report should be processed, otherwise false.
    },

    // Other callbacks must also be defined at the same time if used.
    // Default values are used if a method with return parameter isn't defined.
});

Chiedere il consenso dell'utente per inviare un log di arresto anomalo

Se la privacy dell'utente è importante per l'utente, è necessario ricevere una conferma dell'utente prima di inviare un report di arresto anomalo al Centro app. L'SDK espone un callback che indica agli arresti anomali di App Center di attendere la conferma dell'utente prima di inviare eventuali segnalazioni di arresto anomalo.

Se si sceglie di farlo, si è responsabili di ottenere la conferma dell'utente, ad esempio tramite una richiesta di dialogo con una delle opzioni seguenti: Invia sempre, Invia e Non inviare. In base all'input, si indicherà agli arresti anomali di App Center cosa fare e l'arresto anomalo verrà quindi gestito di conseguenza.

Il callback seguente illustra come indicare all'SDK di attendere la conferma dell'utente prima di inviare arresti anomali:

Crashes.setListener({

    shouldAwaitUserConfirmation: function (report) {

        // Build your own UI to ask for user consent here. SDK doesn't provide one by default.

        // Return true if you built a UI for user consent and are waiting for user input on that custom UI, otherwise false.
        return true;
    },

    // Other callbacks must also be defined at the same time if used.
    // Default values are used if a method with return parameter isn't defined.
});

Se si restituisce true, l'app deve ottenere (usando il proprio codice) l'autorizzazione dell'utente e aggiornare l'SDK con il risultato usando l'API seguente:

import Crashes, { UserConfirmation } from 'appcenter-crashes';

// Depending on the user's choice, call Crashes.notifyUserConfirmation() with the right value.
Crashes.notifyUserConfirmation(UserConfirmation.DONT_SEND);
Crashes.notifyUserConfirmation(UserConfirmation.SEND);
Crashes.notifyUserConfirmation(UserConfirmation.ALWAYS_SEND);

Ottenere informazioni sullo stato di invio per un log di arresto anomalo

A volte, vuoi conoscere lo stato dell'arresto anomalo dell'app. Un caso d'uso comune è che potresti voler mostrare all'interfaccia utente che indica agli utenti che l'app sta inviando un report di arresto anomalo o, nel caso in cui l'app si arresti in modo anomalo dopo l'avvio, vuoi modificare il comportamento dell'app per assicurarti che i log di arresto anomalo possano essere inviati. Gli arresti anomali di App Center hanno tre callback diversi che puoi usare nella tua app per ricevere una notifica di cosa sta succedendo.

A tale scopo, definire un listener di eventi nel codice come illustrato nell'esempio seguente:

Crashes.setListener({
    onBeforeSending: function (report) {
        // called after Crashes.process and before sending the crash.
    },
    onSendingSucceeded: function (report) {
        // called when crash report sent successfully.
    },
    onSendingFailed: function (report) {
        // called when crash report couldn't be sent.
    }

    // Other callbacks must also be defined at the same time if used.
    // Default values are used if a method with return parameter isn't defined.
});

Tutti i callback sono facoltativi. Non è necessario fornire tutti e 3 i metodi nell'oggetto listener dell'evento, ad esempio è possibile implementare solo onBeforeSending.

La ricezione onSendingFailed indica che si è verificato un errore non recuperabile, ad esempio un codice 4xx . Ad esempio, 401 indica che l'errore appSecret è.

Questo callback non viene attivato se si tratta di un problema di rete. In questo caso, l'SDK continua a ritentare (e sospende anche i tentativi mentre la connessione di rete è inattiva). In caso di problemi di rete o interruzione dell'endpoint e il riavvio dell'app viene onBeforeSending attivato di nuovo dopo il riavvio del processo.

Aggiungere allegati a un report di arresto anomalo

È possibile aggiungere allegati binari e di testo a un report di arresto anomalo del sistema. L'SDK li invierà insieme all'arresto anomalo in modo da poterli visualizzare nel portale di App Center. Il callback seguente viene richiamato immediatamente prima di inviare l'arresto anomalo archiviato dall'avvio dell'applicazione precedente. Non verrà richiamato quando si verifica l'arresto anomalo. Assicurarsi che il file allegato non sia denominato minidump.dmp in quanto tale nome è riservato per i file minidump. Ecco un esempio di come allegare testo e un'immagine a un arresto anomalo:

import Crashes, { ErrorAttachmentLog } from 'appcenter-crashes';

Crashes.setListener({
    getErrorAttachments(report) {
        const textAttachment = ErrorAttachmentLog.attachmentWithText('Hello text attachment!', 'hello.txt');
        const binaryAttachment = ErrorAttachmentLog.attachmentWithBinary(`${imageAsBase64string}`, 'logo.png', 'image/png');
        return [textAttachment, binaryAttachment];
    }

    // Other callbacks must also be defined at the same time if used.
    // Default values are used if a method with return parameter isn't defined.
});

Il fileName parametro è facoltativo (può essere null) e viene usato solo nel portale di App Center. Da un evento di arresto anomalo specifico nel portale, è possibile visualizzare gli allegati e scaricarli. Se è stato specificato un nome di file, sarà il nome del file da scaricare; in caso contrario, viene generato automaticamente il nome del file.

Per configurare il getErrorAttachments callback per lavorare con le funzioni asincrone/await ES2017, restituire invece una promessa soddisfatta. L'esempio seguente associa un testo e un'immagine a un arresto anomalo in modo asincrono:

import Crashes, { ErrorAttachmentLog } from 'appcenter-crashes';

Crashes.setListener({
    getErrorAttachments(report) {
        return (async () => {
            const textContent = await readTextFileAsync(); // use your async function to read text file
            const binaryContent = await readBinaryFileAsync(); // use your async function to read binary file
            const textAttachment = ErrorAttachmentLog.attachmentWithText(textContent, 'hello.txt');
            const binaryAttachment = ErrorAttachmentLog.attachmentWithBinary(binaryContent, 'logo.png', 'image/png');
            return [textAttachment, binaryAttachment];
        })();
    }

    // Other callbacks must also be defined at the same time if used.
    // Default values are used if a method with return parameter isn't defined.
});

Errori gestiti

App Center consente anche di tenere traccia degli errori usando le eccezioni gestite tramite trackError il metodo . Un'app può facoltativamente allegare proprietà o/e allegati a un report degli errori gestito per fornire ulteriore contesto.

try {
    // Throw error.
} catch (error) {

    // Prepare properties.
    const properties = { 'Category' : 'Music', 'Wifi' : 'On' };

    // Prepare attachments.
    const textAttachment = ErrorAttachmentLog.attachmentWithText('Hello text attachment!', 'hello.txt');
    const attachments = [textAttachment];

    // Create an exception model from error.
    const exceptionModel1 = ExceptionModel.createFromError(error);

    // ..or generate with your own error data.
    const exceptionModel2 = ExceptionModel.createFromTypeAndMessage("type", "message", "stacktrace");

    // Track error with custom data.
    Crashes.trackError(exceptionModel1, properties, attachments);
    Crashes.trackError(exceptionModel1, properties, nil);
    Crashes.trackError(exceptionModel2, nil, attachments);
    Crashes.trackError(exceptionModel2, nil, nil);
}

Blocco interruzioni

App Center supporta arresti anomali del breakpad da Android NDK in un'app React Native.

Seguire la procedura di configurazione normale precedente e, nell'override MainActivity.javaOnCreate , aggiungere la configurazione minidump e chiamare nel codice nativo che configura la configurazione del breakpad.

Esempio:

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Crashes.getMinidumpDirectory().thenAccept(new AppCenterConsumer<String>() {
      @Override
      public void accept(String path) {
        // Path is null when Crashes is disabled.
        if (path != null) {
          // links to NDK
          setupBreakpadListener(path);
        }
      }
    });
  }

Abilitare o disabilitare arresti anomali di App Center in fase di esecuzione

È possibile abilitare e disabilitare arresti anomali di App Center in fase di esecuzione. Se la si disabilita, l'SDK non eseguirà alcuna segnalazione di arresto anomalo per l'app.

await Crashes.setEnabled(false);

Per abilitare di nuovo gli arresti anomali di App Center, usare la stessa API ma passare true come parametro.

await Crashes.setEnabled(true);

Lo stato viene salvato in modo permanente nella risorsa di archiviazione del dispositivo tra i lanci dell'applicazione.

Controllare se Gli arresti anomali di App Center sono abilitati

È anche possibile verificare se Gli arresti anomali di App Center sono abilitati o meno:

const enabled = await Crashes.isEnabled();