Chybové ukončení App Center (Android)

Důležité

Visual Studio App Center bylo vyřazeno 31. března 2025 s výjimkou funkcí Analýzy a diagnostiky, které se budou dál podporovat až do 30. června 2026. Další informace.

• Android
• Ios
• React Native
• MAUI/Xamarin
• UPW
• WPF/WinForms
• Jednota
• macOS
• tvOS

Pokaždé, když vaše aplikace spadne, funkce App Center Crashes automaticky vygeneruje záznam pádu. Protokol se nejprve zapíše do úložiště zařízení a když uživatel aplikaci znovu spustí, zpráva o chybovém ukončení se odešle do App Center. Shromažďování chybových ukončení funguje pro beta i živé aplikace, tj. ty odeslané do Google Play. Protokoly havárií obsahují cenné informace, které vám pomohou opravit havárie.

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

Vyvolat testovací pád

App Center Crashes poskytuje rozhraní API pro vygenerování zkušebního pádu pro snadné testování SDK. Toto rozhraní API je možné použít pouze v debug buildech a ve vydáních nebude fungovat.

Crashes.generateTestCrash();

Crashes.generateTestCrash()

Získejte více informací o předchozím pádu

App Center crashes má dvě rozhraní API, která poskytují další informace pro případ, že dojde k chybovému ukončení vaší 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 v předchozí relaci obdržela upozornění na paměť:

Crashes.hasReceivedMemoryWarningInLastSession();

Crashes.hasReceivedMemoryWarningInLastSession()

Toto rozhraní API je asynchronní. Další informace najdete v naší příručce k asynchronním rozhraním API služby App Center .

Poznámka:

Tato metoda se musí použít pouze po spuštění Crashes, vždy se vrátí false před zahájením.

Poznámka:

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

Došlo k pádu aplikace v předchozí relaci?

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

Crashes.hasCrashedInLastSession();

Crashes.hasCrashedInLastSession()

Toto rozhraní API je asynchronní. Další informace najdete v naší příručce k asynchronním rozhraním API služby App Center .

To se hodí v případě, že chcete upravit chování nebo uživatelské rozhraní aplikace po havárii. Někteří vývojáři se rozhodli zobrazit další uživatelské rozhraní, aby se omlouval svým uživatelům, nebo chtějí, aby se po havárii mohli spojit.

Poznámka:

Tato metoda se musí použít pouze po spuštění Crashes, vždy se vrátí false před zahájením.

Podrobnosti o posledním pádu

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

Crashes.getLastSessionCrashReport();

Crashes.getLastSessionCrashReport()

Toto rozhraní API je asynchronní. Další informace najdete v naší příručce k asynchronním rozhraním API služby App Center .

Pro toto rozhraní API existuje mnoho případů použití, přičemž nejběžnější je volání tohoto rozhraní API lidmi, kteří implementují vlastní CrashesListener.

Poznámka:

Tato metoda se musí použít pouze po spuštění Crashes, vždy se vrátí null před zahájením.

Přizpůsobit používání funkce havárií v App Center

Služba App Center Crashes poskytuje zpětná volání, která umožňují vývojářům provádět další akce před odesláním protokolů o pádech 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žijte vlastní CrashesListener

Vytvořte vlastní CrashesListener a přiřaďte ho následujícím způsobem:

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 callbacků, 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 posluchač před voláním AppCenter.start(), protože App Center začne zpracovávat chyby okamžitě po spuštění.

Měla by se havárie zpracovat?

Tuto zpětné volání implementujte, pokud se chcete rozhodnout, jestli je potřeba zpracovat konkrétní chybové ukončení nebo ne. Může se například stát, že dojde k chybovému ukončení na úrovni systému, které byste chtěli ignorovat a že 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 selhání.

Pokud je pro vás ochrana osobních údajů 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. SDK poskytuje zpětné volání, které instruuje App Center Crashes, aby před odesláním jakýchkoli zpráv o chybách čekal na potvrzení uživatele.

Pokud jste se rozhodli to udělat, 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 Neodesílat. Na základě vkladu dat řeknete aplikaci App Center, jak řešit pád aplikace, a ten pak bude následně řešen odpovídajícím způsobem.

Poznámka:

Sada SDK pro toto dialogové okno nezobrazuje, aplikace musí poskytnout vlastní uživatelské rozhraní, aby požádala o souhlas uživatele.

Následující zpětné volání ukazuje, jak sadě SDK sdělit, 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 se vrátíte na true, vaše aplikace musí pomocí vlastního kódu získat oprávnění uživatele a informovat sadu SDK o výsledku prostřednictvím následujícího 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 odkazovat na náš vlastní příklad dialogového okna.

Získejte informace o stavu odesílání protokolu o selhání

Někdy chcete zjistit stav pádu aplikace. Běžným případem použití je, že můžete chtít zobrazit uživatelské rozhraní, které uživatelům říká, že aplikace odesílá zprávu o chybovém ukončení, nebo pokud se aplikace po spuštění rychle chybově ukončí, chcete upravit chování aplikace, aby se zajistilo odeslání protokolů chybových ukončení. Ve službě App Center Crashes jsou k dispozici tři různá zpětná volání, která můžete použít ve své aplikaci, abyste byli informováni o tom, co se děje.

Před odesláním chybového záznamu 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ě problémů se sítí nebo výpadkem koncového bodu se po restartování procesu znovu aktivuje aplikace onBeforeSending .

Následující zpětné volání se vyvolá po úspěšném odeslání protokolu chybových ukončení sady SDK.

@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 SDK nepodařilo odeslat protokol o selhání, 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ě, jako je kód 4xx . Například 401 znamená, že appSecret je nesprávná.

Toto zpětné volání se neaktivuje, pokud se jedná o problém se sítí. V tomto případě sada SDK pokračuje v opakování (a zároveň pozastaví opakování, zatímco síťové připojení je mimo provoz).

Přidání příloh do hlášení o pádu

Do zprávy o chybovém ukončení můžete přidat binární a textové přílohy. SDK je odešle spolu s pádem aplikace, abyste je mohli vidět na portálu App Center. Před odesláním uloženého chybového ukončení z předchozího spuštění aplikace se vyvolá následující zpětné volání. Když dojde k chybovému ukončení, nevyvolá se. Ujistěte se, že soubor přílohy není pojmenovaný minidump.dmp , protože tento název je vyhrazený pro soubory minidump. 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í pádů App Center při běhu

Za běhu můžete povolit a zakázat pády aplikace App Center. Pokud ji zakážete, sada SDK pro aplikaci neudělá žádné zprávy o chybách.

Crashes.setEnabled(false);

Crashes.setEnabled(false)

Pokud chcete znovu povolit pády aplikace App Center, použijte stejné rozhraní API, ale předejte true jako parametr.

Crashes.setEnabled(true);

Crashes.setEnabled(true)

Stav se zachová v úložišti zařízení napříč spuštěním aplikace.

Toto rozhraní API je asynchronní. Další informace najdete v naší příručce k asynchronním rozhraním API služby App Center .

Poznámka:

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

Kontrola, jestli je povolené chybové ukončení App Center

Můžete také zkontrolovat, jestli je funkce App Center pro sledování pádů aplikací povolená, nebo ne:

Crashes.isEnabled();

Crashes.isEnabled()

Toto rozhraní API je asynchronní. Další informace najdete v naší příručce k asynchronním rozhraním API služby App Center .

Poznámka:

Tato metoda se musí použít pouze po spuštění Crashes, vždy se vrátí false před zahájením.

Vyřešené chyby

App Center také umožňuje sledovat chyby pomocí zpracovaných výjimek. K tomu použijte 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 k 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 zpracovávané zprávy o chybách 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í pádů NDK

Hlášení pádů

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

Sestavení knihovny breakpadu

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

Poznámka:

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

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

Jakmile zahrnete Google Breakpad, připojte zpracovatele havárií 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 je nativní metoda setupNativeCrashesListener , 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é, odešle aplikace minidump do App Center automaticky po restartování. 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í minidumps.

Poznámka:

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

Poznámka:

V Breakpad je známá chyba, která znemožňuje zachycení pádů v emulátorech x86.

Symbolika

Další informace o zpracování pádů najdete v dokumentaci k diagnostice.