Az App Center összeomlik (Android)

Fontos

A Visual Studio App Center 2025. március 31-én megszűnt, kivéve az Elemzési és diagnosztikai funkciókat, amelyek 2026. június 30-ig továbbra is támogatottak lesznek. Tudj meg többet.

• Android
• Ios
• React Native
• MAUI/Xamarin
• UWP
• WPF/WinForms
• Egység
• macOS
• tvOS-

Az App Center összeomlásai automatikusan létrehoznak összeomlási naplót minden alkalommal, amikor az alkalmazás összeomlik. A napló először az eszköz tárolójába lesz beírva, és amikor a felhasználó újra elindítja az alkalmazást, a rendszer elküldi az összeomlási jelentést az App Centernek. Az összeomlások gyűjtése a bétaverziós és az élő alkalmazások, azaz a Google Play-be küldött alkalmazások esetében is működik. Az összeomlási naplók értékes információkat tartalmaznak az összeomlás elhárításához.

Kövesse az Első lépések szakaszt, ha még nem állította be az SDK-t az alkalmazásban.

Készítsen tesztösszeomlást

Az App Center Crashes egy API-t biztosít, amellyel tesztösszeomlást hozhat létre az SDK egyszerű teszteléséhez. Ez az API csak a buildek hibakeresésében használható, és a kiadási buildekben semmit sem fog tenni.

Crashes.generateTestCrash();

Crashes.generateTestCrash()

További információ az előző összeomlásról

Az App Center Összeomlások két API-val rendelkezik, amelyek további információt nyújtanak arról, hogy az alkalmazás összeomlott-e.

Az alkalmazás alacsony memóriahasználati figyelmeztetést kapott az előző munkamenetben?

Az SDK elindítása után bármikor ellenőrizheti, hogy az alkalmazás memóriariasztást kapott-e az előző munkamenetben:

Crashes.hasReceivedMemoryWarningInLastSession();

Crashes.hasReceivedMemoryWarningInLastSession()

Ez az API aszinkron, erről az App Center Aszinkron API-k útmutatójában olvashat bővebben.

Megjegyzés:

Ezt a metódust csak akkor szabad használni, ha a Crashes már elindult. Mindig visszaad false a kezdés előtt.

Megjegyzés:

Bizonyos esetekben a kevés memóriával rendelkező eszköz nem tud eseményeket küldeni.

Összeomlott az alkalmazás az előző munkamenetben?

Az SDK elindítása után bármikor ellenőrizheti, hogy az alkalmazás összeomlott-e az előző indításkor:

Crashes.hasCrashedInLastSession();

Crashes.hasCrashedInLastSession()

Ez az API aszinkron, erről az App Center Aszinkron API-k útmutatójában olvashat bővebben.

Ez akkor hasznos, ha az összeomlás után módosítani szeretné az alkalmazás viselkedését vagy felhasználói felületét. Egyes fejlesztők úgy döntöttek, hogy további felhasználói felületet mutatnak, hogy bocsánatot kérjenek a felhasználóiktól, vagy szeretnének kapcsolatba lépni egy összeomlás után.

Megjegyzés:

Ezt a metódust csak akkor szabad használni, ha a Crashes már elindult. Mindig visszaad false a kezdés előtt.

Az utolsó összeomlás részletei

Ha az alkalmazás korábban összeomlott, részletes információkat kaphat az utolsó összeomlásról.

Crashes.getLastSessionCrashReport();

Crashes.getLastSessionCrashReport()

Ez az API aszinkron, erről az App Center Aszinkron API-k útmutatójában olvashat bővebben.

Ehhez az API-hoz számos használati eset létezik, a leggyakoribbak azok, akik ezt az API-t hívják, és implementálják az egyéni CrashesListenert.

Megjegyzés:

Ezt a metódust csak akkor szabad használni, ha a Crashes már elindult. Mindig visszaad null a kezdés előtt.

Az App Center-összeomlások használatának testreszabása

Az App Center összeomlásai visszahívásokat biztosítanak a fejlesztőknek, hogy további műveleteket hajtsanak végre az összeomlási naplók App Centerbe való küldése előtt és során.

A visszahívások kezeléséhez vagy implementálja az összes metódust a CrashesListener felületen, vagy a AbstractCrashesListener osztály felülbírálásával csak azokat válassza ki, amelyek érdeklik.

Saját CrashesListener használata

Hozza létre a saját CrashesListener-jét, és rendelje hozzá így:

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

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

Ha csak néhány visszahívást szeretne testre szabni, használja a következőt AbstractCrashesListener :

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)

Megjegyzés:

A hívása AppCenter.start() állítsa be a figyelőt, mivel az App Center közvetlenül a kezdés után megkezdi az összeomlások feldolgozását.

Fel kell dolgoznunk az összeomlást?

Implementálja ezt a visszahívást, ha el szeretné dönteni, hogy egy adott összeomlást fel kell-e dolgozni vagy sem. Előfordulhat például egy rendszerszintű összeomlás, amelyet figyelmen kívül szeretne hagyni, és amelyet nem szeretne elküldeni az App Centerbe.

@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
}

Kérje meg a felhasználó hozzájárulását összeomlási napló küldéséhez

Ha fontos önnek a felhasználói adatvédelem, érdemes lehet a felhasználó megerősítését kapnia, mielőtt összeomlási jelentést küldene az App Centernek. Az SDK biztosít egy visszahívást, amely az App Center Crashes számára jelzi, hogy várjon a felhasználói visszaigazolásra, mielőtt bármilyen összeomlási jelentést küldene.

Ha ezt választotta, ön a felelős a felhasználó megerősítésének beszerzéséért, például egy párbeszédpanelen keresztül, amely a következő lehetőségek egyikét tartalmazza: Always Send, Send és Don't send. A bemenet alapján meg fogja mondani az App Center Crashesnek, hogy mit kell tennie, és az összeomlást ennek megfelelően fogja kezelni.

Megjegyzés:

Az SDK ehhez nem jelenít meg párbeszédpanelt, az alkalmazásnak saját felhasználói felületet kell biztosítania a felhasználói hozzájárulás kéréséhez.

Az alábbi visszahívás bemutatja, hogyan adhatja az SDK-nak az utasítást, hogy várjon a felhasználói megerősítésre az összeomlások elküldése előtt.

@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
}

Ha visszatér true, az alkalmazásnak (a saját kódjával) be kell szereznie a felhasználó engedélyét, majd az eredményt az alábbi API-t használva kell közölnie az SDK-val.

// 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)

Példaként hivatkozhat az egyéni párbeszédpanel-példánkra.

Információk az összeomlási napló küldési állapotáról

Időnként tudni szeretné az alkalmazás összeomlásának állapotát. Gyakori használati eset, hogy olyan felhasználói felületet szeretne megjeleníteni, amely tájékoztatja a felhasználókat arról, hogy az alkalmazás összeomlási jelentést küld, vagy ha az alkalmazás az indítás után gyorsan összeomlik, módosítania kell az alkalmazás viselkedését, hogy az összeomlási naplók elküldhetők legyenek. Az App Center Összeomlások három különböző visszahívással rendelkezik, amelyeket az alkalmazásban használhat, hogy értesítést kapjon a történtekről:

A rendszer a következő visszahívást hívja meg, mielőtt az SDK összeomlási naplót küld

@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.
}

Ha hálózati problémák vagy kimaradás lép fel a végponton, és újraindítja az alkalmazást, onBeforeSending a folyamat újraindítása után újra aktiválódik.

A rendszer az alábbi visszahívást fogja meghívni, miután az SDK sikeresen elküldte az összeomlási naplót

@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.
}

A rendszer a következő visszahívást hívja meg, ha az SDK nem tudott összeomlási naplót küldeni

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

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

A(z) onSendingFailed azt jelenti, hogy nem helyreállítható hiba, például egy 4xx kód történt. Például a 401 azt jelenti, hogy a appSecret helytelen.

Ez a visszahívás hálózati probléma esetén nem aktiválódik. Ebben az esetben az SDK folytatja az újrapróbálkozást (és szünetelteti az újrapróbálkozást, amíg a hálózati kapcsolat leáll).

Összeomlási jelentéshez mellékletek hozzáadása

Bináris és szöveges mellékleteket is hozzáadhat az összeomlási jelentésekhez. Az SDK az összeomlással együtt küldi el őket, hogy megjelenjenek az App Center portálon. A rendszer a következő visszahívást fogja meghívni, mielőtt elküldené a tárolt összeomlást az előző alkalmazásindításokból. Az összeomlás bekövetkezésekor a rendszer nem fogja meghívni. Győződjön meg arról, hogy a mellékletfájl neve nincs elnevezve minidump.dmp , mivel ez a név a minidump fájlok számára van fenntartva. Íme egy példa arra, hogyan csatolhat szöveget és képet egy váratlan hibához:

@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)
}

Megjegyzés:

A méretkorlát jelenleg 7 MB. Ha nagyobb mellékletet kísérel meg elküldeni, hiba lép fel.

Az App Center futásidejű összeomlásainak engedélyezése vagy letiltása

Futásidőben engedélyezheti és letilthatja az App Center összeomlás funkcióját. Ha letiltja, az SDK nem végez összeomlási jelentést az alkalmazáshoz.

Crashes.setEnabled(false);

Crashes.setEnabled(false)

Az App Center összeomlásainak újbóli engedélyezéséhez használja ugyanazt az API-t, de adjon át true paraméterként.

Crashes.setEnabled(true);

Crashes.setEnabled(true)

Az állapot megmarad az eszköz tárolójában az alkalmazásindítások során.

Ez az API aszinkron, erről az App Center Aszinkron API-k útmutatójában olvashat bővebben.

Megjegyzés:

Ezt a módszert csak akkor szabad használni, ha a Crashes már elindult.

Ellenőrizze, hogy engedélyezve van-e az App Center Crashes funkciója

Azt is ellenőrizheti, hogy engedélyezve van-e az App Center Crashes:

Crashes.isEnabled();

Crashes.isEnabled()

Ez az API aszinkron, erről az App Center Aszinkron API-k útmutatójában olvashat bővebben.

Megjegyzés:

Ezt a metódust csak akkor szabad használni, ha a Crashes már elindult. Mindig visszaad false a kezdés előtt.

Kezelt hibák

Az App Center lehetővé teszi a hibák nyomon követését is a kezelt kivételek használatával. Ehhez használja a trackError következő módszert:

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

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

Az alkalmazások opcionálisan tulajdonságokat csatolhatnak egy kezelt hibajelentéshez, hogy további kontextust biztosítsanak. Adja át a tulajdonságokat kulcs/érték párok leképezéseként (csak sztringek) az alábbi példában látható módon.

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)
}

Bináris és szöveges mellékleteket is hozzáadhat a kezelt hibajelentésekhez. Adja át a mellékleteket Iterable-ként, ahogyan az alábbi példában látható.

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))
}

NDK-összeomlások bejelentése

Összeomlások jelentése

Ha megfelelő összeomlási jelentéseket szeretne kapni az App Centerben, először győződjön meg arról, hogy beállította az App Center Crashes SDK-t a fenti utasítások követésével.

A Breakpad könyvtár létrehozása

Ezután adja hozzá és fordítsa le a Google Breakpadet a hivatalos Google Breakpad Android README-ben felsorolt utasítások követésével.

Megjegyzés:

Az App Center SDK alapértelmezés szerint nem kötegeli a Google Breakpadet.

A kivételkezelő csatolása

Miután beépítetted a Google Breakpadet, csatold az NDK Crash Handler-t a következő után 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);
        }
    }
});

A metódus setupNativeCrashesListener egy natív metódus, amelyet a C/C++-ban kell implementálnia:

#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);
}

A dumpCallback hibaelhárítás helye:

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

Miután megfelelően beállította ezeket a módszereket, az alkalmazás automatikusan elküldi a minidumpot az App Centerbe újraindításkor. A hibaelhárításhoz részletes naplókkal (AppCenter.setLogLevel(Log.VERBOSE) előtte AppCenter.start) ellenőrizheti, hogy a minidumpok az alkalmazás újraindítása után lesznek-e elküldve.

Megjegyzés:

Az App Center a minidump mellékletek fenntartott nevét minidump.dmp használja. Győződjön meg arról, hogy a mellékletnek más nevet ad, hacsak nem minidump fájlról van szó, hogy megfelelően tudjuk kezelni.

Megjegyzés:

Van egy ismert hiba a Breakpadben, amely lehetetlenné teszi az összeomlások rögzítését x86 emulátorokon.

Szimbolika

Az összeomlások feldolgozásával kapcsolatos további információkért tekintse meg a diagnosztikai dokumentációt .