Chybové ukončení app center (tvOS)
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.
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 pro beta i živé aplikace, tj. ty, které byly odeslány do App Store. 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.
Protokoly chybových ukončení v tvOS také vyžadují symboliku. Přečtěte si dokumentaci ke službě App Center Diagnostics , která vysvětluje, jak poskytnout symboly pro vaši aplikaci.
Poznámka
Pokud chcete přijímat správně symbolická trasování zásobníku, ujistěte se, že je zakázaný bitcode. Další informace o bitcode najdete v dokumentaci k symbolizaci pro iOS v App Center.
Poznámka
4.0.0 Ve verzi App Center byly zavedeny zásadní změny. Pokud chcete migrovat App Center z předchozích verzí, postupujte podle části Migrace na sadu App Center SDK 4.0.0 a vyšší .
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 testovacích nebo beta aplikacích a v produkčních aplikacích nic neudělá.
[MSACCrashes 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:
[MSACCrashes hasReceivedMemoryWarningInLastSession];
Crashes.hasReceivedMemoryWarningInLastSession
Poznámka
Tuto metodu je možné použít pouze po Crashes spuštění, vždy se vrátí NO nebo 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:
[MSACCrashes hasCrashedInLastSession];
Crashes.hasCrashedInLastSession
To se hodí pro případ, že chcete upravit chování nebo uživatelské rozhraní aplikace po chybovém ukončení.
Poznámka
Tuto metodu je možné použít pouze po MSACCrashes spuštění, vždy se vrátí NO nebo 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í.
MSACErrorReport *crashReport = [MSACCrashes lastSessionCrashReport];
var crashReport = Crashes.lastSessionCrashReport
Poznámka
Tuto metodu je možné použít pouze po Crashes spuštění, vždy se vrátí nil před spuštěním.
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í crashesDelegate.
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.
Chcete-li přidat vlastní chování, musíte přijmout CrashesDelegate-protocol, všechny jeho metody jsou volitelné.
Zaregistrovat se jako delegát
[MSACCrashes setDelegate:self];
Crashes.delegate = self
Poznámka
Před voláním AppCenter.startmusíte nastavit delegáta, protože App Center začne zpracovávat chybové ukončení hned po spuštění.
Mělo by se chybové ukončení zpracovat?
Implementujte metodu crashes:shouldProcessErrorReport:-ve třídě, která přijímá CrashesDelegateprotokol -, pokud chcete rozhodnout, jestli je potřeba zpracovat konkrétní chybu nebo ne. 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.
- (BOOL)crashes:(MSACCrashes *)crashes shouldProcessErrorReport:(MSACErrorReport *)errorReport {
return YES; // return YES if the crash report should be processed, otherwise NO.
}
func crashes(_ crashes: Crashes, shouldProcess errorReport: ErrorReport) -> Bool {
return true; // return true if the crash report should be processed, otherwise false.
}
Zpracovávané chyby
App Center také umožňuje sledovat chyby pomocí zpracovaných výjimek prostřednictvím trackError metody. Aplikace může volitelně připojit vlastnosti nebo přílohy ke zpracovávané zprávě o chybách, aby poskytla další kontext.
@try {
// Throw error.
} @catch (NSError *error) {
// Init attachments.
NSArray<MSACErrorAttachmentLog *> attachments = @[ MSACErrorAttachmentLog attachmentWithText:@"Hello world!" filename:@"hello.txt"] ]
// Init properties.
NSDictionary *properties = @{ "Category" : "Music", "Wifi" : "On" };
// Track errors.
[MSACCrashes trackError:error withProperties:properties attachments:attachments];
[MSACCrashes trackError:error withProperties:properties attachments:nil];
[MSACCrashes trackError:error withProperties:nil attachments:attachments];
[MSACCrashes trackError:error withProperties:nil attachments:nil];
}
do {
// Throw error.
} catch {
// Init attachments.
let attachments = [ErrorAttachmentLog.attachment(withText: "Hello world!", filename: "hello.txt")]
// Init properties.
let properties:Dictionary<String, String> = ["Category" : "Music", "Wifi" : "On"]
// Track errors.
Crashes.trackError(error, properties: properties, attachments: attachments)
Crashes.trackError(error, properties: properties, attachments: nil)
Crashes.trackError(error, properties: nil, attachments: attachments)
Crashes.trackError(error, properties: nil, attachments: nil)
}
Pro sledování výjimek můžete použít trackException metodu:
@try {
// Throw exceptions.
} @catch (NSException *exception) {
// Init exceptions.
MSACExceptionModel *customException1 = [MSACExceptionModel initWithType:@"Custom exception" exceptionMessage:"Track custom exception.", stackTrace:exception.callStackSymbols];
MSACExceptionModel *customException2 = [MSACExceptionModel initWithException:exception];
// Track exceptions.
[MSACCrashes trackException:customException1 withProperties:properties attachments:nil];
[MSACCrashes trackException:customException2 withProperties:properties attachments:nil];
}
do {
// Throw exception.
} catch {
// Init exception.
let exception = ExceptionModel(withType: "Custom exception", exceptionMessage: "Track custom exception.", stackTrace: Thread.callStackSymbols)
// Track exception.
Crashes.trackException(exception, properties: properties, attachments: nil)
}
Požádat 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á, možná budete chtít před odesláním zprávy o chybovém ukončení do App Center získat potvrzení uživatelů. 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 čekali na potvrzení uživatelů.
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 Neodesílat. Na základě vstupu řeknete aplikaci App Center chybové ukončení, co má dělat, a chyba se pak bude odpovídajícím způsobem zpracovávat.
Poznámka
V sadě SDK se nezobrazuje dialogové okno, aplikace musí poskytnout vlastní uživatelské rozhraní, aby mohla požádat o souhlas uživatele.
Poznámka
Aplikace by neměla volat notifyWithUserConfirmation explicitně, pokud neimplementuje dialogové okno pro potvrzení uživatele. Modul Chybové ukončení bude zpracovávat posílání protokolů implicitně za vás.
Následující metoda ukazuje, jak nastavit obslužnou rutinu potvrzení uživatele:
[MSACCrashes setUserConfirmationHandler:(^(NSArray<MSACErrorReport *> *errorReports) {
// Your code to present your UI to the user, e.g. an UIAlertController.
UIAlertController *alertController = [UIAlertController
alertControllerWithTitle:@"Sorry about that!"
message:@"Do you want to send an anonymous crash report so we can fix the issue?"
preferredStyle:UIAlertControllerStyleAlert];
[alertController
addAction:[UIAlertAction actionWithTitle:@"Don't send"
style:UIAlertActionStyleCancel
handler:^(UIAlertAction *action) {
[MSACCrashes notifyWithUserConfirmation:MSACUserConfirmationDontSend];
}]];
[alertController
addAction:[UIAlertAction actionWithTitle:@"Send"
style:UIAlertActionStyleDefault
handler:^(UIAlertAction *action) {
[MSACCrashes notifyWithUserConfirmation:MSACUserConfirmationSend];
}]];
[alertController
addAction:[UIAlertAction actionWithTitle:@"Always send"
style:UIAlertActionStyleDefault
handler:^(UIAlertAction *action) {
[MSACCrashes notifyWithUserConfirmation:MSACUserConfirmationAlways];
}]];
// Show the alert controller.
[self.window.rootViewController presentViewController:alertController animated:YES completion:nil];
return YES; // Return YES if the SDK should await user confirmation, otherwise NO.
})];
MSACCrashes.setUserConfirmationHandler({ (errorReports: [MSACErrorReport]) in
// Your code to present your UI to the user, e.g. an UIAlertController.
let alertController = UIAlertController(title: "Sorry about that!",
message: "Do you want to send an anonymous crash report so we can fix the issue?",
preferredStyle:.alert)
alertController.addAction(UIAlertAction(title: "Don't send", style: .cancel) {_ in
MSACCrashes.notify(with: .dontSend)
})
alertController.addAction(UIAlertAction(title: "Send", style: .default) {_ in
MSACCrashes.notify(with: .send)
})
alertController.addAction(UIAlertAction(title: "Always send", style: .default) {_ in
MSACCrashes.notify(with: .always)
})
// Show the alert controller.
self.window?.rootViewController?.present(alertController, animated: true)
return true // Return true if the SDK should await user confirmation, otherwise return false.
})
V případě, že se vrátíte YES/true v bloku obslužné rutiny výše, měla by vaše aplikace získat oprávnění uživatele a odeslat sadě SDK zprávu s výsledkem pomocí následujícího rozhraní API. Pokud k tomu používáte upozornění, jako to děláme v ukázce výše, volali byste ho z vaší implementace zpětného alertView:clickedButtonAtIndex:volání .
// Depending on the users's choice, call notifyWithUserConfirmation: with the right value.
[MSACCrashes notifyWithUserConfirmation:MSACUserConfirmationDontSend];
[MSACCrashes notifyWithUserConfirmation:MSACUserConfirmationSend];
[MSACCrashes notifyWithUserConfirmation:MSACUserConfirmationAlways];
// Depending on the user's choice, call notify(with:) with the right value.
MSACCrashes.notify(with: .dontSend)
MSACCrashes.notify(with: .send)
MSACCrashes.notify(with: .always)
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í. Parametr CrashesDelegate-protocol definuje tři různá zpětná volání, která můžete v 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í.
- (void)crashes:(MSACCrashes *)crashes willSendErrorReport:(MSACErrorReport *)errorReport {
// Your code, e.g. to present a custom UI.
}
func crashes(_ crashes: Crashes, willSend errorReport: 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, willSendErrorReport 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í.
- (void)crashes:(MSACCrashes *)crashes didSucceedSendingErrorReport:(MSACErrorReport *)errorReport {
// Your code, e.g. to hide the custom UI.
}
func crashes(_ crashes: Crashes, didSucceedSending errorReport: ErrorReport) {
// Your code goes here.
}
Pokud se sadě SDK nepodařilo odeslat protokol chybových ukončení, vyvolá se následující zpětné volání.
- (void)crashes:(MSACCrashes *)crashes didFailSendingErrorReport:(MSACErrorReport *)errorReport withError:(NSError *)error {
// Your code goes here.
}
func crashes(_ crashes: Crashes, didFailSending errorReport: ErrorReport, withError error: Error) {
// Your code goes here.
}
Příjem didFailSendingErrorReport 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. Tady je příklad připojení textu a obrázku k chybovému ukončení:
- (NSArray<MSACErrorAttachmentLog *> *)attachmentsWithCrashes:(MSACCrashes *)crashes
forErrorReport:(MSACErrorReport *)errorReport {
MSACErrorAttachmentLog *attachment1 = [MSACErrorAttachmentLog attachmentWithText:@"Hello world!" filename:@"hello.txt"];
MSACErrorAttachmentLog *attachment2 = [MSACErrorAttachmentLog attachmentWithBinary:[@"Fake image" dataUsingEncoding:NSUTF8StringEncoding] filename:@"fake_image.jpeg" contentType:@"image/jpeg"];
return @[ attachment1, attachment2 ];
}
func attachments(with crashes: Crashes, for errorReport: ErrorReport) -> [ErrorAttachmentLog]? {
let attachment1 = ErrorAttachmentLog.attachment(withText: "Hello world!", filename: "hello.txt")
let attachment2 = ErrorAttachmentLog.attachment(withBinary: "Fake image".data(using: String.Encoding.utf8), filename: nil, contentType: "image/jpeg")
return [attachment1!, attachment2!]
}
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í.
[MSACCrashes setEnabled:NO];
Crashes.enabled = false
Pokud chcete znovu povolit chybové ukončení App Centeru, použijte stejné rozhraní API, ale předejte YES/true ho jako parametr.
[MSACCrashes setEnabled:YES];
Crashes.enabled = true
Stav se v úložišti zařízení během spouštění aplikací udržuje.
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 jsou povolená chybová ukončení app center:
BOOL enabled = [MSACCrashes isEnabled];
var enabled = Crashes.enabled
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.