Troubleshoot Issues on iOS Apps

1<key>NSLocationAlwaysUsageDescription</key>
2<string>Placeholder Purpose String</string>

1// Turn on logging by selecting the logLevel (debug, warn or error). Debugging is not recommended for production apps.
2SFMCSdk.setLogger(logLevel: .debug)

1// turn on logging for debugging.  Not recommended for production apps.
2// Set to true to enable logging while debugging
3MarketingCloudSDK.sharedInstance().sfmc_setDebugLoggingEnabled(true)

1class CustomLogOutputter: LogOutputter {
2    override func out(level: LogLevel, subsystem: String, category: LoggerCategory, message: String) {
3        // custom log outputting code
4    }
5}
6
7// Then set the log level and custom log outputter
8SFMCSdk.setLogger(logLevel: .debug, logOutputter: CustomLogOutputter())

1SFMCSdk.setLogger(logLevel: .debug, logOutputter: LogOutputter(), filters: [.module, .identity])

1SFMCSdk.clearLoggerFilters()

1let enabled = MarketingCloudSDK.sharedInstance().sfmc_getDebugLoggingEnabled()

1print("SDK State = \(SFMCSdk.state())")

1// display a JSON formatted, easily readable block of text describing the current status of the SDK.
2print("SDK State = \(MarketingCloudSDK.sharedInstance().sfmc_getSDKState() ?? "SDK State is nil")")

1SDK State = {
2    "Analytics Details" =     {
3        ETAnalyticsEnabled = 1;
4        PIAnalyticsEnabled = 1;
5        PiIdentifier = "Not Set";
6        useLegacyPiIdentifier = 1;
7    };
8    "Inbox Details" =     {
9        "Count of All Inbox Messages in DB" = 0;
10        "Count of Read Inbox Messages in DB" = 0;
11        "Count of Unread Inbox Messages in DB" = 0;
12        "Current Inbox Messages" = None;
13    };
14    "Location General Information" =     {
15        "Beacon Monitoring Details" =         {
16            "Count of Proximity Messages in DB" = 0;
17            "Proximity messages in local DB" = None;
18            "Ranging for Beacons with UUID" = "(null)";
19        };
20        "Geo-fence Monitoring Details" =         {
21            "Count of Geo-fence Messages in DB" = 0;
22            "Currently Monitoring Regions" =             {
23            };
24            "Geo-fence Entry messages in DB" = None;
25            "Geo-fence Exit messages in DB" = None;
26            "Regions in DB" = None;
27        };
28        "Location Details" =         {
29            "Last Known Location" =             {
30                latitude = "0.0";
31                longitude = "0.0";
32            };
33            "Location Entitlement in place" = true;
34            "User Location Authorization Status" = 0;
35            "Watching Location" = 0;
36        };
37    };
38    "MarketingCloudSDK General Information" =     {
39        "Application Name" = "SDKExplorer_Dev";
40        "Application Version" = "Version 216.0.0 (Build 2976)";
41        "Device Details" =         {
42            "Daylight Savings Time Active" = 0;
43            "Device Locale" = "en_US";
44            "Device Reported Timezone" = "-18000";
45            DeviceId = "00000000-0000-0000-0000-000000000000";
46            "Hardware Description" = "iPhone9,4";
47            "OS Version" = "12.1.2";
48            "Platform Name" = iOS;
49        };
50        "MarketingCloudSDK Configuration Details" =         {
51            "Current Configuration" =             {
52                accesstoken = 000000000000000000000000;
53                appid = "00000000-0000-0000-0000-000000000000";
54                etanalytics = 1;
55                inbox = 1;
56                location = 1;
57                name = "DEV";
58                pianalytics = 1;
59                uselegacypiidentifier = 1;
60            };
61        };
62        "MarketingCloudSDK Version" = "6.1.1.0";
63        MarketingCloudSDKLocationDelegate = "Not set";
64        MarketingCloudSDKURLHandlingDelegate = "<SDKExplorer_Dev.AppDelegate: 0x283a72fa0>";
65        "Push Information" =         {
66            "Developer has Push Enabled" = Yes;
67            "Device Token" = 0000000000000000000000000000000000000000000000000000000000000000;
68            "User has Push Enabled" = Yes;
69        };
70        "Registration Details" =         {
71            "Current Registration" =             {
72                "app_version" = "216.0.0";
73                "device_token" = 0000000000000000000000000000000000000000000000000000000000000000;
74                deviceid = "00000000-0000-0000-0000-000000000000";
75                dst = 0;
76                etappid = "00000000-0000-0000-0000-000000000000";
77                hwid = "iPhone9,4";
78                locale = "en_US";
79                "location_enabled" = 0;
80                platform = iOS;
81                "platform_version" = "12.1.2";
82                "proximity_enabled" = 0;
83                "push_enabled" = true;
84                "sdk_version" = "6.1.1.0";
85                tags =                 (
86                    ALL,
87                    DEBUG,
88                    iPhone
89                );
90                timezone = "-18000";
91            };
92            "Date of Last Successful Registration" = None;
93            "Last Successfully Sent Registration" = None;
94        };
95    };
96    "Notifications Details" =     {
97        "Last Notification Received" = None;
98    };
99    "Privacy Settings" =     {
100        "Privacy Mode" = SFMCPrivacyModeNotBlocked;
101    };
102    "Retry Alarms Active" =     (
103        MarketingCloudSDKControlChannel,
104        SFMCRegistration
105    );
106}

1func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
2    if let options = launchOptions, let notification = options[UIApplication.LaunchOptionsKey.remoteNotification] as? [AnyHashable: Any] {
3        self.notificationUserInfo = notification
4    }
5
6    FirebaseApp.configure()
7    Messaging.messaging().delegate = self
8    self.configureSdk()
9
10    if #available(iOS 10.0, *) {
11        UNUserNotificationCenter.current().delegate = self
12
13        let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
14        UNUserNotificationCenter.current().requestAuthorization(
15            options: authOptions,
16            completionHandler: { _, _ in }
17        )
18    } else {
19        let settings: UIUserNotificationSettings =
20        UIUserNotificationSettings(types: [.alert, .badge, .sound], categories: nil)
21        application.registerUserNotificationSettings(settings)
22    }
23    application.registerForRemoteNotifications()
24
25    return true
26}
27
28@discardableResult
29func configureSdk() -> Bool {
30    let appID = "<your appID here>"
31    let accessToken = "<your accessToken here>"
32    let appEndpointURL = "<your appEndpoint here>"
33    let mid = "<your account MID here>"
34
35#if DEBUG
36    SFMCSdk.setLogger(logLevel: .debug)
37#endif
38
39    let appEndpoint = URL(string: appEndpointURL)!
40
41    var configBuilder = ConfigBuilder()
42
43    let engagementConfiguration = MarketingCloudSdkConfigBuilder(appId: appID)
44        .setAccessToken(accessToken)
45        .setMarketingCloudServerUrl(URL(string: appEndpointURL)!)
46        .setMid(mid)
47        .setInboxEnabled(true)
48        .setLocationEnabled(true)
49        .setAnalyticsEnabled(true)
50        .build()
51
52    configBuilder = configBuilder
53        .setEngagement(config: engagementConfiguration)
54
55    let pushFeatureConfiguration = PushFeatureConfigBuilder()
56        .setApplicationControlsBadging(true)
57        .build()
58
59    configBuilder = configBuilder
60        .setPushFeature(config: pushFeatureConfiguration)
61
62    // Set the completion handler to take action when all modules initialization is completed.
63    // Seting the completion handler is optional.
64
65    let completionHandler: ((_ status: [ModuleInitStatus]) -> Void) = { [weak self] status in
66        DispatchQueue.main.async {
67            self?.handleSDKInitializationCompletion(status: status)
68        }
69    }
70
71    SFMCSdk.initializeSdk(configBuilder.build(), completion: completionHandler)
72
73    return true
74}
75
76// MARK: - SDK Initialization Completion Handler
77
78private func handleSDKInitializationCompletion(status: [ModuleInitStatus]) {
79    var allSuccessful = true
80
81    for moduleStatus in status {
82        print("Module: \(moduleStatus.moduleName.rawValue), Status: \(moduleStatus.initStatus.rawValue)")
83
84        if moduleStatus.initStatus == .success {
85            // Handle successful initialization for each module
86            switch moduleStatus.moduleName {
87            case .engagement:
88                // Handle successful initialization for Marketing cloud module
89            case .pushFeature:
90                // Handle successful initialization for Push Feature module
91            default:
92                break
93            }
94        } else if moduleStatus.initStatus == .error {
95            allSuccessful = false
96            // module failed to initialize, check logs for more details
97        } else if moduleStatus.initStatus == .cancelled {
98            allSuccessful = false
99            // module initialization was cancelled (for example due to re-confirguration triggered before init was completed)
100        } else if moduleStatus.initStatus == .timeout {
101            allSuccessful = false
102            // module failed to initialize due to timeout, check logs for more details
103        }
104    }
105    if allSuccessful {
106        print("SDK initialization completed successfully")
107    } else {
108        print("SDK initialization completed with errors - check logs above")
109    }
110}

1func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
2    if let options = launchOptions, let notification = options[UIApplication.LaunchOptionsKey.remoteNotification] as? [AnyHashable: Any] {
3        self.notificationUserInfo = notification
4    }
5
6    FirebaseApp.configure()
7    Messaging.messaging().delegate = self
8    self.configureSFMCSdk()
9
10    if #available(iOS 10.0, *) {
11        UNUserNotificationCenter.current().delegate = self
12
13        let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
14        UNUserNotificationCenter.current().requestAuthorization(
15            options: authOptions,
16            completionHandler: { _, _ in }
17        )
18    } else {
19        let settings: UIUserNotificationSettings =
20        UIUserNotificationSettings(types: [.alert, .badge, .sound], categories: nil)
21        application.registerUserNotificationSettings(settings)
22    }
23    application.registerForRemoteNotifications()
24
25    return true
26}
27
28@discardableResult
29func configureSFMCSdk() -> Bool {
30    let appID = "<your appID here>"
31    let accessToken = "<your accessToken here>"
32    let appEndpointURL = "<your appEndpoint here>"
33    let mid = "<your account MID here>"
34
35#if DEBUG
36    SFMCSdk.setLogger(logLevel: .debug)
37#endif
38
39    let appEndpoint = URL(string: appEndpointURL)!
40
41    let mobilePushConfiguration = PushConfigBuilder(appId: appID)
42        .setAccessToken(accessToken)
43        .setMarketingCloudServerUrl(appEndpoint)
44        .setMid(mid)
45        .setInboxEnabled(true) // enable if needed by your application
46        .setLocationEnabled(true) // enable if needed by your application
47        .setAnalyticsEnabled(true) // enable if needed by your application
48        .build()
49
50    let completionHandler: (OperationResult) -> () = { result in
51        if result == .success {
52            self.setupMobilePush()
53        } else if result == .error {
54        } else if result == .cancelled {
55        } else if result == .timeout {
56        }
57    }
58
59    SFMCSdk.initializeSdk(ConfigBuilder().setPush(config: mobilePushConfiguration, onCompletion: completionHandler).build())
60
61    return true

1// MARK: FireBaseMessaging Delegate
2/**
3 Set deviceToken to MarketingCloudSDK in the FCM delegate method when Swizzling is enabled.
4 DeviceToken must be set MANDATORILY to MarketingCloudSDK using`SFMCSdk.mp.setDeviceToken` API for Push notifications to be received through Mobile Push.
5 */
6extension AppDelegate : MessagingDelegate {
7    func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
8        print("FCM Token", fcmToken ?? "")
9
10        PushFeature.requestSdk { pushFeature in
11            print("SDK is operational")
12            if let apnsToken = messaging.apnsToken {
13                print("Setting APNs token in MarketingCloudSDK")
14                pushFeature?.setDeviceToken(apnsToken)
15            } else {
16                print("fcm token is null")
17            }
18            print("SDK is not yet operational")
19        }
20    }
21}

1// MARK: FireBaseMessaging Delegate
2/**
3 Set deviceToken to MarketingCloudSDK in the FCM delegate method when Swizzling is enabled.
4 DeviceToken must be set MANDATORILY to MarketingCloudSDK using`SFMCSdk.mp.setDeviceToken` API for Push notifications to be received through Mobile Push.
5 */
6extension AppDelegate : MessagingDelegate {
7    func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
8        print("FCM Token", fcmToken ?? "")
9
10        SFMCSdk.requestPushSdk { mp in
11            print("SDK is operational")
12            if let apnsToken = messaging.apnsToken {
13                print("Setting APNs token in MarketingCloudSDK")
14                mp.setDeviceToken(apnsToken)
15            } else {
16                print("fcm token is null")
17            }
18            print("SDK is not yet operational")
19        }
20    }
21}

1/**
2     MobilePush SDK: REQUIRED IMPLEMENTATION
3     */
4    func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
5        PushFeature.requestSdk { pushFeature in
6            pushFeature?.setNotificationUserInfo(userInfo)
7        }
8        completionHandler(.newData)
9    }
10
11    func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
12        PushFeature.requestSdk { pushFeature in
13            pushFeature?.setNotificationResponse(response)
14        }
15        completionHandler()
16    }
17
18    func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
19        completionHandler([.banner, .list, .sound])
20    }

1/**
2     MobilePush SDK: REQUIRED IMPLEMENTATION
3     */
4    func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
5        SFMCSdk.requestPushSdk { mp in
6            mp.setNotificationUserInfo(userInfo)
7        }
8        completionHandler(.newData)
9    }
10
11    func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
12        SFMCSdk.requestPushSdk { mp in
13            mp.setNotificationRequest(response.notification.request)
14        }
15        completionHandler()
16    }
17
18    func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
19        completionHandler([.banner, .list, .sound])
20    }

1// Disable Swizzling in the other push provider used
2//registerForRemoteNotifications() method gets to this callback
3func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
4    PushFeature.requestSdk { pushFeature in
5        pushFeature?.setDeviceToken(deviceToken)
6    }
7}
8
9/**
10 MobilePush SDK: REQUIRED IMPLEMENTATION
11 */
12func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
13    PushFeature.requestSdk { pushFeature in
14        pushFeature?.setNotificationUserInfo(userInfo)
15    }
16    completionHandler(.newData)
17}
18
19func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
20    PushFeature.requestSdk { pushFeature in
21        pushFeature?.setNotificationResponse(response)
22    }
23    completionHandler()
24}
25
26func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
27    completionHandler([.banner, .list, .sound])
28}

1// Disable Swizzling in the other push provider used
2//registerForRemoteNotifications() method gets to this callback
3func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
4    SFMCSdk.requestPushSdk { mp in
5        mp.setDeviceToken(deviceToken)
6    }
7}
8
9/**
10 MobilePush SDK: REQUIRED IMPLEMENTATION
11 */
12func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
13    SFMCSdk.requestPushSdk { mp in
14        mp.setNotificationUserInfo(userInfo)
15    }
16    completionHandler(.newData)
17}
18
19func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
20    SFMCSdk.requestPushSdk { mp in
21        mp.setNotificationRequest(response.notification.request)
22    }
23    completionHandler()
24}
25
26func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
27    completionHandler([.banner, .list, .sound])
28}

1SFMCSdk.setFileProtectionType(fileProtectionType: .completeUntilFirstUserAuthentication)

1failed to build module 'PushFeatureSDK'; this SDK is not supported by the compiler (the SDK is built with 'Apple Swift version 6.1.2...', while this compiler is 'Apple Swift version 6.2.3...'). Please select a toolchain which matches the SDK.
2
3'PushFeatureProtocol' is unavailable: cannot find Swift declaration for this protocol.

1SFMCSdk.setAutoMergePolicy { isMergeSucces in
2    if(!isMergeSuccess) {
3        // ...
4    }
5}

1[SFMCSdk setAutoMergePolicyOnCompletion:^(BOOL isMergeSuccess) {
2    if(!isMergeSuccess) {
3        // ...
4    }
5}];

1class ExampleDelegate: UIResponder, UIApplicationDelegate {
2
3    var setTagsAndAttributes: (() -> ())? = nil
4
5    // ...
6}
7
8// ...
9SFMCSdk.setManualMergePolicy(withHandler: {(v8, v9) in
10
11    self.setTags = {
12        let tags: [String] = // e.g. v9["tags"]
13        MarketingCloudSdk.requestSdk { mc in
14            mc?.addTags(tags)
15        }
16    }
17}
18                             
19private func handleSDKInitializationCompletion(status: [ModuleInitStatus]) {
20    // ...
21    if moduleStatus.initStatus == .success {
22        // Handle successful initialization for each module
23        switch moduleStatus.moduleName {
24        case .engagement:
25            self.setTags?()
26            // Handle successful initialization for Marketing cloud module
27        }
28    }
29    // ...
30}
31
32// ...
33
34SFMCSdk.initializeSdk(configBuilder.build(), completion: completionHandler)

1class ExampleDelegate: UIResponder, UIApplicationDelegate {
2
3    var setTagsAndAttributes: (() -> ())? = nil
4
5    // ...
6}
7
8// ...
9SFMCSdk.setManualMergePolicy(withHandler: {(v7, v8) in
10
11    self.setTagsAndAttributes = {
12        let attributes: [String:String] = // e.g. v8["attributes"] as! [String : String]
13        SFMCSdk.identity.setProfileAttributes([ModuleName.push : attributes])
14
15        let tags: [String] = // e.g. v8["tags"]
16        SFMCSdk.requestPushSdk { mp in
17            mp.addTags(tags)
18        }
19    }
20}
21
22// ...
23
24let completionHandler: (OperationResult) -> () = { result in
25    // ...
26    if result == .success {
27        // ...
28        if (SFMCSdk.mp.getStatus() == .operational) {
29            self.setTagsAndAttributes?()
30        }
31        // ...
32    }
33}
34
35// ...
36
37SFMCSdk.initializeSdk(ConfigBuilder().setPush(config: configuration, onCompletion: completionHandler).build())

1@interface ExampleDelegate : UIResponder <UIApplicationDelegate>
2
3@property (nonatomic, copy) void (^setTags)(void);
4
5// ...
6
7[SFMCSdk setManualMergePolicyWithHandler:^(NSDictionary * _Nonnull v8, NSDictionary * _Nonnull v9) {
8    self.setTags = ^{
9    
10        NSArray *tags = // e.g. v9[@"tags"];
11        [SFMarketingCloudSdk requestSdk:^(id<MarketingCloudSdkInterface> _Nonnull mp) {
12          [mp addTags: tags];
13        }];
14    }
15}];
16
17// MARK: - SDK Initialization Completion Handler
18
19- (void)handleSDKInitializationCompletion:(NSArray<SFMCModuleInitStatus *> *)status {
20    // ...
21        if (moduleStatus.initStatus == SFMCSdkOperationResultSuccess) {
22            switch (moduleStatus.moduleName) {
23                case SFMCSdkModuleNameEngagement:
24                    if (self.setTags != nil) {
25                        [self setTags];
26                    }
27                    break;
28            }
29        }
30    // ...
31
32SFMCSdkConfigBuilder *configBuilder = [[SFMCSdkConfigBuilder alloc] init];
33configBuilder = [configBuilder setEngagementWithConfig:pushConfig];
34[SFMCSdk initializeSdk:[configBuilder build] completion:^(NSArray<SFMCModuleInitStatus *> * _Nonnull status) {
35    // Handle completion
36    [self handleSDKInitializationCompletion:status];
37}];

1@interface ExampleDelegate : UIResponder <UIApplicationDelegate>
2
3@property (nonatomic, copy) void (^setTagsAndAttributes)(void);
4
5// ...
6
7[SFMCSdk setManualMergePolicyWithHandler:^(NSDictionary * _Nonnull v7, NSDictionary * _Nonnull v8) {
8    self.setTagsAndAttributes = ^{
9        NSDictionary *attributes = // e.g. v8[@"attributes"];
10        [[SFMCSdk identity] setProfileAttributes:attributes];
11
12        NSArray *tags = // e.g. v8[@"tags"];
13        [SFMCSdk requestPushSdk:^(id<PushInterface> _Nonnull mp) {
14          [mp addTags: tags];
15        }];
16    }
17}];
18
19// ...
20
21void (^completionHandler)(OperationResult) = ^(OperationResult result) {
22   switch(result) {
23       case OperationResultSuccess:
24            // ...
25            if ([[SFMCSdk mp] getStatus] == ModuleStatusOperational) {
26                if (self.setTagsAndAttributes != nil) {
27                    [self setTagsAndAttributes];
28                }
29            }
30           // ...
31
32           break;
33       // ...
34   }
35}
36
37SFMCSdkConfigBuilder *configBuilder = [[SFMCSdkConfigBuilder alloc] init];
38configBuilder = [configBuilder setPushWithConfig:pushConfig onCompletion:completionHandler];
39[SFMCSdk initializeSdk:[configBuilder build]];

1let appId = // your app ID
2let resetSuccess: Bool = SFMCSdk.resetDataPolicy(appId: appId)
3if (resetSuccess) {
4    print("reset succeeded")
5}

1NSString *appId = // your app ID
2BOOL resetSuccess = [SFMCSdk resetDataPolicyWithAppId:appId];
3if(resetSuccess) {
4    NSLog(@"reset succeeded");
5}

1Terminating app due to uncaught exception 'com.salesforce.security.keychainException',
2reason: 'dictionaryItemFromKeychain: Error attempting to look up keychain item:
3Unknown status code (-34018)'