Pády aplikace App Center (iOS)

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.

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í pádů aplikací funguje pro beta i živé aplikace, tedy ty odeslané do App Store. 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 .

Protokoly havárií na iOS vyžadují symbolikaci, podívejte se na dokumentaci App Center Diagnostics, která vysvětluje, jak poskytnout symboly pro vaši aplikaci.

Poznámka:

Pokud jste připojeni k ladicímu programu, sada SDK nepředá žádné protokoly havárie. Ujistěte se, že ladicí program není připojený, když aplikace spadne.

Poznámka:

Pokud chcete přijímat správně symbolikované trasování zásobníku, ujistěte se, že je bitcode zakázaný. Další informace o bitovém kódu najdete v dokumentaci k symbolizaci 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 do sady App Center SDK 4.0.0 a vyšší .

Hlášení chyb v rozšířeních

App Center podporuje reportování pádů v rozšířeních pro iOS. Použití je stejné jako v aplikaci kontejneru.

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 se dá použít jenom v testovacích a beta aplikacích a nebude v produkčních aplikacích nic dělat.

[MSACCrashes 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ěť:

[MSACCrashes hasReceivedMemoryWarningInLastSession];

Crashes.hasReceivedMemoryWarningInLastSession

Poznámka:

Tato metoda se smí použít pouze poté, co bylo Crashes spuštěno, vždy 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 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.

[MSACCrashes hasCrashedInLastSession];

Crashes.hasCrashedInLastSession

To se hodí v případě, že chcete upravit chování nebo uživatelské rozhraní aplikace po havárii.

Poznámka:

Tato metoda se smí použít pouze poté, co bylo MSACCrashes spuštěno, vždy vrátí NO nebo false před spuštění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í.

MSACErrorReport *crashReport = [MSACCrashes lastSessionCrashReport];

var crashReport = Crashes.lastSessionCrashReport

Poznámka:

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

Pro toto rozhraní API existuje mnoho případů použití, z nichž nejběžnější je, že lidé volají toto rozhraní API a implementují vlastní CrashesDelegate.

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 přidat vlastní chování, musíte přijmout CrashesDelegate-protocol, všechny jeho metody jsou volitelné.

Registrace jako delegát

[MSACCrashes setDelegate:self];

Crashes.delegate = self

Poznámka:

Před volánímAppCenter.startje nutné nastavit delegáta, protože App Center spustí chybové ukončení okamžitě po spuštění.

Měla by se havárie zpracovat?

Implementujte metodu crashes:shouldProcessErrorReport: ve třídě, která implementuje protokol CrashesDelegate, pokud chcete rozhodnout, zda konkrétní havárii zpracovat či nikoliv. 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.

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

Vyřešené chyby

App Center také umožňuje sledovat chyby pomocí zpracovaných výjimek prostřednictvím metody trackError. Aplikace může volitelně připojit vlastnosti nebo přílohy k zpracovávané zprávě o chybách a poskytnout tak 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)
}

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 odesílat, Odesílat 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.

Poznámka:

Aplikace by neměla volat notifyWithUserConfirmation explicitně, pokud neimplementuje dialogové okno potvrzení uživatele. Modul Crashes bude zpracovávat odesílání protokolů za vás implicitně.

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.
})];

Crashes.setUserConfirmationHandler({ (errorReports: [ErrorReport]) 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
    Crashes.notify(with: .dontSend)
  })

  alertController.addAction(UIAlertAction(title: "Send", style: .default) {_ in
    Crashes.notify(with: .send)
  })

  alertController.addAction(UIAlertAction(title: "Always send", style: .default) {_ in
    Crashes.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.
})

Pokud se vrátíte YES/true do výše uvedeného bloku obslužné rutiny, měla by vaše aplikace získat oprávnění uživatele a odeslat zprávu sadě SDK s výsledkem pomocí následujícího rozhraní API. Pokud používáte výstrahu pro tento účel, jak jsme to udělali v ukázce výše, volali byste ji z implementace zpětného volání alertView:clickedButtonAtIndex:.

// 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.
Crashes.notify(with: .dontSend)
Crashes.notify(with: .send)
Crashes.notify(with: .always)

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í. Protokol CrashesDelegatedefinuje tři různé zpětné volání, které můžete použít ve své aplikaci, abyste dostávali oznámení 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í.

- (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ě problémů se sítí nebo výpadkem koncového bodu se po restartování procesu znovu aktivuje aplikace willSendErrorReport .

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

- (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 SDK nepodařilo odeslat protokol o selhání, 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ě, 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. Tady je příklad, jak připojit text a obrázek k pádu aplikace:

- (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í 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.

[MSACCrashes setEnabled:NO];

Crashes.enabled = false

Pokud chcete znovu povolit chybové hlášení v App Center, použijte stejné rozhraní API, ale jako parametr předejte YES/true.

[MSACCrashes setEnabled:YES];

Crashes.enabled = true

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

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:

BOOL enabled = [MSACCrashes isEnabled];

var enabled = Crashes.enabled

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.

Zakázání zpracování výjimek Mach

Ve výchozím nastavení používá App Center Crashes obslužnou rutinu výjimky Mach k zachytávání závažných signálů, například přetečení zásobníku, prostřednictvím serveru výjimek Mach.

Metoda disableMachExceptionHandler-poskytuje možnost zakázat zachytávání závažných signálů prostřednictvím serveru výjimek Mach. Pokud chcete zakázat obslužnou rutinu výjimky Mach, měli byste volat tuto metodu PŘED spuštěním sady SDK. Váš typický instalační kód by vypadal takto:

[MSACCrashes disableMachExceptionHandler];
[MSACAppCenter start:@"{Your App Secret}" withServices:@[[MSACAnalytics class], [MSACCrashes class]]];

Crashes.disableMachExceptionHandler()
AppCenter.start(withAppSecret: "{Your App Secret}", services: [Analytics.self, Crashes.self])

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-05-05

Sdílet prostřednictvím

Pády aplikace App Center (iOS)

Hlášení chyb v rozšířeních

Vyvolat testovací pád

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

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

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

Podrobnosti o posledním pádu

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

Registrace jako delegát

Měla by se havárie zpracovat?

Vyřešené chyby

Požádejte uživatele o souhlas s odesláním protokolu selhání.

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

Před odesláním chybového záznamu SDK se vyvolá následující zpětné volání.

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

Pokud se SDK nepodařilo odeslat protokol o selhání, vyvolá se následující zpětné volání.

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

Povolení nebo zakázání pádů App Center při běhu

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

Zakázání zpracování výjimek Mach

Váš názor

Další materiály