Az App Center összeomlik (Unity)

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.

Az App Center Crashes automatikusan létrehoz egy összeomlási naplót minden alkalommal, amikor az alkalmazás összeomlik, és a naplót az eszköz tárhelyére menti. Amikor egy felhasználó újra elindítja az alkalmazást, az SDK 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 esetében is működik, vagyis a Google Play-be küldött összeomlások esetében. Az összeomlási naplók értékes információkat tartalmaznak az összeomlás elhárításához.

Ha még nem állította be az SDK-t az alkalmazásban, kövesse a Unity első lépéseket ismertető szakaszának utasításait.

Az iOS összeomlási naplóinak szimbolikus megjelenítésére van szükség. A szimbólumok engedélyezéséhez tekintse meg az App Center Diagnostics dokumentációját, amely bemutatja, hogyan adhat szimbólumokat az alkalmazásnak.

Fontos

A Unityhez készült Crashes SDK nem támogatja az UWP-t. Az oldalon található utasítások csak Android és iOS rendszerre vonatkoznak.

Megjegyzés:

Az SDK nem továbbítja az összeomlási naplókat, ha hozzácsatolta a hibakeresőt. Győződjön meg arról, hogy az alkalmazás összeomlásakor a hibakereső nincs csatlakoztatva.

Megjegyzés:

Ha a Enable CrashReport API engedélyezve van a PlayerSettings beállításaiban, az SDK nem gyűjt hibanaplókat.

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 a hibakeresést és a kiadási konfigurációkat ellenőrzi. Így csak hibakereséskor használhatja, mivel a kiadási alkalmazások esetében nem fog működni.

Crashes.GenerateTestCrash();

Megjegyzés:

Ez a módszer csak akkor működik, ha a Fejlesztési összeállítás beállítás be van kapcsolva.

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:

bool hadLowMemoryWarning = Crashes.HasReceivedMemoryWarningInLastSessionAsync().Result;

Megjegyzés:

Ez a metódus nem működik a következőben Awake(): .

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:

bool didAppCrash = await Crashes.HasCrashedInLastSessionAsync();

A hívás HasCrashedInLastSessionAsync 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 további felhasználói felületet mutatnak, hogy bocsánatot kérjenek a felhasználóiktól, vagy egy összeomlás után kapcsolatba szeretnének lépni.

Az utolsó összeomlás részletei

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

ErrorReport crashReport = await Crashes.GetLastSessionCrashReportAsync();

Ennek az API-nak a leggyakoribb használati esete az, amikor egy felhasználó implementálja az egyéni Crashes delegate-et vagy listenert.

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 hajtanak végre az összeomlási naplók App Centerbe való küldése előtt és után.

Megjegyzés:

Állítsa be a visszahívást az App Center indítása előtt, például a Awake metódusban, mivel az App Center közvetlenül az indítás után megkezdi az összeomlások feldolgozását.

Fel kell dolgoznunk az összeomlást?

Állítsa be a következő callback függvényt, 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 nem szeretne elküldeni az App Centerbe.

Crashes.ShouldProcessErrorReport = (ErrorReport report) =>
{
     // Check the report in here and return true or false depending on the ErrorReport.
    return true;
};

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 a kód ezt a visszahívást használja, önnek kell beszereznie a felhasználó megerősítését. Az egyik lehetőség egy párbeszédpanelen keresztül érhető el, amely a következő lehetőségek egyikével érhető el: Mindig küldés, Küldés és Ne küldjön. A bemenet alapján adja meg, mit tegyen az App Center Crashes, és az összeomlást ennek megfelelően kezelik majd.

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.

Crashes.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;
};

Ha a visszahívás visszatér true, felhasználói engedélyt kell beszereznie, és az eredményt közölnie kell az SDK-val az alábbi API használatával:

// Depending on the user's choice, call Crashes.NotifyUserConfirmation() with the right value.
Crashes.NotifyUserConfirmation(UserConfirmation.DontSend);
Crashes.NotifyUserConfirmation(UserConfirmation.Send);
Crashes.NotifyUserConfirmation(UserConfirmation.AlwaysSend);

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 egy olyan felhasználói felület megjelenítése, amely tájékoztatja a felhasználót arról, hogy az alkalmazás összeomlási jelentést küld. Egy másik forgatókönyv az, amikor módosítani szeretné az alkalmazás viselkedését, hogy az összeomlási naplók röviddel az újraindítás után elküldhetők legyenek. Az App Center Összeomlások három különböző visszahívást biztosít, 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

Crashes.SendingErrorReport += (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, SendingErrorReport 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

Crashes.SentErrorReport += (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

Crashes.FailedToSendErrorReport += (errorReport, exception) =>
{
    // Your code goes here.
};

A(z) FailedToSendErrorReport 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).

Mellékletek hozzáadása az összeomlás vagy a kezeletlen kivétel jelentéséhez

Opcionálisan bináris és szöveges mellékleteket is hozzáadhat egy összeomlási vagy kezeletlen kivételről szóló jelentéshez. Az SDK elküldi őket a jelentéssel együtt, hogy megjelenjenek az App Center portálon. A rendszer közvetlenül a tárolt jelentés elküldése előtt meghívja a következő visszahívást. Összeomlás esetén ez a következő alkalmazásindításkor történik. Kezeletlen kivételek esetén be kell jelentkeznie a mellékletek küldésére. Ügyeljen arra, hogy a mellékletfájl neve ne legyen elnevezve minidump.dmp , mivel 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 jelentéshez:

Crashes.GetErrorAttachments = (ErrorReport report) =>
{
    // Your code goes here.
    return new ErrorAttachmentLog[]
    {
        ErrorAttachmentLog.AttachmentWithText("Hello world!", "hello.txt"),
        ErrorAttachmentLog.AttachmentWithBinary(Encoding.UTF8.GetBytes("Fake image"), "fake_image.jpeg", "image/jpeg")
    };
};

Az összeomlások a jelentésekben szereplő IsCrash tulajdonság révén különíthetők el a nem kezelt kivételektől. A tulajdonság igaz lesz összeomlások esetén, és egyébként hamis.

Megjegyzés:

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

Megjegyzés:

GetErrorAttachments meghívódik a fő szálon, és nem osztja fel a munkát a keretek között. A játékhurok blokkolásának elkerülése érdekében ne végezzen hosszú ideig futó feladatokat ebben a függvényhívásban.

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.SetEnabledAsync(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.SetEnabledAsync(true);

Nem kell megvárnia ezt a hívást, hogy más API-hívásokat (például IsEnabledAsync) konzisztenssé tegyen.

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

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

Az is ellenőrizheti, hogy az App Center Crashes szolgáltatás engedélyezve van-e:

bool isEnabled = await Crashes.IsEnabledAsync();

A Unityben kezelt kivételek

Az App Center lehetővé teszi a hibák nyomon követését is a Unityben 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);
}

A hiba további kontextusához tulajdonságokat is csatolhat. Adja át a tulajdonságokat szöveges szótárként. Ez a lépés nem kötelező.

try {
    // your code goes here.
} catch (Exception exception) {
    var properties = new Dictionary<string, string>
    {
        { "Category", "Music" },
        { "Wifi", "On" }
    };
    Crashes.TrackError(exception, properties);
}

Bináris és szöveges mellékleteket is hozzáadhat a kezelt hibajelentésekhez. Adja át a mellékleteket objektumtömbként ErrorAttachmentLog az alábbi példában látható módon.

try {
    // your code goes here.
} catch (Exception exception) {
    var attachments = new ErrorAttachmentLog[]
    {
        ErrorAttachmentLog.AttachmentWithText("Hello world!", "hello.txt"),
        ErrorAttachmentLog.AttachmentWithBinary(Encoding.UTF8.GetBytes("Fake image"), "fake_image.jpeg", "image/jpeg")
    };
    Crashes.TrackError(exception, attachments: attachments);
}

Kezeletlen kivételek a Unityben

Nem kezelt kivételek bejelentése

Alapértelmezés szerint az App Center SDK nem jelenti az alkalmazásban keletkező olyan kezeletlen kivételeket, amelyek nem okoznak súlyos összeomlást. A funkció engedélyezéséhez hívja meg a következő metódust:

Crashes.ReportUnhandledExceptions(true);

Az API meghívása után az App Center az App Center portálon problémákként naplózza az összes kezeletlen kivételt, hasonlóan a korábban említett kezelt kivételekhez. A funkció letiltásához hívja meg ugyanazt az API-t, false mint a paraméter.

Crashes.ReportUnhandledExceptions(false);

Megjegyzés:

Az App Center SDK által észlelt nem kezelt kivételek hibákként jelennek meg az App Center felhasználói felületén. Ennek az az oka, hogy a Unity alapértelmezés szerint elfogja a kezeletlen kivételeket, ami azt jelenti, hogy az alkalmazás nem lép ki, és nem minősül összeomlásnak.

Mellékletek hozzáadása kezeletlen kivételjelentéshez

Alapértelmezés szerint az App Center SDK nem engedélyezi a nem kezelt kivételek mellékleteit. A funkció engedélyezéséhez állítsa a metódus logikai paraméterét a következő értékre:

Crashes.ReportUnhandledExceptions(true, true);

Ezután a GetErrorAttachments visszahívás implementálásával tetszés szerint mellékleteket adhat hozzá egy nem kezelt kivételjelentéshez.

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 fel kell vennie és össze kell állítania a Google Breakpadet az Android README hivatalos Google Breakpadjében felsorolt utasítások követésével. Ha a Unityben szeretné használni, vegye fel a bináris fájlt az alkalmazásba.

Megjegyzés:

Az App Center SDK alapértelmezés szerint nem tartalmazza a Google Breakpadet.

A kivételkezelő csatolása

Ha már integrálta a Google Breakpadet, csatolja az NDK hibakezelőt:

/* Attach NDK Crash Handler. */
var minidumpDir = Crashes.GetMinidumpDirectoryAsync();
setupNativeCrashesListener(minidumpDir.Result);

...

[DllImport("YourLib")]
private static extern void setupNativeCrashesListener(string path);

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

#include <android/log.h>
#include "google-breakpad/src/client/linux/handler/exception_handler.h"
#include "google-breakpad/src/client/linux/handler/minidump_descriptor.h"

static google_breakpad::ExceptionHandler exception_handler(google_breakpad::MinidumpDescriptor(), NULL, dumpCallback, NULL, true, -1);

/**
 * Registers breakpad as the exception handler for NDK code.
 * @param path minidump directory path returned from Crashes.GetMinidumpDirectoryAsync()
 */
extern "C" void setupNativeCrashesListener(const char *path) {
    google_breakpad::MinidumpDescriptor descriptor(path);
    exception_handler.set_minidump_descriptor(descriptor);
}

A dumpCallback hibaelhárításhoz való használata:

/*
 * Triggered automatically after an attempt to write a minidump file to the breakpad folder.
 */
static 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ók segítségével ellenőrizheti, hogy a minidumpok az alkalmazás újraindítása után érkeznek-e.

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.

Figyelmezteté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 .

  • Last updated on