Chybové ukončení App Centeru (Android)

Důležité

31. března 2025 je naplánované vyřazení z provozu. I když můžete dál používat Visual Studio App Center, dokud ho úplně vyřadíte, existuje několik doporučených alternativ, na které můžete zvážit migraci.

Přečtěte si další informace o časových osách a alternativách podpory.

• Android
• iOS
• React Native
• MAUI/Xamarin
• UWP
• WPF/WinForms
• Unity
• macOS
• tvOS
• Cordova

Chybové ukončení App Center automaticky vygeneruje protokol chybových ukončení pokaždé, když dojde k chybovému ukončení aplikace. Protokol se nejprve zapíše do úložiště zařízení a když uživatel aplikaci znovu spustí, odešle se do App Center zpráva o chybovém ukončení. Shromažďování chyb funguje u beta i živých aplikací, tj. těch odeslaných na Google Play. Protokoly chyb obsahují cenné informace, které vám pomůžou chybu opravit.

Pokud jste v aplikaci ještě nenastavili sadu SDK, postupujte podle části Začínáme.

Vygenerování chybového ukončení testu

Aplikace App Center Crashes poskytuje rozhraní API pro vygenerování testovacího chybového ukončení pro snadné testování sady SDK. Toto rozhraní API se dá použít jenom v sestaveních ladění a v buildech vydaných verzí nebude dělat nic.

Crashes.generateTestCrash();

Crashes.generateTestCrash()

Získání dalších informací o předchozím chybovém ukončení

Aplikace App Center Crashes má dvě rozhraní API, která poskytují další informace pro případ, že dojde k chybovému ukončení aplikace.

Obdržela aplikace v předchozí relaci upozornění na nedostatek paměti?

Kdykoli po spuštění sady SDK můžete zkontrolovat, jestli aplikace obdržela upozornění paměti v předchozí relaci:

Crashes.hasReceivedMemoryWarningInLastSession();

Crashes.hasReceivedMemoryWarningInLastSession()

Toto rozhraní API je asynchronní. Další informace si o tom můžete přečíst v naší příručce k asynchronním rozhraním API app center .

Poznámka

Tuto metodu je možné použít pouze po Crashes spuštění, vždy se vrátí false před spuštěním.

Poznámka

V některých případech zařízení s nedostatkem paměti nemůže odesílat události.

Došlo k chybě aplikace v předchozí relaci?

Kdykoli po spuštění sady SDK můžete zkontrolovat, jestli aplikace při předchozím spuštění havarovala:

Crashes.hasCrashedInLastSession();

Crashes.hasCrashedInLastSession()

Toto rozhraní API je asynchronní. Další informace si o tom můžete přečíst v naší příručce k asynchronním rozhraním API app center .

To se hodí pro případ, že chcete upravit chování nebo uživatelské rozhraní aplikace po chybovém ukončení. Někteří vývojáři se rozhodli zobrazit další uživatelské rozhraní, aby se omluvili svým uživatelům, nebo chtějí po chybovém ukončení kontaktovat.

Poznámka

Tuto metodu je možné použít pouze po Crashes spuštění, vždy se vrátí false před spuštěním.

Podrobnosti o posledním chybovém ukončení

Pokud vaše aplikace dříve havarovala, můžete získat podrobnosti o posledním chybovém ukončení.

Crashes.getLastSessionCrashReport();

Crashes.getLastSessionCrashReport()

Toto rozhraní API je asynchronní. Další informace si o tom můžete přečíst v naší příručce k asynchronním rozhraním API app center .

Pro toto rozhraní API existuje mnoho případů použití. Nejběžnější z nich jsou lidé, kteří toto rozhraní API volají a implementují vlastní crashesListener.

Poznámka

Tuto metodu je možné použít pouze po Crashes spuštění, vždy se vrátí null před spuštěním.

Přizpůsobení využití chyb app center

Aplikace App Center Crashes poskytuje vývojářům zpětná volání, která mohou provádět další akce před a při odesílání protokolů chyb do App Center.

Pokud chcete zpracovat zpětná volání, buď implementujte všechny metody v CrashesListener rozhraní, nebo přepište AbstractCrashesListener třídu a vyberte pouze ty, které vás zajímají.

Použití vlastního crashesListeneru

Vytvořte si vlastní CrashesListener a přiřaďte ho takto:

CrashesListener customListener = new CrashesListener() {
    // Implement all callbacks here.
};
Crashes.setListener(customListener);

val customListener = object : CrashesListener {
    // Implement all callbacks here.
}
Crashes.setListener(customListener)

Pokud vás zajímá jenom přizpůsobení některých zpětných volání, použijte AbstractCrashesListener místo toho:

AbstractCrashesListener customListener = new AbstractCrashesListener() {
    // Implement any callback here as required.
};
Crashes.setListener(customListener);

val customListener = object : AbstractCrashesListener() {
    // Implement any callback here as required.
}
Crashes.setListener(customListener)

Poznámka

Nastavte naslouchací proces před voláním AppCenter.start(), protože App Center začne zpracovávat chybové ukončení hned po spuštění.

Mělo by se chybové ukončení zpracovat?

Toto zpětné volání implementujte, pokud chcete rozhodnout, jestli je potřeba zpracovat konkrétní chybové ukončení. Může například dojít k chybovému ukončení na úrovni systému, které byste chtěli ignorovat a které nechcete posílat do App Center.

@Override
public boolean shouldProcess(ErrorReport report) {
    return true; // return true if the crash report should be processed, otherwise false.
}

override fun shouldProcess(report: ErrorReport?): Boolean {
    return true
}

Požádejte uživatele o souhlas s odesláním protokolu chybových ukončení.

Pokud je pro vás ochrana osobních údajů uživatelů důležitá, můžete před odesláním zprávy o chybovém ukončení do App Center získat potvrzení uživatele. Sada SDK zveřejňuje zpětné volání, které informuje o chybách App Center, aby před odesláním zpráv o chybách čekalo na potvrzení uživatele.

Pokud jste se tak rozhodli, zodpovídáte za získání potvrzení uživatele, například prostřednictvím dialogového okna s jednou z následujících možností: Vždy odeslat, Odeslat a Neposílat. Na základě vstupu řeknete App Center, co dělat, a pak se s chybovým ukončením odpovídajícím způsobem zpracuje.

Poznámka

V sadě SDK se nezobrazuje dialogové okno, aplikace musí poskytnout vlastní uživatelské rozhraní, aby mohla požádat o souhlas uživatele.

Následující zpětné volání ukazuje, jak říct sadě SDK, aby před odesláním chybových ukončení čekala na potvrzení uživatele:

@Override
public boolean shouldAwaitUserConfirmation() {

    // 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;
}

override fun shouldAwaitUserConfirmation(): Boolean {
    return true
}

Pokud vrátíte true, vaše aplikace musí získat (pomocí vlastního kódu) oprávnění uživatele a odeslat sadě SDK zprávu s výsledkem pomocí následujícího rozhraní API:

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

Crashes.notifyUserConfirmation(Crashes.DONT_SEND)
Crashes.notifyUserConfirmation(Crashes.SEND)
Crashes.notifyUserConfirmation(Crashes.ALWAYS_SEND)

Jako příklad můžete odkázat na náš příklad vlastního dialogového okna.

Získání informací o stavu odesílání pro protokol chybových ukončení

Někdy chcete znát stav chybového ukončení aplikace. Běžným případem použití je, že můžete chtít zobrazit uživatelské rozhraní, které uživatelům oznámí, že vaše aplikace odesílá zprávu o chybovém ukončení, nebo v případě, že aplikace po spuštění rychle padá, chcete upravit chování aplikace, aby bylo možné odesílat protokoly chybových ukončení. Aplikace App Center Crashes má tři různá zpětná volání, která můžete ve své aplikaci použít k oznámení o tom, co se děje:

Před odesláním protokolu chyb sdk se vyvolá následující zpětné volání.

@Override
public void onBeforeSending(ErrorReport errorReport) {
    // Your code, e.g. to present a custom UI.
}

override fun onBeforeSending(report: ErrorReport?) {
    // Your code, e.g. to present a custom UI.
}

V případě, že máme problémy se sítí nebo výpadek koncového bodu a restartujete aplikaci, onBeforeSending aktivuje se po restartování procesu znovu.

Následující zpětné volání se vyvolá poté, co sada SDK úspěšně odeslala protokol chybových ukončení.

@Override
public void onSendingSucceeded(ErrorReport report) {
    // Your code, e.g. to hide the custom UI.
}

override fun onSendingSucceeded(report: ErrorReport?) {
    // Your code, e.g. to hide the custom UI.
}

Pokud se sadě SDK nepodařilo odeslat protokol chybových ukončení, vyvolá se následující zpětné volání.

@Override
public void onSendingFailed(ErrorReport report, Exception e) {
    // Your code goes here.
}

override fun onSendingFailed(report: ErrorReport?, e: Exception?) {
    // Your code goes here.
}

Příjem onSendingFailed znamená, že došlo k neobnovitelné chybě, například ke kódu 4xx . Například hodnota 401 znamená, že appSecret je špatná.

Toto zpětné volání se neaktivuje, pokud se jedná o problém se sítí. V tomto případě sada SDK stále opakuje pokusy (a pozastavuje opakování, když je síťové připojení mimo provoz).

Přidání příloh do zprávy o chybovém ukončení

Do zprávy o chybovém ukončení můžete přidat binární a textové přílohy. Sada SDK je odešle spolu s chybovým ukončením, abyste je mohli zobrazit na portálu App Center. Následující zpětné volání se vyvolá přímo před odesláním uloženého chybového ukončení z předchozích spuštění aplikace. Když dojde k chybě, nebude vyvolána. Ujistěte se, že soubor přílohy není pojmenovaný minidump.dmp , protože tento název je vyhrazený pro soubory s minidumpem. Tady je příklad připojení textu a obrázku k chybovému ukončení:

@Override
public Iterable<ErrorAttachmentLog> getErrorAttachments(ErrorReport report) {

    // Attach some text.
    ErrorAttachmentLog textLog = ErrorAttachmentLog.attachmentWithText("This is a text attachment.", "text.txt");

    // Attach binary data.
    byte[] binaryData = getYourBinary();
    ErrorAttachmentLog binaryLog = ErrorAttachmentLog.attachmentWithBinary(binaryData, "your_filename.jpeg", "image/jpeg");

    // Return attachments as list.
    return Arrays.asList(textLog, binaryLog);
}

override fun getErrorAttachments(report: ErrorReport?): MutableIterable<ErrorAttachmentLog> {

    // Attach some text.
    val textLog = ErrorAttachmentLog.attachmentWithText("This is a text attachment.", "text.txt")

    // Attach binary data.
    val binaryData = getYourBinary()
    val binaryLog = ErrorAttachmentLog.attachmentWithBinary(binaryData, "your_filename.jpeg", "image/jpeg")

    // Return attachments as list.
    return listOf(textLog, binaryLog)
}

Poznámka

Limit velikosti je aktuálně 7 MB. Při pokusu o odeslání větší přílohy dojde k chybě.

Povolení nebo zakázání chybových ukončení app center za běhu

Za běhu můžete povolit a zakázat chybové ukončení app center. Pokud ho zakážete, sada SDK nebude pro aplikaci hlásit žádné chybové ukončení.

Crashes.setEnabled(false);

Crashes.setEnabled(false)

Pokud chcete znovu povolit chybové ukončení App Centeru, použijte stejné rozhraní API, ale předejte true ho jako parametr.

Crashes.setEnabled(true);

Crashes.setEnabled(true)

Stav se v úložišti zařízení během spouštění aplikací udržuje.

Toto rozhraní API je asynchronní. Další informace si o tom můžete přečíst v naší příručce k asynchronním rozhraním API app center .

Poznámka

Tuto metodu je možné použít pouze po Crashes spuštění.

Kontrola, jestli jsou povolená chybová ukončení App Center

Můžete také zkontrolovat, jestli je povolená chyba App Center:

Crashes.isEnabled();

Crashes.isEnabled()

Toto rozhraní API je asynchronní. Další informace o tom najdete v naší příručce k asynchronním rozhraním API app center .

Poznámka

Tato metoda musí být použita pouze po Crashes spuštění, bude vždy vrácena false před spuštěním.

Zpracovávané chyby

App Center také umožňuje sledovat chyby pomocí zpracovaných výjimek. Použijte k tomu metodu trackError :

try {
    // your code goes here.
} catch (Exception exception) {
    Crashes.trackError(exception);
}

try {
    // your code goes here.
} catch (exception: Exception) {
    Crashes.trackError(exception)
}

Aplikace může volitelně připojit vlastnosti ke zpracovávané zprávě o chybách a poskytnout tak další kontext. Předejte vlastnosti jako mapu párů klíč/hodnota (pouze řetězce), jak je znázorněno v následujícím příkladu.

try {
    // your code goes here.
} catch (Exception exception) {
    Map<String, String> properties = new HashMap<String, String>() {{
        put("Category", "Music");
        put("Wifi", "On");
    }};
    Crashes.trackError(exception, properties, null);
}

try {
    // your code goes here.
} catch (exception: Exception) {
    val properties = mapOf("Category" to "Music", "Wifi" to "On")
    Crashes.trackError(exception, properties, null)
}

Do sestavy zpracovávané chyby můžete také volitelně přidat binární a textové přílohy. Předejte přílohy jako , Iterable jak je znázorněno v následujícím příkladu.

try {
    // your code goes here.
} catch (Exception exception) {

    // Attach some text.
    ErrorAttachmentLog textLog = ErrorAttachmentLog.attachmentWithText("This is a text attachment.", "text.txt");

    // Attach binary data.
    byte[] binaryData = getYourBinary();
    ErrorAttachmentLog binaryLog = ErrorAttachmentLog.attachmentWithBinary(binaryData, "your_filename.jpeg", "image/jpeg");

    // Track an exception with attachments.
    Crashes.trackError(exception, null, Arrays.asList(textLog, binaryLog));
}

try {
    // your code goes here.
} catch (exception: Exception) {

    // Attach some text.
    val textLog = ErrorAttachmentLog.attachmentWithText("This is a text attachment.", "text.txt")

    // Attach binary data.
    val binaryData = getYourBinary()
    val binaryLog = ErrorAttachmentLog.attachmentWithBinary(binaryData, "your_filename.jpeg", "image/jpeg")

    // Track an exception with attachments.
    Crashes.trackError(exception, null, listOf(textLog, binaryLog))
}

Hlášení chyb sady NDK

Hlášení chybových ukončení

Pokud chcete dostávat správné zprávy o chybách v App Center, nejprve se podle výše uvedených pokynů ujistěte, že máte nastavenou sadu App Center Crashes SDK.

Vytvoření knihovny zarážky

Dále zahrňte a zkompilujte Google Breakpad podle pokynů uvedených v oficiálním souboru README Google Breakpad pro Android.

Poznámka

Sada App Center SDK ve výchozím nastavení neobsahuje sadu Google Breakpad.

Připojení obslužné rutiny výjimky

Jakmile budete mít k dispozici Google Breakpad, připojte obslužnou rutinu chyb NDK za AppCenter.start:

// Attach NDK Crash Handler after SDK is initialized.
Crashes.getMinidumpDirectory().thenAccept(new AppCenterConsumer<String>() {
    @Override
    public void accept(String path) {

        // Path is null when Crashes is disabled.
        if (path != null) {
            setupNativeCrashesListener(path);
        }
    }
});

Metoda setupNativeCrashesListener je nativní metoda, kterou musíte implementovat v jazyce C/C++:

#include "google-breakpad/src/client/linux/handler/exception_handler.h"
#include "google-breakpad/src/client/linux/handler/minidump_descriptor.h"

void Java_com_microsoft_your_package_YourActivity_setupNativeCrashesListener(
        JNIEnv *env, jobject, jstring path) {
    const char *dumpPath = (char *) env->GetStringUTFChars(path, NULL);
    google_breakpad::MinidumpDescriptor descriptor(dumpPath);
    new google_breakpad::ExceptionHandler(descriptor, NULL, dumpCallback, NULL, true, -1);
    env->ReleaseStringUTFChars(path, dumpPath);
}

Kde dumpCallback se používá k řešení potíží:

/*
 * Triggered automatically after an attempt to write a minidump file to the breakpad folder.
 */
bool dumpCallback(const google_breakpad::MinidumpDescriptor &descriptor,
                  void *context,
                  bool succeeded) {

    // Allow system to log the native stack trace.
    __android_log_print(ANDROID_LOG_INFO, "YourLogTag",
                        "Wrote breakpad minidump at %s succeeded=%d\n", descriptor.path(),
                        succeeded);
    return false;
}

Jakmile jsou tyto metody správně nastavené, aplikace po restartování automaticky odešle minidump do App Center. Při řešení potíží můžete pomocí podrobných protokolů (AppCenter.setLogLevel(Log.VERBOSE) před AppCenter.start) zkontrolovat, jestli se po restartování aplikace odesílají minimální výpisy.

Poznámka

App Center používá rezervovaný název minidump.dmp pro přílohy s minidumpem. Pokud se jedná o soubor s minidumpem, nezapomeňte přílohu pojmenovat jinak, abychom ji mohli správně zpracovat.

Poznámka

V breakpadu je známá chyba, která znemožňuje zachycení chybových ukončení v emulátorech x86.

Symbolika

Další informace týkající se zpracování chyb najdete v dokumentaci k diagnostice .