diff --git a/src/pages/home/getting-started/tabs/enable-debug-logging.md b/src/pages/home/getting-started/tabs/enable-debug-logging.md index 7e65f769a3..f38b15a47f 100644 --- a/src/pages/home/getting-started/tabs/enable-debug-logging.md +++ b/src/pages/home/getting-started/tabs/enable-debug-logging.md @@ -108,78 +108,135 @@ To ensure accurate session and crash reporting, this call must be added to every #### Swift -Start Lifecycle data collection by calling `lifecycleStart:` from within the callback of the `ACPCore::start:` method in your app's `application:didFinishLaunchingWithOptions:` delegate method. +1. Register the Lifecycle extension with the SDK Core by adding the following to your app's `application:didFinishLaunchingWithOptions:` delegate method. This will register the extension with Core and begin Lifecycle event processing: + +```swift +func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool { + MobileCore.registerExtensions([Lifecycle.self, ...], { + ... + } +} +``` + +2. Start Lifecycle data collection by calling `lifecycleStart:` from within the callback of the `MobileCore.registerExtensions` method in your app's `application:didFinishLaunchingWithOptions:` delegate method. If your iOS application supports background capabilities, your `application:didFinishLaunchingWithOptions:` method might be called when iOS launches your app in the background. If you do not want background launches to count towards your lifecycle metrics, then `lifecycleStart:` should only be called when the application state is not equal to `UIApplicationStateBackground`. ```swift func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool { - // register the lifecycle extension - ACPLifecycle.registerExtension(); - - let appState = application.applicationState; - ACPCore.start { - // only start lifecycle if the application is not in the background + let appState = application.applicationState + MobileCore.registerExtensions([Lifecycle.self, ...], { if appState != .background { - ACPCore.lifecycleStart(nil) - } - } + // only start lifecycle if the application is not in the background + MobileCore.lifecycleStart(additionalContextData: nil) + } + } } ``` -When launched, if your app is resuming from a backgrounded state, iOS might call your `applicationWillEnterForeground:` delegate method. You also need to call `lifecycleStart:`, but this time you do not need all of the supporting code that you used in `application:didFinishLaunchingWithOptions:`: +3. When launched, if your app is resuming from a backgrounded state, iOS might call your `applicationWillEnterForeground:` delegate method. You also need to call `lifecycleStart:`, but this time you do not need all of the supporting code that you used in `application:didFinishLaunchingWithOptions:`: ```swift -func applicationWillEnterForeground(_ application: UIApplication) { - ACPCore.lifecycleStart(nil) +func applicationWillEnterForeground(_ application: UIApplication) { + MobileCore.lifecycleStart(additionalContextData: nil) } ``` -When the app enters the background, pause Lifecycle data collection from your app's `applicationDidEnterBackground:` delegate method: +In iOS 13 and later, for a scene-based application, use the `UISceneDelegate`'s `sceneWillEnterForeground` method as follows: ```swift -func applicationDidEnterBackground(_ application: UIApplication) { - ACPCore.lifecyclePause() +func sceneWillEnterForeground(_ scene: UIScene) { + MobileCore.lifecycleStart(additionalContextData: nil) } ``` -#### Objective-C +For more information on handling foregrounding applications with Scenes, refer to Apple's documentation [here](https://developer.apple.com/documentation/uikit/app_and_environment/scenes/preparing_your_ui_to_run_in_the_foreground) -Start Lifecycle data collection by calling `lifecycleStart:` from within the callback of the `ACPCore::start:` method in your app's `application:didFinishLaunchingWithOptions:` delegate method. +4. When the app enters the background, pause Lifecycle data collection from your app's `applicationDidEnterBackground:` delegate method: -If your iOS application supports background capabilities, you `application:didFinishLaunchingWithOptions:` method may be called when iOS launches your app in the background. If you do not want background launches to count towards your lifecycle metrics, then `lifecycleStart:` should only be called when the application state is not equal to `UIApplicationStateBackground`. +```swift +func applicationDidEnterBackground(_ application: UIApplication) { + MobileCore.lifecyclePause() +} +``` + +In iOS 13 and later, for a scene-based application, use the `UISceneDelegate`'s `sceneDidEnterBackground` method as follows: + +```swift +func sceneDidEnterBackground(_ scene: UIScene) { + MobileCore.lifecyclePause() +} +``` + +For more information on handling backgrounding applications with Scenes, refer to Apple's documentation [here](https://developer.apple.com/documentation/uikit/app_and_environment/scenes/preparing_your_ui_to_run_in_the_background) + +#### Objective-C + +1. Register the Lifecycle extension with the SDK Core by adding the following to your app's `application:didFinishLaunchingWithOptions:` delegate method. This will register the extension with Core and begin Lifecycle event processing: ```objectivec -- (BOOL) application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions { +- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions { // register the lifecycle extension - [ACPLifecycle registerExtension]; +[AEPMobileCore registerExtensions:@[AEPMobileLifecycle.class, ...] completion:^{ + ... +}]; +return YES; +} +``` + +2. Start Lifecycle data collection by calling `lifecycleStart:` from within the callback of the `AEPMobileCore::registerExtensions:` method in your app's `application:didFinishLaunchingWithOptions:` delegate method. +If your iOS application supports background capabilities, your `application:didFinishLaunchingWithOptions:` method might be called when iOS launches your app in the background. If you do not want background launches to count towards your lifecycle metrics, then `lifecycleStart:` should only be called when the application state is not equal to `UIApplicationStateBackground`. + +```objectivec +- (BOOL) application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions { + // register the lifecycle extension, and begin event processing with Core const UIApplicationState appState = application.applicationState; - [ACPCore start:^{ - // only start lifecycle if the application is not in the background - if (appState != UIApplicationStateBackground) { - [ACPCore lifecycleStart:nil]; - } + [AEPMobileCore registerExtensions:@[AEPMobileLifecycle.class, ...] completion:^{ + // only start lifecycle if the application is not in the background + if (appState != UIApplicationStateBackground) { + [AEPMobileCore lifecycleStart:nil]; + } }]; } ``` -When launched, if your app is resuming from a backgrounded state, iOS may call your `applicationWillEnterForeground:` delegate method. You also need to call `lifecycleStart:`, but this time you do not need all of the supporting code that you used in `application:didFinishLaunchingWithOptions:`: +3. When launched, if your app is resuming from a backgrounded state, iOS might call your `applicationWillEnterForeground:` delegate method. You also need to call `lifecycleStart:`, but this time you do not need all of the supporting code that you used in `application:didFinishLaunchingWithOptions:`: ```objectivec - (void) applicationWillEnterForeground:(UIApplication *)application { - [ACPCore lifecycleStart:nil]; + [AEPMobileCore lifecycleStart:nil]; } ``` -When the app enters the background, pause Lifecycle data collection from your app's `applicationDidEnterBackground:` delegate method: +In iOS 13 and later, for a scene-based application, use the `UISceneDelegate`'s `sceneWillEnterForeground` method as follows: ```objectivec - - (void) applicationDidEnterBackground:(UIApplication *)application { - [ACPCore lifecyclePause]; - } +- (void) sceneWillEnterForeground:(UIScene *)scene { + [AEPMobileCore lifecycleStart:nil]; +} ``` +For more information on handling foregrounding applications with Scenes, refer to Apple's documentation [here](https://developer.apple.com/documentation/uikit/app_and_environment/scenes/preparing_your_ui_to_run_in_the_foreground) + +4. When the app enters the background, pause Lifecycle data collection from your app's `applicationDidEnterBackground:` delegate method: + +```objectivec +- (void) applicationDidEnterBackground:(UIApplication *)application { + [AEPMobileCore lifecyclePause]; +} +``` + +In iOS 13 and later, for a scene-based application, use the `UISceneDelegate`'s `sceneDidEnterBackground` method as follows: + +```objectivec +- (void) sceneDidEnterBackground:(UIScene *)scene { + [AEPMobileCore lifecyclePause]; +} +``` + +For more information on handling backgrounding applications with Scenes, refer to Apple's documentation [here](https://developer.apple.com/documentation/uikit/app_and_environment/scenes/preparing_your_ui_to_run_in_the_background) + \ No newline at end of file +``` -->