• Click on  "+ Capability" and select "Push Notifications"
• Click on "+ Capability" and select "Background Modes" and
  
  • Select Remote notifications
  •  

• Click on  "+ Capability" and select "Push Notifications"
• Click on "+ Capability" and select "Background Modes" and
  • Select Location updates
  • Select Remote notifications

nudgeBase

nudgeGeo

target '<YOUR_APP_NAME>' do 
use_frameworks! 
pod 'nudgeBase', '<LIB_VERSION_NUMBER>' 
end

target '<YOUR_APP_NAME>' do 
use_frameworks! 
pod 'nudgeGeo', '<LIB_VERSION_NUMBER>' 
end

source 'https://cdn.cocoapods.org/'
source 'https://github.com/getlarky/nudgePods.git'
target '<YOUR_APP_NAME>' do
  use_frameworks!
  pod 'nudgeBase', '<LIB_VERSION_NUMBER>'
end

source 'https://cdn.cocoapods.org/'
source 'https://github.com/getlarky/nudgePods.git'
target '<YOUR_APP_NAME>' do
  use_frameworks!
pod 'nudgeGeo', '<LIB_VERSION_NUMBER>'
end

Objective-C:

In ViewController.m:

@import nudgeBase;

In ViewController.m:

@import nudgeGeo;

Swift:

In ViewController.swift:

import nudgeBase

In ViewController.swift:

import nudgeGeo

NudgeBase *myNudge = [[NudgeBase alloc] 
      initWithOptions:@{
        @"apiKey": @"<YOUR_API_KEY_HERE>",
        @"enabled": @YES,
        @"federationID": @"<USER_ID>"
    }];

NudgeGeo *myNudge = [[NudgeGeo alloc] 
      initWithOptions:(@{
        @"apiKey": @"<API_KEY>",
        @"enabled": @YES,
        @"federationID": @"<FEDERATION_ID",
        @"showLocationDialog": @YES
    }) callback: nil];

var myNudge: NudgeBase!
let apiKey: String = “<YOUR_API_KEY_HERE>"
let federationId: String = "<USERID_ID>"

myNudge = NudgeBase(options: [
    "apiKey": self.apiKey,
    "enabled": true,
    "federationId": self.federationId
]);

var myNudge: NudgeGeo!
let apiKey: String = “<YOUR_API_KEY_HERE>"
let federationId: String = "<USERID_ID>"

myNudge = NudgeGeo(options: [
    "apiKey": self.apiKey,
    "enabled": true,
    "showLocationDialog": true,
    "federationId": self.federationId
]);

AppDelegate.h

#import <UIKit/UIKit.h>
#import <UserNotifications/UserNotifications.h>

@interface AppDelegate : 
  UIResponder <UIApplicationDelegate, UNUserNotificationCenterDelegate>

@end

AppDelegate.m

@import nudgeBase

Swift:

AppDelegate.swift

import nudgeBase 

@UIApplicationMain 
class AppDelegate: UIResponder, UIApplicationDelegate { 

}

UNUserNotificationCenter *center = 
  [UNUserNotificationCenter currentNotificationCenter]; 
center.delegate = self; 

[NudgeBase registerForPushNotificationsAndReturnError:nil]; 

[application registerForRemoteNotifications];

UNUserNotificationCenter.current().delegate = self

try? NudgeBase.registerForPushNotifications()

application.registerForRemoteNotifications()

NOTE: this method is only available for iOS 10 or higher. If you'd like to handle the case where your user is below iOS 10, you can do so by catching the following error:

UNUserNotificationCenter.current().delegate = self

do {
    try NudgeBase.registerForPushNotifications()
} catch NudgeBase.NudgeErrors.unsupportediOSVersion {
    print("Unsupported iOS version, please upgrade.")
} catch {
    print("Unexpected error when trying to register for push notifications.")
}

application.registerForRemoteNotifications()

- (void)application:(UIApplication *)application 
    didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken { 
      [NudgeBase onRegisteredForNotificationsWithDeviceToken:deviceToken]; 
}

func application(_ application: UIApplication, 
    didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) { 
        NudgeBase.onRegisteredForNotifications(deviceToken: deviceToken) 
    } 

- (void)application:(UIApplication *)application 
    didFailToRegisterForRemoteNotificationsWithError:(NSError *)error { 
    [NudgeBase onFailedToRegisterForNotificationsWithError:error]; 
}

func application(_ application: UIApplication, 
    didFailToRegisterForRemoteNotificationsWithError error: Error) { 
        NudgeBase.onFailedToRegisterForNotifications(error:error) 
    }

- (void)application:(UIApplication *)application 
    didReceiveRemoteNotification:(NSDictionary *)userInfo 
    fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
      [NudgeBase receivedPushWithNotificationPayload:userInfo application:application];
}

NSString * isNudge = [userInfo objectForKey:@"isNudge"]; 
BOOL boolIsNudge = [isNudge boolValue]; 
if (boolIsNudge) { 
    [NudgeBase receivedPushWithNotificationPayload:userInfo application:application];
} else { 
    // Do application logic for your notifications here! 
}

let isNudge = userInfo["isNudge"] as! Bool;
if (isNudge) { 
    NudgeBase.receivedPush(notificationPayload:userInfo, application: application)} 
else { 
    // Do application logic for your notifications here!
}

...toward the bottom of your AppDelegate class

- (void)userNotificationCenter:(UNUserNotificationCenter *)center
    willPresentNotification:(UNNotification *)notification
    withCompletionHandler:
       (void (^)(UNNotificationPresentationOptions options))completionHandler {   
          NSLog(@"%@", notification.request.content.userInfo);
          completionHandler(UNAuthorizationOptionSound | 
              UNAuthorizationOptionAlert | UNAuthorizationOptionBadge);
}

- (void)userNotificationCenter:(UNUserNotificationCenter *)center
    didReceiveNotificationResponse:(UNNotificationResponse *)response
    withCompletionHandler:(void (^)())completionHandler {
     NSLog(@"%@", response.notification.request.content.userInfo);
    [NudgeBase tappedNotificationWithNotification:response.notification];
    completionHandler();
}

Swift:

...after your class AppDelegate: UIResponder, UIApplicationDelegate {}class

@available(iOS 10, *)
extension AppDelegate: UNUserNotificationCenterDelegate {
    // Receive displayed notifications for iOS 10 devices.
    func userNotificationCenter(_ center: UNUserNotificationCenter,
      willPresent notification: UNNotification,
      withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {        
      if#available(iOS 14.0, *) {
          completionHandler([[.banner, .sound, .badge]])
      } else {
          // Fallback on earlier versions
          completionHandler([[.alert, .sound, .badge]])
      }    
    }
    func userNotificationCenter(_ center: UNUserNotificationCenter,
           didReceive response: UNNotificationResponse,
           withCompletionHandler completionHandler: @escaping () -> Void) {
             NudgeBase.tappedNotification(notification: response.notification)
             completionHandler()
    }
}

Finally, we need to request location permissions from users!

This is an important step in not only requesting the appropriate permissions, but also explaining to the
user why you are requesting that permission. The example text below can be used as a default; any
changes to this text should be reviewed and approved by the client.

Add the following entries into your app's Info.plist file :

Privacy - Location When In Use Usage Description (NSLocationWhenInUseUsageDescription)

Default string:

Allow While Using App to take full advantage of personalized notifications for branch details, 
community events and possible fraud activity

Privacy - Location Always and When In Use Usage Description (NSLocationAlwaysAndWhenInUseUsageDescription)

Default string:

Please tap Always Allow to continue taking full advantage of personalized notifications for branch details, 
community events and possible fraud activity

//
//  AppDelegate.swift
//  nudgeBase
//
//  Copyright (c) 2022 Larky, Inc. All rights reserved.
//

import UIKit
import nudgeBase

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    var window: UIWindow?

    func application(_ application: UIApplication,
                     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        
        // For iOS 10 display notification (sent via APNS)
        UNUserNotificationCenter.current().delegate = self

        do {
            try NudgeBase.registerForPushNotifications()
        } catch NudgeBase.NudgeErrors.unsupportediOSVersion {
            print("Unsupported iOS version, please upgrade")
        } catch {
            print("Unexpected error, please contact support@larky.com")
        }
        
        application.registerForRemoteNotifications()
        
        return true
    }

    func applicationWillResignActive(_ application: UIApplication) {
        // Sent when the application is about to move from active to inactive state. 
        // This can occur for certain types of temporary interruptions (such as an incoming phone call 
        // or SMS message) or when the user quits the application and it begins the transition to the 
        // background state. Use this method to pause ongoing tasks, disable timers, and throttle down 
        // OpenGL ES frame rates. Games should use this method to pause the game.
    }

    func applicationDidEnterBackground(_ application: UIApplication) {
        // Use this method to release shared resources, save user data, invalidate timers, and store 
        // enough application state information to restore your application to its current state 
        // in case it is terminated later. If your application supports background execution, this method 
        // is called instead of applicationWillTerminate: when the user quits.
    }

    func applicationWillEnterForeground(_ application: UIApplication) {
        // Called as part of the transition from the background to the inactive state; 
        // here you can undo many of the changes made on entering the background.
    }

    func applicationDidBecomeActive(_ application: UIApplication) {
        // Restart any tasks that were paused (or not yet started) while the application was inactive. 
        // If the application was previously in the background, optionally refresh the user interface.
    }

    func applicationWillTerminate(_ application: UIApplication) {
        // Called when the application is about to terminate. Save data if appropriate. 
        // See also applicationDidEnterBackground:.
    }
    
    
    func application(_ application: UIApplication,
                     didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
        NudgeBase.onRegisteredForNotifications(deviceToken: deviceToken)
    }
    
    func application(_ application: UIApplication,
                     didFailToRegisterForRemoteNotificationsWithError error: Error) {
        NudgeBase.onFailedToRegisterForNotifications(error:error)
    }
    
    func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable: Any],
                     fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
        // If you are receiving a notification message while your app is in the background,
        // this callback will not be fired till the user taps on the notification launching the application.
        guard (userInfo["aps"] as? [String: AnyObject]) != nil else {
            completionHandler(.failed)
            return
        }
        
        guard (userInfo["isNudge"] as? Bool) != nil else {
            return
        }
        
        let isNudge = userInfo["isNudge"] as! Bool;
        if (isNudge) {
            NudgeBase.receivedPush(notificationPayload:userInfo, application: application)
        }
        completionHandler(.noData)
    }
}

// [START ios_10_message_handling]
@available(iOS 10, *)
extension AppDelegate: UNUserNotificationCenterDelegate {
    // Receive displayed notifications for iOS 10 devices.
    func userNotificationCenter(_ center: UNUserNotificationCenter,
                                willPresent notification: UNNotification,
      withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
      print(notification.request.content.userInfo)      
      if#available(iOS 14.0, *) {
          completionHandler([[.banner, .sound, .badge]])
      } else {
          // Fallback on earlier versions
          completionHandler([[.alert, .sound, .badge]])
      }    
    }
    func userNotificationCenter(_ center: UNUserNotificationCenter,
                              didReceive response: UNNotificationResponse,
                              withCompletionHandler completionHandler: @escaping () -> Void) {
        NudgeBase.tappedNotification(notification: response.notification)
        completionHandler()
    }
}

//
//  ViewController.swift
// 
import UIKit

import nudgeBase

class ViewController: UIViewController {

    var apiKey: String = "<YOUR API KEY HERE>"
    var myNudge: NudgeBase!
    var isNudgeEnabled: Bool = true

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view.
        myNudge = NudgeBase(options: [
                "apiKey": self.apiKey,
                "enabled": self.isNudgeEnabled
            ]);
    }
}

//
//  ViewController.swift
// 
import UIKit

import nudgeGeo

class ViewController: UIViewController {

    var apiKey: String = "<YOUR API KEY HERE>"
    var myNudge: NudgeGeo!
    var isNudgeEnabled: Bool = true

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view.
        myNudge = NudgeGeo(options: [
                "apiKey": self.apiKey,
                "enabled": self.isNudgeEnabled
            ]);
    }
}