iOS SDK 2.0 - How to Integrate and Power Your Brand Community in iOS Apps

platform :ios, '13.0'

target 'YourProject' do
  use_frameworks!

  # Pods for YourProject

genuin_sdk_version = '2.1.1'

pod "GenuinCore", :git => "https://bitbucket.org/genuindev/genuin_sdk_ios.git", :tag => genuin_sdk_version
pod "GenuinUI", :git => "https://bitbucket.org/genuindev/genuin_sdk_ios.git", :tag => genuin_sdk_version
pod "GenuinCamera", :git => "https://bitbucket.org/genuindev/genuin_sdk_ios.git", :tag => genuin_sdk_version
pod "GenuinAI", :git => "https://bitbucket.org/genuindev/genuin_sdk_ios.git", :tag => genuin_sdk_version


end

post_install do |installer|
  installer.pods_project.targets.each do |target|
    if target.name == 'Giphy'
      `xcrun -sdk iphoneos bitcode_strip -r Pods/Giphy/GiphySDK/GiphyUISDK.xcframework/ios-arm64_armv7/GiphyUISDK.framework/GiphyUISDK -o Pods/Giphy/GiphySDK/GiphyUISDK.xcframework/ios-arm64_armv7/GiphyUISDK.framework/GiphyUISDK`
    end
    target.build_configurations.each do |config|
      config.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = '13.0'
      config.build_settings['BUILD_LIBRARY_FOR_DISTRIBUTION'] = 'YES'
    end
  end
end

pod "GenuinCore", :git => "https://bitbucket.org/genuindev/genuin_sdk_ios.git", :tag => genuin_sdk_version

pod "GenuinUI", :git => "https://bitbucket.org/genuindev/genuin_sdk_ios.git", :tag => genuin_sdk_version

pod "GenuinCamera", :git => "https://bitbucket.org/genuindev/genuin_sdk_ios.git", :tag => genuin_sdk_version

pod "GenuinAI", :git => "https://bitbucket.org/genuindev/genuin_sdk_ios.git", :tag => genuin_sdk_version

import GenuinCore

func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
    // Optional configuration and attaching the UIWindow to UIWindowScene
    guard let _ = (scene as? UIWindowScene) else { return }

    // Initialize the SDK configuration 
    let configuration = GenuinConfiguration.shared

    // For Production environment (Default)
    configuration.setCustomLoader("YOUR_LOADER", bundle: .main)

    // For QA Environment
    configuration.environment = .qa 

    // Initialize the SDK with your API key and configuration
    GenuinSDK.shared.initialize(apiKey: "YOUR_API_KEY", configuration: configuration)

    // Notify the SDK that the scene will connect
    GenuinSDK.shared.scene(scene, willConnectTo: session, options: connectionOptions)
}

import GenuinCore

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    // Initialize the SDK configuration
    let configuration = GenuinConfiguration.shared

    // For Production Environment (Default)
    configuration.setCustomLoader("YOUR_LOADER", bundle: .main)

    // For QA Environment 
    configuration.environment = .qa 

   // Initialize the SDK with your API key and configuration
    GenuinSDK.shared.initialize(apiKey: "YOUR_API_KEY", configuration: configuration)
    return true
}

GenuinUI.shared.initialize() //Initialize method is required if GenuinUI sdk is integrated
GenuinCamera.shared.initialize() //Initialize method is required if GenuinCamera sdk is integrated
GenuinAI.shared.initialize() //Initialize method is required if GenuinAI sdk is integrated

GenuinSDK.shared.initialize(apiKey: "YOUR_API_KEY", configuration: configuration)

import GenuinCore
import GenuinUI
import GenuinCamera
import GenuinAI

func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
    // Optional configuration and attaching the UIWindow to UIWindowScene
    guard let _ = (scene as? UIWindowScene) else { return }

    // Initialize the SDK configuration 
    let configuration = GenuinConfiguration.shared

    // For Production environment (Default)
    configuration.setCustomLoader("YOUR_LOADER", bundle: .main)

    // For QA Environment
    configuration.environment = .qa 

    GenuinUI.shared.initialize() //Initialize method is required if GenuinUI sdk is integrated
    GenuinCamera.shared.initialize() //Initialize method is required if GenuinCamera sdk is integrated
    GenuinAI.shared.initialize() //Initialize method is required if GenuinAI sdk is integrated


    // Initialize the SDK with your API key and configuration
    GenuinSDK.shared.initialize(apiKey: "YOUR_API_KEY", configuration: configuration)
}

import GenuinCore
import GenuinUI
import GenuinCamera
import GenuinAI

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    // Initialize the SDK configuration
    let configuration = GenuinConfiguration.shared

    // For Production Environment (Default)
    configuration.setCustomLoader("YOUR_LOADER", bundle: .main)

    // For QA Environment 
    configuration.environment = .qa 

GenuinUI.shared.initialize() //Initialize method is required if GenuinUI sdk is integrated
GenuinCamera.shared.initialize() //Initialize method is required if GenuinCamera sdk is integrated
GenuinAI.shared.initialize() //Initialize method is required if GenuinAI sdk is integrated


   // Initialize the SDK with your API key and configuration
    GenuinSDK.shared.initialize(apiKey: "YOUR_API_KEY", configuration: configuration)
    return true
}

import SwiftUI
import GenuinCore
import GenuinUI
import GenuinAI
import GenuinCamera

@main
struct GenuinSwiftUIApp: App {
    
    init() {
        let configuration = GenuinConfiguration()

        // For QA Environment
        configuration.environment = .qa

        configuration.setCustomLoader("YOUR_LOADER", bundle: Bundle.main)
        GenuinUI.shared.initialize()
        GenuinCamera.shared.initialize()
        GenuinAI.shared.initialize()
        GenuinSDK.shared.initialize(apiKey: "YOUR_API_KEY", configuration: configuration)
    }
    
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

import AppTrackingTransparency
import AdSupport //Import only if you want to use advertisingIdentifier

class SceneDelegate: UIResponder, UIWindowSceneDelegate {

   func sceneDidBecomeActive(_ scene: UIScene) {
        // Called when the scene has moved from an inactive state to an active state.
        // Use this method to restart any tasks that were paused (or not yet started) when the scene was inactive.
        DispatchQueue.main.async {
            ATTrackingManager.requestTrackingAuthorization { status in
                switch status {
                case .notDetermined:
                    break
                case .restricted:
                    break
                case .denied:
                    break
                case .authorized:
                    // If you want to check the current advertisingIdentifier
                    print("advertisingIdentifier: ", ASIdentifierManager.shared().advertisingIdentifier.uuidString)
                    break
                @unknown default:
                    break
                }
            }
        }
    }

}

import AppTrackingTransparency
import AdSupport //Import only if you want to use advertisingIdentifier

class AppDelegate: UIResponder, UIApplicationDelegate {

    func applicationDidBecomeActive(_ application: UIApplication) {
        DispatchQueue.main.async {
            ATTrackingManager.requestTrackingAuthorization { status in
                switch status {
                case .notDetermined:
                    break
                case .restricted:
                    break
                case .denied:
                    break
                case .authorized:
                    // If you want to check the current advertisingIdentifier
                    print("advertisingIdentifier: ", ASIdentifierManager.shared().advertisingIdentifier.uuidString)
                    break
                @unknown default:
                    break
                }
            }
        }
    }

}

init(
    embedId: String,
    uniqueId: String? = nil,
    viewController: UIViewController,
    ssoToken: String? = nil,
    params: [String: Any]? = nil,
    contextualParams: [String: Any]? = nil,
    embedConfiguration: EmbedConfiguration = EmbedConfiguration()
)

let embedConfiguration = EmbedConfiguration()
embedConfiguration.isShowProfileEnabled = false
embedConfiguration.isDirectDeepLinkEnabled = false

GenuinSDK.shared.initializeEmbed(embedId: "YOUR_EMBED_ID", containerView: <YOUR_CONTAINER_VIEW>, viewConroller: <YOUR_VIEW_CONTROLLER>, ssoToken: <YOUR_SSO_TOKEN>, embedConfiguration: embedConfiguration)

let embedConfiguration = EmbedConfiguration()
embedConfiguration.isShowProfileEnabled = false
embedConfiguration.isDirectDeepLinkEnabled = false

GenuinSDK.shared.initializeEmbed(embedId: "YOUR_EMBED_ID", containerView: <YOUR_CONTAINER_VIEW>, viewConroller: <YOUR_VIEW_CONTROLLER>, embedConfiguration: embedConfiguration)

let embedConfiguration = EmbedConfiguration()
embedConfiguration.isShowProfileEnabled = false
embedConfiguration.isDirectDeepLinkEnabled = false

GenuinSDK.shared.initializeEmbed(embedId: "EMBED_ID", uniqueId: "YOUR_UNIQUE_ID", containerView: YOUR_VIEW, viewConroller: YOUR_VIEW_CONTROLLER, ssoToken: "YOUR_SSO_TOKEN", params: ["name" :"FULL_NAME", "nickname" : "USER_NAME", "mobile" :"MOBILE_NO"], contextualParams: ["page_context": "CONTEXT_TEXT", "geo": { "lat": LATITUDE_VALUE, "long": LONGITUDE_VALUE }], embedConfiguration: embedConfiguration)

// Below is an Example Code

let attributes = GenuinEmbedAttributes(embedId: YOUR_EMBED_ID, viewController: YOUR_VIEW_CONTROLLER)
let embedView = GenuinEmbedView(attributes: attributes)
self.YOUR_VIEW.addSubview(embedView)
embedView.fetchDataAndLoad()

// Below is an Example Code

let embedView = GenuinEmbedView()
let attributes = GenuinEmbedAttributes(embedId: YOUR_EMBED_ID, viewController: YOUR_VIEW_CONTROLLER)
embedView.initWith(attributes: attributes)
self.YOUR_VIEW.addSubview(embedView)
embedView.fetchDataAndLoad()

@IBOutlet weak var embedView: GenuinEmbedView?

func loadEmbed() {
    //specify your attributes
    let attributes = GenuinEmbedAttributes(embedId: YOUR_EMEBED_ID,
                                           viewController: YOUR_VIEW_CONTROLLER)
    embedView?.initWith(attributes: attributes)
    embedView?.fetchDataAndLoad()
}

let embedConfiguration = EmbedConfiguration()
embedConfiguration.isShowProfileEnabled = false
embedConfiguration.isDirectDeepLinkEnabled = false

GenuinSDK.shared.initializeEmbedFeed(embedId: "YOUR_EMBED_ID", containerView: <YOUR_CONTAINER_VIEW>, viewConroller: <YOUR_VIEW_CONTROLLER>, ssoToken: <YOUR_SSO_TOKEN>, embedConfiguration: embedConfiguration)

let embedConfiguration = EmbedConfiguration()
embedConfiguration.isShowProfileEnabled = false
embedConfiguration.isDirectDeepLinkEnabled = false

GenuinSDK.shared.initializeEmbedFeed(embedId: "YOUR_EMBED_ID", containerView: <YOUR_CONTAINER_VIEW>, viewConroller: <YOUR_VIEW_CONTROLLER>, embedConfiguration: embedConfiguration)

let embedConfiguration = EmbedConfiguration()
embedConfiguration.isShowProfileEnabled = false
embedConfiguration.isDirectDeepLinkEnabled = false

GenuinSDK.shared.initializeEmbedFeed(embedId: "EMBED_ID", uniqueId: "YOUR_UNIQUE_ID", containerView: YOUR_VIEW, viewConroller: YOUR_VIEW_CONTROLLER, ssoToken: "YOUR_SSO_TOKEN", params: ["name" :"FULL_NAME", "nickname" : "USER_NAME", "mobile" :"MOBILE_NO"], contextualParams: ["page_context": "CONTEXT_TEXT", "geo": { "lat": LATITUDE_VALUE, "long": LONGITUDE_VALUE }], embedConfiguration: embedConfiguration)

import GenuinCore

class StandardWallFeedViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        // Do any additional setup after loading the view.
        let embedConfiguration = EmbedConfiguration()
        embedConfiguration.isShowProfileEnabled = true
        
        GenuinSDK.shared.initializeStandardWall(embedId: "YOUR_EMBED_ID", containerView: self.view, viewConroller: self, embedConfiguration: embedConfiguration)
        
    }

}

import SwiftUI
import UIKit
import GenuinCore

struct GenuinCarouselViewWrapper: UIViewRepresentable {
    var embedId: String
    
    func makeUIView(context: Context) -> UIView {
        let container = UIView()
        return container
    }

    func updateUIView(_ uiView: UIView, context: Context) {
        DispatchQueue.main.async {
            guard let parentVC = uiView.parentViewController else {
                print("Could not get parent VC!")
                return
            }

            let embedConfiguration = EmbedConfiguration()

            GenuinSDK.shared.initializeEmbed(
                embedId: embedId,
                containerView: uiView,
                viewConroller: parentVC,
                embedConfiguration: embedConfiguration
            )
        }
    }
}

import SwiftUI
import UIKit
import GenuinCore

struct GenuinCarouselContextViewWrapper: UIViewRepresentable {
    var embedId: String
    var uniqueId: String?
    var ssoToken: String?
    var params: [String : Any]?
    var contextualParams: [String: Any]?
    var embedConfiguration: EmbedConfiguration = EmbedConfiguration()
    
    func makeUIView(context: Context) -> UIView {
        let container = UIView()
        return container
    }

    func updateUIView(_ uiView: UIView, context: Context) {
        DispatchQueue.main.async {
            guard let parentVC = uiView.parentViewController else {
                print("Could not get parent VC!")
                return
            }

            GenuinSDK.shared.initializeEmbed(
                embedId: embedId,
                uniqueId: uniqueId,
                containerView: uiView,
                viewConroller: parentVC,
                ssoToken: ssoToken,
                params: params,
                contextualParams: contextualParams,
                embedConfiguration: embedConfiguration
            )
        }
    }
}

import SwiftUI

struct CarouselView: View {
    var body: some View {
        VStack {
            GenuinCarouselViewWrapper(embedId: "YOUR_EMBED_ID")
                .frame(height: 200)
            
            Spacer()
        }
    }
}

#Preview {
    CarouselView()
}

import SwiftUI
import UIKit
import GenuinCore

struct CarouselContextView: View {
    @State private var contextualParams: [String: Any]? = nil
    @State private var txtContext: String = ""
    private var embedConfiguration: EmbedConfiguration = EmbedConfiguration()
    
    init() {
        let genuinCarouselConfiguration = GenuinCarouselConfiguration()
        genuinCarouselConfiguration.aspectRatio = .ratio4x5
        embedConfiguration.genuinCarouselConfiguration = genuinCarouselConfiguration
    }
    
    var body: some View {
        VStack {
            GenuinCarouselContextViewWrapper(embedId: "YOUR_EMBED_ID", uniqueId: "YOUR_UNIQUE_ID", ssoToken: "YOUR_SSO_TOKEN", params: ["name" :"FULL_NAME", "nickname" : "USER_NAME", "mobile" :"MOBILE_NO"], contextualParams: contextualParams, embedConfiguration: embedConfiguration)
                .frame(height: 200)
            
            HStack {
                TextField("Contextual Params", text: $txtContext)
                    .textFieldStyle(.roundedBorder)
                
                Button("Assign Context") {
                    contextualParams = ["page_context": txtContext, "geo" : [ "lat": LATITUDE_VALUE, "long": LONGITUDE_VALUE ]]
                }
            }
            .padding()
            
            Spacer()
        }
    }
}

#Preview {
    CarouselContextView()
}

import SwiftUI
import GenuinCore

struct GenuinSDKStandardWallNavigationControllerWrapper: UIViewControllerRepresentable {
    var embedId: String
    
    func makeUIViewController(context: Context) -> UINavigationController {
        // Return the UIKit UINavigationController from the SDK
        let embedConfiguration = EmbedConfiguration()
        
        return GenuinSDK.shared.getStandardWallController(embedId: embedId, embedConfiguration: embedConfiguration) ?? UINavigationController()
    }

    func updateUIViewController(_ uiViewController: UINavigationController, context: Context) {
        // No update logic needed unless the SDK content needs to change dynamically
    }
}

import SwiftUI

struct StandardWallView: View {
    var body: some View {
        GenuinSDKStandardWallNavigationControllerWrapper(embedId: "YOUR_EMBED_ID")
            .edgesIgnoringSafeArea(.top)
    }
}

#Preview {
    StandardWallView()
}

GenuinSDK.shared.initializeEmbed(embedId: "EMBED_ID", uniqueId: "YOUR_UNIQUE_ID", containerView: YOUR_VIEW, viewConroller: YOUR_VIEW_CONTROLLER, ssoToken: "YOUR_TOKEN", params: ["name" :"FULL_NAME", "nickname" : "USER_NAME", "mobile" :"MOBILE_NUMBER"], embedConfiguration: embedConfiguration)

GenuinSDK.shared.initializeEmbed(embedId: "EMBED_ID", uniqueId: "YOUR_UNIQUE_ID", containerView: YOUR_VIEW, viewConroller: YOUR_VIEW_CONTROLLER, ssoToken: "YOUR_TOKEN", contextualParams: ["page_context": "CONTEXT_TEXT", "geo": { "lat": LATITUDE_VALUE, "long": LONGITUDE_VALUE }], embedConfiguration: embedConfiguration)

init(
    placementId: String,
    styleId: String,
    uniqueId: String? = nil,
    viewController: UIViewController,
    ssoToken: String? = nil,
    params: [String: Any]? = nil,
    contextualParams: [String: Any]? = nil,
    placementConfiguration: PlacementConfiguration = PlacementConfiguration()
)

let placementConfiguration = PlacementConfiguration()

GenuinSDK.shared.initializePlacement(
    placementId: "PLACEMENT_ID",
    styleId: "STYLE_ID",
    containerView: YOUR_CONTAINER_VIEW,
    viewController: YOUR_CONTROLLER,
    contextualParams: [
        "page_context": "<PAGE_CONTEXT>",
        "geo": [
            "lat": XX.XXX,          // Float or Double
            "long": XX.XXX,         // Float or Double
            "radius_limit": <RADIUS_LIMIT> // Int
        ],
        "place": [
            "country": "<COUNTRY_CODE>",
            "state": "<STATE>",
            "city": "<CITY>",
            "zipcode": <ZIP>        // Int
        ],
        "time": <timestamp>,        // Long
        "user_segments": [
            "age": "<AGE>",
            "min_age": "<MIN_AGE>",
            "max_age": "<MAX_AGE>",
            "segment": "<SEGMENT>",
            "gender": "M/F/O",
            "race": "<RACE>"
        ],
        "url": "https://url/",
        "brands_ids": [
            brandId1,               // Int
            brandId2                // Int
        ],
        "user_interests": [""],
        "posted_by_user_ids": [
            "user_id1",
            "user_id2"
        ],
        "previous_page_context": "<PREVIOUS_PAGE_CONTEXT>",
        "user_context": "<CONTEXT>"
    ],
    placementConfiguration: placementConfiguration
)

let attributes = GenuinPlacementAttributes(
    placementId: "YOUR_PLACEMENT_ID",
    styleId: "YOUR_PLACEMENT_STYLE_ID",
    viewController: YOUR_VIEW_CONTROLLER
)

let placementView = GenuinPlacementView(attributes: attributes)
self.YOUR_VIEW.addSubview(placementView)
placementView.fetchDataAndLoad()

let placementView = GenuinPlacementView()
let attributes = GenuinPlacementAttributes(
    placementId: "YOUR_PLACEMENT_ID",
    styleId: "YOUR_PLACEMENT_STYLE_ID",
    viewController: YOUR_VIEW_CONTROLLER
)
placementView.initWith(attributes: attributes)
self.YOUR_VIEW.addSubview(placementView)
placementView.fetchDataAndLoad()

@IBOutlet weak var placementView: GenuinPlacementView?

func loadPlacement() {
    let attributes = GenuinPlacementAttributes(
        placementId: "YOUR_PLACEMENT_ID",
        styleId: "YOUR_PLACEMENT_STYLE_ID",
        viewController: YOUR_VIEW_CONTROLLER
    )
    placementView?.initWith(attributes: attributes)
    placementView?.fetchDataAndLoad()
}

let embedView = GenuinEmbedView()
let attributes = GenuinEmbedAttributes(
    embedId: YOUR_EMBED_ID,
    viewController: YOUR_VIEW_CONTROLLER
)
    
embedView.initWith(attributes: attributes)
    
embedView.fetchDataInBackground { success in
    if success {
        self.YOUR_VIEW.addSubview(embedView)
        embedView.load()
    }
}

let placementView = GenuinPlacementView()
let attributes = GenuinPlacementAttributes(
    placementId: "YOUR_PLACEMENT_ID",
    styleId: "YOUR_PLACEMENT_STYLE_ID",
    viewController: YOUR_VIEW_CONTROLLER
)
    
placementView.initWith(attributes: attributes)
    
placementView.fetchDataInBackground { success in
    if success {
        self.YOUR_VIEW.addSubview(placementView)
        placementView.load()
    }
}

GenuinSDK.shared.ssoLogin(ssoToken: "YOUR_SSO_TOKEN")

GenuinSDK.shared.initializeEmbed(embedId: "EMBED_ID", uniqueId: "YOUR_UNIQUE_ID", containerView: YOUR_VIEW, viewConroller: YOUR_VIEW_CONTROLLER, ssoToken: "YOUR_SSO_TOKEN", params: ["name" :"FULL_NAME", "nickname" : "USER_NAME", "mobile" :"MOBILE_NO"], contextualParams: ["page_context": "CONTEXT_TEXT", "geo": { "lat": LATITUDE_VALUE, "long": LONGITUDE_VALUE }], embedConfiguration: embedConfiguration)

GenuinSDK.shared.ssoLogin(ssoToken: "YOUR_SSO_TOKEN", params: ["name" :"FULL_NAME", "nickname" : "USER_NAME"])

GenuinSDK.shared.ssoLogin(ssoToken: "YOUR_SSO_TOKEN") { status in
}
// Where status of login = true or false

GenuinSDK.shared.delegate = self ( YOUR_ANY_CLASS )

extension YOUR_ANY_CLASS : GenuinDelegate{
  func presentLoginViewController(baseViewController : UIViewController) {
    guard let loginVC = GET AND ASSIGN YOUR CONTROLLER
    baseViewController.present(loginVC, animated: true)
  }
}

GenuinSDK.shared.ssoLogin(ssoToken: "YOUR_SSO_TOKEN", params: ["name" : "FULL_NAME", "nickname" : "USER_NAME"])

GenuinSDK.shared.ssoLogout()

GenuinSDK.shared.ssoLogout { status in
}
// Where status of logout = true or false

{"appclips":{"apps":["YOUR_TEAM_ID.APP_BUNDLE_ID.Clip"]},"applinks":{"apps":[],"details":[{"paths":["/*"],"appID":"YOUR_TEAM_ID.APP_BUNDLE_ID"}]}}

class SceneDelegate: UIResponder, UIWindowSceneDelegate {

  var window: UIWindow?

  func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
    // Use this method to optionally configure and attach the UIWindow `window` to the provided UIWindowScene `scene`.
    // If using a storyboard, the `window` property will automatically be initialized and attached to the scene.
    // This delegate does not imply the connecting scene or session are new (see `application:configurationForConnectingSceneSession` instead).
    guard let _ = (scene as? UIWindowScene) else { return }
    handleGenuinDeeplink(deeplinkURL: connectionOptions.userActivities.first?.webpageURL)
  }

  func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
    //redirect if genuin SDK handles the deeplink
    handleGenuinDeeplink(deeplinkURL: userActivity.webpageURL)
  }

  func handleGenuinDeeplink(deeplinkURL: URL?) {
    if let dlURL = deeplinkURL, GenuinSDK.shared.willHandleDeepLink(url: dlURL){
       
      if let rootVC = window?.rootViewController as? UIViewController{
        DispatchQueue.main.async {
          GenuinSDK.shared.handleDeeplink(viewController: rootVC)
        }
      }
    }
  }
}

func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([any UIUserActivityRestoring]?) -> Void) -> Bool {
        //redirect if genuin SDK handles the deeplink
        if let dlURL = userActivity.webpageURL , GenuinSDK.shared.willHandleDeepLink(url: dlURL){
            if let rootVC = window?.rootViewController as? UIViewController {
                GenuinSDK.shared.handleDeeplink(viewController: rootVC)
            }
        }
      return true
 }

override func viewDidAppear(_ animated: Bool) {
    super.viewDidAppear(animated)
    GenuinSDK.shared.handleDeeplink(viewController: self)
}

GenuinSDK.shared.registerLinkoutInterceptor(associateDomains: [ARRAY_OF_ASSOCIATED_DOMAINS_HANDLED_BY_YOUR_APP], linkOutInterceptorDelegate: YOUR_ANY_CLASS)

extension YOUR_ANY_CLASS : GenuinLinkOutInterceptorDelegate{
  func onLinkOutIntercept(urlString: String, viewController: UIViewController?) {
    	/*
         This callback will be triggered when user clicks on linkouts from any video and if it's domain matches the associateDomains provided.
         
         You will receive the url clicked and a current controller so you can handle the deeplink redirection from here in your app
        */
  }
}

pod 'FirebaseMessaging', '~> 10.24.0'

import FirebaseMessaging
import GenuinCore

func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
	//Assign APNS token and notify sdk
        Messaging.messaging().apnsToken = deviceToken 
        GenuinSDK.shared.application(application, didRegisterForRemoteNotificationsWithDeviceToken: deviceToken, isFCMIntegrated: true) 

    }

func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        guard let _ = (scene as? UIWindowScene) else { return }
	//Register the notification
        registerForNotification()
	 //configure firebase
        FirebaseApp.configure() 
	 //set delegate , extend current class with MessagingDelegate
        Messaging.messaging().delegate = self   
    }

func registerForNotification(){
	//Take permission and register remote notification
        let current = UNUserNotificationCenter.current()
        current.getNotificationSettings(completionHandler: { (settings) in
            if settings.authorizationStatus == .notDetermined{
                self.requestForNotificationPermission()
            }else if settings.authorizationStatus == .authorized {
                UNUserNotificationCenter.current().delegate = self
                DispatchQueue.main.async{
                    UIApplication.shared.registerForRemoteNotifications()
                }
            }
        })
    }
    
    private func requestForNotificationPermission(){
        UNUserNotificationCenter.current().delegate = self
        UNUserNotificationCenter.current().requestAuthorization(options:[.badge, .alert, .sound]){ (granted, error) in
            print(granted)
            
        }
        UIApplication.shared.registerForRemoteNotifications()
    }

func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
        if let token = fcmToken {
            //fetch and register token
            getInstanceID()
        }
    }
    
    func getInstanceID(){
        Messaging.messaging().token { token, error in
           // Check for error. Otherwise do what you will with token here
            if let error = error {
                print("Error fetching remote instance ID: \(error)")
            } else if let result = token {
                print("Remote instance ID token: \(result)")
                GenuinSDK.shared.registerFCMToken(token: result)
            }
        }
    }

func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
        
        if let userInfo = response.notification.request.content.userInfo as? [String: AnyObject]{
            //notify firebase
            Messaging.messaging().appDidReceiveMessage(userInfo)

            //check if genuin will handle notification
            if GenuinSDK.shared.willHandleNotification(userInfo: userInfo){
                //notify to redirect
                GenuinSDK.shared.userNotificationCenter(center, didReceive: response, withCompletionHandler: completionHandler)
                //notification notification
                if let rootVC = window?.rootViewController as? UIViewController{
                    GenuinSDK.shared.handleNotifications(viewController: rootVC)
                }
            }
        }
  }

func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void){
        let userInfo = notification.request.content.userInfo
        print("\(userInfo)")
        //mention design type for notification 
        completionHandler([.list, .badge, .sound])
    }

func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void){
        let userInfo = notification.request.content.userInfo
        
        GenuinSDK.shared.userNotificationCenter(center, willPresent: notification, withCompletionHandler: completionHandler)
        if let rootVC = window?.rootViewController as? UIViewController{
            GenuinSDK.shared.handleNotifications(viewController: rootVC)
        }
        
        //mention design type for notification 
        completionHandler([.list, .badge, .sound])
    }

import GenuinCore

func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
	//Assign APNS token and notify sdk
        GenuinSDK.shared.application(application, didRegisterForRemoteNotificationsWithDeviceToken: deviceToken, isFCMIntegrated: false) 

    }

func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        guard let _ = (scene as? UIWindowScene) else { return }
	//Register the notification
        registerForNotification()
    }

func registerForNotification(){
	//Take permission and register remote notification
        let current = UNUserNotificationCenter.current()
        current.getNotificationSettings(completionHandler: { (settings) in
            if settings.authorizationStatus == .notDetermined{
                self.requestForNotificationPermission()
            }else if settings.authorizationStatus == .authorized {
                UNUserNotificationCenter.current().delegate = self
                DispatchQueue.main.async{
                    UIApplication.shared.registerForRemoteNotifications()
                }
            }
        })
    }
    
    private func requestForNotificationPermission(){
        UNUserNotificationCenter.current().delegate = self
        UNUserNotificationCenter.current().requestAuthorization(options:[.badge, .alert, .sound]){ (granted, error) in
            print(granted)
            
        }
        UIApplication.shared.registerForRemoteNotifications()
    }

func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
        
        if let userInfo = response.notification.request.content.userInfo as? [String: AnyObject]{
            //check if genuin will handle notification
            if GenuinSDK.shared.willHandleNotification(userInfo: userInfo){
                //notify to redirect
                GenuinSDK.shared.userNotificationCenter(center, didReceive: response, withCompletionHandler: completionHandler)
                //notification notification
                if let rootVC = window?.rootViewController as? UIViewController{
                    GenuinSDK.shared.handleNotifications(viewController: rootVC)
                }
            }
        }
  }

func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void){
        let userInfo = notification.request.content.userInfo
        print("\(userInfo)")
        //mention design type for notification 
        completionHandler([.list, .badge, .sound])
    }

func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void){
        let userInfo = notification.request.content.userInfo
        
        GenuinSDK.shared.userNotificationCenter(center, willPresent: notification, withCompletionHandler: completionHandler)
        if let rootVC = window?.rootViewController as? UIViewController{
            GenuinSDK.shared.handleNotifications(viewController: rootVC)
        }
        
        //mention design type for notification 
        completionHandler([.list, .badge, .sound])
    }