@woosmap/react-native-plugin-geofencing 0.11.0-beta.2 → 0.11.0-beta.3

package/ios/WoosmapGeofenceService.swift

@@ -5,778 +5,893 @@
 //  Created by apple on 02/08/21.
 //
 
+import CoreLocation
 import Foundation
 import UIKit
-import CoreLocation
 import WoosmapGeofencing
 
 extension CLRegion {
-    var normalizeIdentifier: String {
-        get {
-            let idFormat = self.identifier
-            if(idFormat.contains("::")){
-                let seperated = idFormat.components(separatedBy: "@")
-                return seperated[1]
-            }
-            
-            return idFormat
-        }
+  var normalizeIdentifier: String {
+    let idFormat = self.identifier
+    if idFormat.contains("::") {
+      let seperated = idFormat.components(separatedBy: "@")
+      return seperated[1]
     }
+
+    return idFormat
+  }
 }
 
 /// Geofence services
 @objc(WoosmapGeofenceService) public class WoosmapGeofenceService: NSObject {
 
-    /// Share object for WoosmapGeofenceService
-    @objc static var shared: WoosmapGeofenceService? {
-        get {
-            return  _shared
-        }
-    }
+  /// Share object for WoosmapGeofenceService
+  @objc static var shared: WoosmapGeofenceService? {
+    return _shared
+  }
 
-
-    private static var _shared: WoosmapGeofenceService?
-    private var woosmapKey: String = ""
-    private var defaultProfile: String = ""
-    private var enableAirshipCallback: Bool = false
-    private let dataLocation = DataLocation()
-    private let dataPOI = DataPOI()
-    private let dataDistance = DataDistance()
-    private let dataRegion = DataRegion()
-    private let dataVisit = DataVisit()
-    private let airshipEvents = AirshipEvents()
-    private let marketingCloudEvents = MarketingCloudEvents()
-    private var protectedRegionSlot: Int {
-        get {
-            let defaults = UserDefaults.standard
-            let protectedSlot = defaults.integer(forKey: "WoosmapGeofenceService.protectedregionslot")
-            return  protectedSlot
-        }
-        set {
-            let defaults = UserDefaults.standard
-            defaults.set(newValue, forKey: "WoosmapGeofenceService.protectedregionslot")
-        }
+  private var _isServiceRunning: Bool = false
+  private static var _shared: WoosmapGeofenceService?
+  private var woosmapKey: String = ""
+  private var defaultProfile: String = ""
+  private var enableAirshipCallback: Bool = false
+  private let dataLocation = DataLocation()
+  private let dataPOI = DataPOI()
+  private let dataDistance = DataDistance()
+  private let dataRegion = DataRegion()
+  private let dataVisit = DataVisit()
+  private let airshipEvents = AirshipEvents()
+  private let marketingCloudEvents = MarketingCloudEvents()
+  private var sdkInstance: WoosmapGeofenceManager?
+  private var protectedRegionSlot: Int {
+    get {
+      let defaults = UserDefaults.standard
+      let protectedSlot = defaults.integer(
+        forKey: "WoosmapGeofenceService.protectedregionslot"
+      )
+      return protectedSlot
     }
-
-    private var defaultPOIRadius: String {
-        get {
-            let defaults = UserDefaults.standard
-            let defaultPOIRadius = defaults.string(forKey: "WoosmapGeofenceService.poiradius") ?? ""
-            return  defaultPOIRadius
-        }
-        set {
-            let defaults = UserDefaults.standard
-            defaults.set(newValue, forKey: "WoosmapGeofenceService.poiradius")
-        }
+    set {
+      let defaults = UserDefaults.standard
+      defaults.set(
+        newValue,
+        forKey: "WoosmapGeofenceService.protectedregionslot"
+      )
     }
+  }
 
-    /// Status of search api On/Off
-    @objc public var searchAPIRequestEnable: Bool {
-        get {
-            return  WoosmapGeofenceManager.shared.getSearchAPIRequestEnable()
-        }
-        set {
-            WoosmapGeofenceManager.shared.setSearchAPIRequestEnable(enable: newValue)
-
-        }
+  private var defaultPOIRadius: String {
+    get {
+      let defaults = UserDefaults.standard
+      let defaultPOIRadius =
+        defaults.string(forKey: "WoosmapGeofenceService.poiradius") ?? ""
+      return defaultPOIRadius
     }
-
-    /// Status of distance api On/Off
-    @objc public var distanceAPIRequestEnable: Bool {
-        get {
-            return  WoosmapGeofenceManager.shared.getDistanceAPIRequestEnable()
-        }
-        set {
-            WoosmapGeofenceManager.shared.setDistanceAPIRequestEnable(enable: newValue)
-
-        }
+    set {
+      let defaults = UserDefaults.standard
+      defaults.set(newValue, forKey: "WoosmapGeofenceService.poiradius")
     }
+  }
 
-    /// status of CreationRegionEnable. On/Off
-    @objc public var searchAPICreationRegionEnable: Bool {
-        get {
-            return  WoosmapGeofenceManager.shared.getSearchAPICreationRegionEnable()
-        }
-        set {
-            WoosmapGeofenceManager.shared.setSearchAPICreationRegionEnable(enable: newValue)
-
-        }
+  /// Status of search api On/Off
+  @objc public var searchAPIRequestEnable: Bool {
+    get {
+      return self.sdkInstance?.getSearchAPIRequestEnable() ?? false
     }
+    set {
+      self.sdkInstance?.setSearchAPIRequestEnable(enable: newValue)
 
-    /// Status of HighfrequencyLocation Mode. On/Off
-    @objc public var modeHighfrequencyLocation: Bool {
-        get {
-            return  WoosmapGeofenceManager.shared.getModeHighfrequencyLocation()
-        }
-        set {
-            WoosmapGeofenceManager.shared.setModeHighfrequencyLocation(enable: newValue)
-        }
     }
+  }
 
-    /// Status of tracking state. On/Off
-    @objc public var trackingState: Bool {
-        get {
-            return  WoosmapGeofenceManager.shared.getTrackingState()
-        }
-        set {
-            WoosmapGeofenceManager.shared.setTrackingEnable(enable: newValue)
-        }
+  /// Status of distance api On/Off
+  @objc public var distanceAPIRequestEnable: Bool {
+    get {
+      return self.sdkInstance?.getDistanceAPIRequestEnable() ?? false
     }
+    set {
+      self.sdkInstance?.setDistanceAPIRequestEnable(enable: newValue)
 
-    // MARK: Application events
-
-    /// This callback received when application become active
-    @objc func appDidBecomeActive() {
-      let status = CLLocationManager.authorizationStatus()
-      if status == .authorizedAlways || status == .authorizedWhenInUse {
-        DispatchQueue.main.async {
-          WoosmapGeofenceManager.shared.didBecomeActive()
-        }
-      }
     }
+  }
 
-    /// This callback recived when application enter in background mode
-    @objc func appDidEnterBackground() {
-        if CLLocationManager.authorizationStatus() != .notDetermined {
-            DispatchQueue.main.async {
-                WoosmapGeofenceManager.shared.startMonitoringInBackground()
-                WoosmapGeofenceManager.shared.getLocationService().stopUpdatingLocation()
-            }
-        }
+  /// status of CreationRegionEnable. On/Off
+  @objc public var searchAPICreationRegionEnable: Bool {
+    get {
+      return self.sdkInstance?.getSearchAPICreationRegionEnable() ?? false
     }
+    set {
+      self.sdkInstance?.setSearchAPICreationRegionEnable(enable: newValue)
 
-    /// This callback received when application is terminated
-    @objc func appWillTerminate() {
-        WoosmapGeofenceManager.shared.setModeHighfrequencyLocation(enable: false)
-    }
-    // MARK: Init
-
-    /// Initialize woosGeofencing service with key saved in previous call
-    private override init() {
-        super.init()
-        let defaults = UserDefaults.standard
-        let woosmapKey = defaults.string(forKey: "WoosmapGeofenceService.woosmap") ?? ""
-        let defaultProfile = defaults.string(forKey: "WoosmapGeofenceService.profile") ?? ""
-        self.enableAirshipCallback = defaults.bool(forKey: "WoosmapGeofenceService.AirshipCallbackEnable")
-        self.woosmapKey = woosmapKey
-        self.defaultProfile = defaultProfile
-
-        defaults.register(defaults: ["TrackingEnable": true,
-                                     "ModeHighfrequencyLocation": false,
-                                     "SearchAPIEnable": true,
-                                     "DistanceAPIEnable": true,
-                                     "searchAPICreationRegionEnable": true,
-                                     "WoosmapGeofenceService.protectedregionslot":0])
-
-        self.activateGeofenceService()
-
-    }
-
-    /// Initialize service with keys and profile
-    /// - Parameters:
-    ///   - woosmapKey: key use for woosmap service
-    ///   - configurationProfile: configuration profile
-    ///   - airshipEnable: To enable airship callback
-  private init(_ woosmapKey: String, _ configurationProfile: String, _ airshipEnable: Bool = false, _ protectedregionslot: Int = -1) {
-        super.init()
-        let defaults = UserDefaults.standard
-        if(woosmapKey == ""){
-            let lastSaved = defaults.string(forKey: "WoosmapGeofenceService.woosmap") ?? ""
-            self.woosmapKey = lastSaved
-        }
-        else{
-            self.woosmapKey = woosmapKey
-        }
-        if(configurationProfile == ""){
-            let lastSaved = defaults.string(forKey: "WoosmapGeofenceService.profile") ?? ""
-            self.defaultProfile = lastSaved
-        }
-        else {
-            self.defaultProfile = configurationProfile
-        }
-        self.enableAirshipCallback = airshipEnable
-    
-        if  protectedregionslot >= 0{
-          self.protectedRegionSlot = protectedregionslot
-        }
-        else{
-          //Use last configured value
-        }
-        // Save it on  preferences
-        
-        defaults.set(self.woosmapKey, forKey: "WoosmapGeofenceService.woosmap")
-        defaults.set(self.defaultProfile, forKey: "WoosmapGeofenceService.profile")
-        defaults.set(airshipEnable, forKey: "WoosmapGeofenceService.AirshipCallbackEnable")
-
-        defaults.register(defaults: ["TrackingEnable": true,
-                                     "ModeHighfrequencyLocation": false,
-                                     "SearchAPIEnable": true,
-                                     "DistanceAPIEnable": true,
-                                     "searchAPICreationRegionEnable": true])
-        self.activateGeofenceService()
-    }
-
-    /// Static instance of woosGeofencing service
-    /// - Parameters:
-    ///   - woosmapKey: key use for woosmap service
-    ///   - configurationProfile: configuration profile
-    @objc public static func setup(woosmapKey: String, configurationProfile: String,airshipTrackingEnable: Bool = false, protectedRegionSlot: Int = -1) {
-        let group = DispatchGroup()
-        group.enter()
-        DispatchQueue.main.async {
-            _shared = WoosmapGeofenceService.init( woosmapKey, configurationProfile,airshipTrackingEnable, protectedRegionSlot)
-            group.leave()
-        }
-        group.wait()
-        
     }
+  }
 
-    /// Creating instance for woosGeofencing service
-    @objc public static func setup() {
-        let group = DispatchGroup()
-        group.enter()
-        DispatchQueue.main.async {
-            _shared = WoosmapGeofenceService.init( "", "")
-            group.leave()
-        }
-        group.wait()
+  /// Status of HighfrequencyLocation Mode. On/Off
+  @objc public var modeHighfrequencyLocation: Bool {
+    get {
+      return self.sdkInstance?.getModeHighfrequencyLocation() ?? false
     }
-
-    /// Setting up woosmap key
-    /// - Parameter key: woosmap key
-    /// - Throws: WoosGeofenceError incase of no key pass or empty
-    public func setWoosmapAPIKey(key: String) throws {
-        if key.trimmingCharacters(in: .whitespacesAndNewlines) == "" {
-            throw WoosGeofenceError(WoosmapGeofenceMessage.invalidWoosmapKey)
-        } else {
-            self.woosmapKey = key
-            let group = DispatchGroup()
-            group.enter()
-            DispatchQueue.main.async {
-                WoosmapGeofenceManager.shared.setWoosmapAPIKey(key: self.woosmapKey)
-                group.leave()
-            }
-            group.wait()
-            let defaults = UserDefaults.standard
-            defaults.set(key, forKey: "WoosmapGeofenceService.woosmap")
-        }
+    set {
+      self.sdkInstance?.setModeHighfrequencyLocation(enable: newValue)
     }
+  }
 
-    /// Change tracking mode with new profile
-    /// - Parameter profile: profile for tracking.   liveTracking / passiveTracking / visitsTracking
-    /// - Throws: in case of wrong profile provided it return error invalidProfile
-    public func startTracking(profile: String) throws {
-        if let savedProfile = ConfigurationProfile(rawValue: profile) {
-            let group = DispatchGroup()
-            group.enter()
-            DispatchQueue.main.async {
-                WoosmapGeofenceManager.shared.startTracking(configurationProfile: savedProfile)
-                group.leave()
-            }
-            group.wait()
-            self.defaultProfile = profile
-            let defaults = UserDefaults.standard
-            defaults.set(profile, forKey: "WoosmapGeofenceService.profile")
-
-        } else {
-            self.defaultProfile = ""
-            let defaults = UserDefaults.standard
-            defaults.set(self.defaultProfile, forKey: "WoosmapGeofenceService.profile")
-            throw WoosGeofenceError(WoosmapGeofenceMessage.invalidProfile)
-        }
-//        print ("Highfrequency \(WoosmapGeofenceManager.shared.getModeHighfrequencyLocation()) , TrackingState \(WoosmapGeofenceManager.shared.getTrackingState()) ")
-    }
-
-    /// Stop tracking
-    public func stopTracking() {
-        WoosmapGeofenceManager.shared.stopTracking()
-    }
-
-    /// activating WoosmapGeofencing with default parameters
-    private func activateGeofenceService() {
-        let status = CLLocationManager.authorizationStatus()
-        // Set private Woosmap key API
-        WoosmapGeofenceManager.shared.setWoosmapAPIKey(key: woosmapKey)
-        #if DEBUG
-        WoosmapGeofenceManager.shared.logLevel = .trace
-        #else
-        WoosmapGeofenceManager.shared.logLevel = .info
-        #endif
-        // Procteted slots
-        try? WoosmapGeofenceManager.shared.setProtectedRegionSlot(self.protectedRegionSlot)
-        // Set delegate of protocol Location, POI and Distance
-        WoosmapGeofenceManager.shared.getLocationService().locationServiceDelegate = dataLocation
-        WoosmapGeofenceManager.shared.getLocationService().searchAPIDataDelegate = dataPOI
-        WoosmapGeofenceManager.shared.getLocationService().distanceAPIDataDelegate = dataDistance
-        WoosmapGeofenceManager.shared.getLocationService().regionDelegate = dataRegion
-
-        // Enable Visit and set delegate of protocol Visit
-        WoosmapGeofenceManager.shared.getLocationService().visitDelegate = dataVisit
-        if(self.enableAirshipCallback){
-            // Set delagate for Airship Cloud
-            WoosmapGeofenceManager.shared.getLocationService().airshipEventsDelegate = airshipEvents
-        }
-        
-        // Set delagate for Marketing Cloud
-        WoosmapGeofenceManager.shared.getLocationService().marketingCloudEventsDelegate = marketingCloudEvents
-        if defaultPOIRadius != "" {
-            WoosmapGeofenceManager.shared.setPoiRadius(radius: formatedRadius(radius: defaultPOIRadius))
-        }
-
-        if status == .authorizedAlways || status == .authorizedWhenInUse {
-          if let savedProfile = ConfigurationProfile(rawValue: defaultProfile) {
-            if Thread.isMainThread {
-              WoosmapGeofenceManager.shared.startTracking(configurationProfile: savedProfile)
-            } else {
-              DispatchQueue.main.async {
-                WoosmapGeofenceManager.shared.startTracking(configurationProfile: savedProfile)
-              }
-            }
-          }
-          // Check if the authorization Status of location Manager
-          if CLLocationManager.authorizationStatus() != .notDetermined {
-            WoosmapGeofenceManager.shared.startMonitoringInBackground()
-          }
-        }
-
-        NotificationCenter.default.addObserver(self,
-                                               selector: #selector(appDidBecomeActive),
-                                               name: UIApplication.didBecomeActiveNotification,
-                                               object: nil)
-
-        NotificationCenter.default.addObserver(self, selector: #selector(appDidEnterBackground), name: UIApplication.didEnterBackgroundNotification, object: nil)
-
-        NotificationCenter.default.addObserver(self, selector: #selector(appWillTerminate), name: UIApplication.willTerminateNotification, object: nil)
-
-        // MARK: Only  for testing
-//          self.searchAPIRequestEnable = true
-//          self.distanceAPIRequestEnable = true
-//          self.searchAPICreationRegionEnable = true
-//        print ("\(WoosmapGeofenceManager.shared.getModeHighfrequencyLocation()) \(WoosmapGeofenceManager.shared.getTrackingState()) ")
+  /// Status of tracking state. On/Off
+  @objc public var trackingState: Bool {
+    get {
+      return self.sdkInstance?.getTrackingState() ?? false
     }
-
-    /// Adding  new  region
-    /// - Parameters:
-    ///   - identifier: Region id
-    ///   - center: geoLocation point
-    ///   - radius: radius of region
-    ///   - type: String circle/isochrone
-    /// - Returns: Status for reagion created or not and new region id from system
-    public func addRegion(identifier: String, center: CLLocationCoordinate2D, radius: Int, type: String) -> (isCreate: Bool, identifier: String) {
-        return WoosmapGeofenceManager.shared.locationService.addRegion(identifier: identifier, center: center, radius: radius, type:type)
+    set {
+      self.sdkInstance?.setTrackingEnable(enable: newValue)
     }
+  }
+
+  // MARK: Application events
 
-    /// Remove region from system
-    /// - Parameter center: geoLocation point of region
-    public func removeRegion(center: CLLocationCoordinate2D) {
-        return WoosmapGeofenceManager.shared.locationService.removeRegion(center: center)
+  /// This callback received when application become active
+  @objc func appDidBecomeActive() {
+    let status = CLLocationManager().authorizationStatus
+    if status == .authorizedAlways || status == .authorizedWhenInUse {
+      DispatchQueue.main.async {
+        self.sdkInstance?.didBecomeActive()
+      }
     }
+  }
 
-    /// Remove region from system
-    /// - Parameter identifier: region id assined for region
-    public func removeRegion(identifier: String) {
-        if let regionInfo = getRegions(id: identifier){
-            if(regionInfo.type == "circle"){
-                WoosmapGeofenceManager.shared.locationService.removeRegion(identifier: regionInfo.identifier)
-            }
-            else{
-                RegionIsochrones.removeRegionIsochrone(id: regionInfo.identifier)
+  /// This callback recived when application enter in background mode
+  @objc func appDidEnterBackground() {
+    if CLLocationManager().authorizationStatus != .notDetermined {
+      DispatchQueue.main.async {
+        self.sdkInstance?.startMonitoringInBackground()
+        self.sdkInstance?.getLocationService().stopUpdatingLocation()
+      }
+    }
+  }
+
+  /// This callback received when application is terminated
+  @objc func appWillTerminate() {
+    self.sdkInstance?.setModeHighfrequencyLocation(enable: false)
+  }
+  // MARK: Init
+
+  /// Initialize woosGeofencing service with key saved in previous call
+  @MainActor
+  private override init() {
+    super.init()
+    let defaults = UserDefaults.standard
+    let woosmapKey =
+      defaults.string(forKey: "WoosmapGeofenceService.woosmap") ?? ""
+    let defaultProfile =
+      defaults.string(forKey: "WoosmapGeofenceService.profile") ?? ""
+    self.enableAirshipCallback = defaults.bool(
+      forKey: "WoosmapGeofenceService.AirshipCallbackEnable"
+    )
+    self.woosmapKey = woosmapKey
+    self.defaultProfile = defaultProfile
+
+    defaults.register(defaults: [
+      "TrackingEnable": true,
+      "ModeHighfrequencyLocation": false,
+      "SearchAPIEnable": true,
+      "DistanceAPIEnable": true,
+      "searchAPICreationRegionEnable": true,
+      "WoosmapGeofenceService.protectedregionslot": 0,
+    ])
+    self.sdkInstance = WoosmapGeofenceManager.shared
+    self.activateGeofenceService()
+  }
+
+  /// Initialize service with keys and profile
+  /// - Parameters:
+  ///   - woosmapKey: key use for woosmap service
+  ///   - configurationProfile: configuration profile
+  ///   - airshipEnable: To enable airship callback
+  @MainActor
+  private init(
+    _ woosmapKey: String,
+    _ configurationProfile: String,
+    _ airshipEnable: Bool = false,
+    _ protectedregionslot: Int = -1
+  ) {
+    super.init()
+    let defaults = UserDefaults.standard
+    if woosmapKey == "" {
+      let lastSaved =
+        defaults.string(forKey: "WoosmapGeofenceService.woosmap") ?? ""
+      self.woosmapKey = lastSaved
+    } else {
+      self.woosmapKey = woosmapKey
+    }
+    if configurationProfile == "" {
+      let lastSaved =
+        defaults.string(forKey: "WoosmapGeofenceService.profile") ?? ""
+      self.defaultProfile = lastSaved
+    } else {
+      self.defaultProfile = configurationProfile
+    }
+    self.enableAirshipCallback = airshipEnable
+
+    if protectedregionslot >= 0 {
+      self.protectedRegionSlot = protectedregionslot
+    } else {
+      //Use last configured value
+    }
+    // Save it on  preferences
+
+    defaults.set(self.woosmapKey, forKey: "WoosmapGeofenceService.woosmap")
+    defaults.set(self.defaultProfile, forKey: "WoosmapGeofenceService.profile")
+    defaults.set(
+      airshipEnable,
+      forKey: "WoosmapGeofenceService.AirshipCallbackEnable"
+    )
+
+    defaults.register(defaults: [
+      "TrackingEnable": true,
+      "ModeHighfrequencyLocation": false,
+      "SearchAPIEnable": true,
+      "DistanceAPIEnable": true,
+      "searchAPICreationRegionEnable": true,
+    ])
+    self.sdkInstance = WoosmapGeofenceManager.shared
+    self.activateGeofenceService()
+
+  }
+
+  /// Static instance of woosGeofencing service
+  /// - Parameters:
+  ///   - woosmapKey: key use for woosmap service
+  ///   - configurationProfile: configuration profile
+  @objc public static func setup(
+    woosmapKey: String,
+    configurationProfile: String,
+    airshipTrackingEnable: Bool = false,
+    protectedRegionSlot: Int = -1
+  ) {
+    DispatchQueue.main.sync {
+      _shared = WoosmapGeofenceService.init(
+        woosmapKey,
+        configurationProfile,
+        airshipTrackingEnable,
+        protectedRegionSlot
+      )
+    }
+  }
+
+  /// Creating instance for woosGeofencing service
+  @objc public static func setup() {
+    DispatchQueue.main.sync {
+      _shared = WoosmapGeofenceService.init("", "")
+    }
+  }
+
+  /// Setting up woosmap key
+  /// - Parameter key: woosmap key
+  /// - Throws: WoosGeofenceError incase of no key pass or empty
+  /// @MainActor
+  public func setWoosmapAPIKey(key: String) throws {
+    if key.trimmingCharacters(in: .whitespacesAndNewlines) == "" {
+      throw WoosGeofenceError(WoosmapGeofenceMessage.invalidWoosmapKey)
+    } else {
+      self.woosmapKey = key
+      self.sdkInstance?.setWoosmapAPIKey(key: self.woosmapKey)
+      let defaults = UserDefaults.standard
+      defaults.set(key, forKey: "WoosmapGeofenceService.woosmap")
+    }
+  }
+
+  /// Change tracking mode with new profile
+  /// - Parameter profile: profile for tracking.   liveTracking / passiveTracking / visitsTracking
+  /// - Throws: in case of wrong profile provided it return error invalidProfile
+  public func startTracking(profile: String) throws {
+    if let savedProfile = ConfigurationProfile(rawValue: profile) {
+      DispatchQueue.main.sync {
+        self.sdkInstance?.startTracking(configurationProfile: savedProfile)
+      }
+      self.defaultProfile = profile
+      let defaults = UserDefaults.standard
+      defaults.set(profile, forKey: "WoosmapGeofenceService.profile")
+
+    } else {
+      self.defaultProfile = ""
+      let defaults = UserDefaults.standard
+      defaults.set(
+        self.defaultProfile,
+        forKey: "WoosmapGeofenceService.profile"
+      )
+      throw WoosGeofenceError(WoosmapGeofenceMessage.invalidProfile)
+    }
+    //        print ("Highfrequency \(self.sdkInstance?.getModeHighfrequencyLocation()) , TrackingState \(self.sdkInstance?.getTrackingState()) ")
+  }
+
+  /// Stop tracking
+  public func stopTracking() {
+    self.sdkInstance?.stopTracking()
+    _isServiceRunning = false
+  }
+
+  /// activating WoosmapGeofencing with default parameters
+  private func activateGeofenceService() {
+    let status = CLLocationManager().authorizationStatus
+    // Set private Woosmap key API
+    sdkInstance?.setWoosmapAPIKey(key: woosmapKey)
+    #if DEBUG
+      self.sdkInstance?.logLevel = .trace
+    #else
+      self.sdkInstance?.logLevel = .info
+    #endif
+    // Procteted slots
+    try? self.sdkInstance?.setProtectedRegionSlot(self.protectedRegionSlot)
+    // Set delegate of protocol Location, POI and Distance
+    self.sdkInstance?.getLocationService().locationServiceDelegate =
+      dataLocation
+    self.sdkInstance?.getLocationService().searchAPIDataDelegate = dataPOI
+    self.sdkInstance?.getLocationService().distanceAPIDataDelegate =
+      dataDistance
+    self.sdkInstance?.getLocationService().regionDelegate = dataRegion
+
+    // Enable Visit and set delegate of protocol Visit
+    self.sdkInstance?.getLocationService().visitDelegate = dataVisit
+    if self.enableAirshipCallback {
+      // Set delagate for Airship Cloud
+      self.sdkInstance?.getLocationService().airshipEventsDelegate =
+        airshipEvents
+    }
+
+    // Set delagate for Marketing Cloud
+    self.sdkInstance?.getLocationService().marketingCloudEventsDelegate =
+      marketingCloudEvents
+    if defaultPOIRadius != "" {
+      self.sdkInstance?.setPoiRadius(
+        radius: formatedRadius(radius: defaultPOIRadius)
+      )
+    }
+
+    if status == .authorizedAlways || status == .authorizedWhenInUse {
+      if let savedProfile = ConfigurationProfile(rawValue: defaultProfile) {
+        self.sdkInstance?.startTracking(configurationProfile: savedProfile)
+        _isServiceRunning = true
+      } else if defaultProfile != "" {
+        let profilelocation = defaultProfile.split(separator: ":")
+        if profilelocation.count == 2 {
+          let pURL = getCustomProfileURL(
+            mode: String(profilelocation[0]),
+            source: String(profilelocation[1])
+          )
+          if pURL != "" {
+            let (status, _) = self.sdkInstance!.startCustomTracking(url: pURL)
+            if status {
+              _isServiceRunning = true
             }
+          }
         }
+      }
+      // Check if the authorization Status of location Manager
+      if CLLocationManager().authorizationStatus != .notDetermined {
+        self.sdkInstance?.startMonitoringInBackground()
+      }
     }
 
-    /// Get location information for geopoint from woos system
-    /// - Parameters:
-    ///   - location: geopoint for location
-    ///   - locationId: id recorded for that location
-    public func searchAPIRequest(location: CLLocationCoordinate2D, locationId: String = "") {
-        // TODO: Missing implementation
-        //WoosmapGeofenceManager.shared.getLocationService().searchAPIRequest(location: CLLocation.init(latitude: location.latitude, longitude: location.longitude), locationId: locationId)
-    }
-// TODO: Missing implementation
-//    /// Get distnce between location point and origin
-//    /// - Parameters:
-//    ///   - locationOrigin: origin geolocation
-//    ///   - coordinatesDest: destination  geolocation
-//    ///   - locationId:  id recorded for that location
-//    public func distanceAPIRequest(locationOrigin: CLLocationCoordinate2D, coordinatesDest: CLLocation, locationId: String = "") {
-//        let latDest = coordinatesDest.coordinate.latitude
-//        let lngDest = coordinatesDest.coordinate.longitude
-//        let originLocation = CLLocation.init(latitude: locationOrigin.latitude,
-//                                             longitude: locationOrigin.longitude)
-//        WoosmapGeofenceManager.shared.getLocationService().distanceAPIRequest(locationOrigin: originLocation,
-//                                                                         coordinatesDest: [(latDest, lngDest)],
-//                                                                         locationId: locationId)
-//    }
-//
-//    /// Get distnce between location point and origin
-//    /// - Parameters:
-//    ///   - locationOrigin: origin geolocation
-//    ///   - locationId: id recorded for that location
-//    public func distanceAPIRequest(locationOrigin: CLLocationCoordinate2D, locationId: String = "") {
-//        if let poi = DataPOI().getPOIbyLocationID(locationId: locationId) {
-//            let latDest = poi.latitude
-//            let lngDest = poi.longitude
-//            let originLocation = CLLocation.init(latitude: locationOrigin.latitude,
-//                                                 longitude: locationOrigin.longitude)
-//            WoosmapGeofenceManager.shared.getLocationService().distanceAPIRequest(locationOrigin: originLocation,
-//                                                                             coordinatesDest: [(latDest, lngDest)],
-//                                                                             locationId: locationId)
-//        }
-//
-//    }
-
-    /// List all locations capture by system
-    /// - Returns: Array of location captured
-    public func  getLocations() -> [Location] {
-        let locations = DataLocation().readLocations()
-        return locations
-    }
-    
-    public func  getLocations(id:String) -> Location? {
-        let locations = DataLocation().readLocations(id: id)
-        return locations
-    }
-
-    /// List all POIs  capture by system
-    /// - Returns: Array of POIs
-    public func  getPOIs() -> [POI] {
-        let poi = DataPOI().readPOI()
-        return poi
-    }
-    
-    /// List all POIs  capture by system
-    /// - Returns: Array of POIs
-    public func  getPOIs(id:String) -> POI? {
-        let poi = DataPOI().readPOI(id: id)
-        return poi
-    }
-    
-    ///Fetch beacon info from storage
-    /// - Returns: Array of Beacon POIs
-    public func getIndoorBeacons(id:String?) -> [IndoorBeacon]? {
-        let info = DataPOI().readIndoorBeaconPOI(venueid: id)
-        return info
-    }
-  
-    ///Delete Becaon info from storage
-    public func deleteIndoorBeacons() {
-        IndoorBeacons.deleteAll()
-    }
-    
-
-    /// List all intrest zone capture by system
-    /// - Returns: Array of zones
-    public func  getZOIs() -> [ZOI] {
-        let zoi = DataZOI().readZOIs()
-        return zoi
-    }
-
-    /// List all region capture by system
-    /// - Returns: Array of regions
-    public func  getRegions() -> [Region] {
-        var regions = DataRegion().readRegions()
-        let IsochroneRegion = DataRegion().readIsochroneRegions()
-        IsochroneRegion.forEach { item in
-            let customRegion = Region(latitude: item.latitude, longitude: item.latitude, radius: Double(item.radius), dateCaptured: Date(), identifier: item.identifier ?? "-", didEnter: false, fromPositionDetection: false, eventName: "")
-            customRegion.type = item.type
-            regions.append(customRegion)
-        }
-        
-        if let locationService = WoosmapGeofenceManager.shared.locationService{
-            if let customRegion = locationService.locationManager?.monitoredRegions{
-                customRegion.forEach { item in
-                    if(locationService.getRegionType(identifier: item.normalizeIdentifier) == RegionType.custom){
-                        
-                        let customRegionItem = Region(latitude: 0, longitude: 0, radius: 0, dateCaptured: Date(), identifier: item.normalizeIdentifier , didEnter: false, fromPositionDetection: false, eventName: "")
-                        
-                        customRegionItem.identifier = item.normalizeIdentifier
-                        if let circleRegion = item as? CLCircularRegion{
-                            customRegionItem.latitude = circleRegion.center.latitude
-                            customRegionItem.longitude = circleRegion.center.longitude
-                            customRegionItem.radius = circleRegion.radius
-                            customRegionItem.type = "circle"
-                        }
-                        regions.append(customRegionItem)
-                    }
-                }
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(appDidBecomeActive),
+      name: UIApplication.didBecomeActiveNotification,
+      object: nil
+    )
+
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(appDidEnterBackground),
+      name: UIApplication.didEnterBackgroundNotification,
+      object: nil
+    )
+
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(appWillTerminate),
+      name: UIApplication.willTerminateNotification,
+      object: nil
+    )
+
+    // MARK: Only  for testing
+    //          self.searchAPIRequestEnable = true
+    //          self.distanceAPIRequestEnable = true
+    //          self.searchAPICreationRegionEnable = true
+    //        print ("\(self.sdkInstance?.getModeHighfrequencyLocation()) \(self.sdkInstance?.getTrackingState()) ")
+  }
+
+  /// Adding  new  region
+  /// - Parameters:
+  ///   - identifier: Region id
+  ///   - center: geoLocation point
+  ///   - radius: radius of region
+  ///   - type: String circle/isochrone
+  /// - Returns: Status for reagion created or not and new region id from system
+  public func addRegion(
+    identifier: String,
+    center: CLLocationCoordinate2D,
+    radius: Int,
+    type: String
+  ) -> (isCreate: Bool, identifier: String) {
+    return self.sdkInstance?.locationService.addRegion(
+      identifier: identifier,
+      center: center,
+      radius: radius,
+      type: type
+    ) ?? (false, "")
+  }
+
+  /// Remove region from system
+  /// - Parameter center: geoLocation point of region
+  public func removeRegion(center: CLLocationCoordinate2D) {
+    self.sdkInstance?.locationService.removeRegion(center: center)
+  }
+
+  /// Remove region from system
+  /// - Parameter identifier: region id assined for region
+  public func removeRegion(identifier: String) {
+    if let regionInfo = getRegions(id: identifier) {
+      if regionInfo.type == "circle" {
+        self.sdkInstance?.locationService.removeRegion(
+          identifier: regionInfo.identifier
+        )
+      } else {
+        RegionIsochrones.removeRegionIsochrone(id: regionInfo.identifier)
+      }
+    }
+  }
+
+  /// Get location information for geopoint from woos system
+  /// - Parameters:
+  ///   - location: geopoint for location
+  ///   - locationId: id recorded for that location
+  public func searchAPIRequest(
+    location: CLLocationCoordinate2D,
+    locationId: String = ""
+  ) {
+    // TODO: Missing implementation
+    //self.sdkInstance?.getLocationService().searchAPIRequest(location: CLLocation.init(latitude: location.latitude, longitude: location.longitude), locationId: locationId)
+  }
+  // TODO: Missing implementation
+  //    /// Get distnce between location point and origin
+  //    /// - Parameters:
+  //    ///   - locationOrigin: origin geolocation
+  //    ///   - coordinatesDest: destination  geolocation
+  //    ///   - locationId:  id recorded for that location
+  //    public func distanceAPIRequest(locationOrigin: CLLocationCoordinate2D, coordinatesDest: CLLocation, locationId: String = "") {
+  //        let latDest = coordinatesDest.coordinate.latitude
+  //        let lngDest = coordinatesDest.coordinate.longitude
+  //        let originLocation = CLLocation.init(latitude: locationOrigin.latitude,
+  //                                             longitude: locationOrigin.longitude)
+  //        self.sdkInstance?.getLocationService().distanceAPIRequest(locationOrigin: originLocation,
+  //                                                                         coordinatesDest: [(latDest, lngDest)],
+  //                                                                         locationId: locationId)
+  //    }
+  //
+  //    /// Get distnce between location point and origin
+  //    /// - Parameters:
+  //    ///   - locationOrigin: origin geolocation
+  //    ///   - locationId: id recorded for that location
+  //    public func distanceAPIRequest(locationOrigin: CLLocationCoordinate2D, locationId: String = "") {
+  //        if let poi = DataPOI().getPOIbyLocationID(locationId: locationId) {
+  //            let latDest = poi.latitude
+  //            let lngDest = poi.longitude
+  //            let originLocation = CLLocation.init(latitude: locationOrigin.latitude,
+  //                                                 longitude: locationOrigin.longitude)
+  //            self.sdkInstance?.getLocationService().distanceAPIRequest(locationOrigin: originLocation,
+  //                                                                             coordinatesDest: [(latDest, lngDest)],
+  //                                                                             locationId: locationId)
+  //        }
+  //
+  //    }
+
+  /// List all locations capture by system
+  /// - Returns: Array of location captured
+  public func getLocations() -> [Location] {
+    let locations = DataLocation().readLocations()
+    return locations
+  }
+
+  public func getLocations(id: String) -> Location? {
+    let locations = DataLocation().readLocations(id: id)
+    return locations
+  }
+
+  /// List all POIs  capture by system
+  /// - Returns: Array of POIs
+  public func getPOIs() -> [POI] {
+    let poi = DataPOI().readPOI()
+    return poi
+  }
+
+  /// List all POIs  capture by system
+  /// - Returns: Array of POIs
+  public func getPOIs(id: String) -> POI? {
+    let poi = DataPOI().readPOI(id: id)
+    return poi
+  }
+
+  ///Fetch beacon info from storage
+  /// - Returns: Array of Beacon POIs
+  public func getIndoorBeacons(id: String?) -> [IndoorBeacon]? {
+    let info = DataPOI().readIndoorBeaconPOI(venueid: id)
+    return info
+  }
+
+  ///Delete Becaon info from storage
+  public func deleteIndoorBeacons() {
+    IndoorBeacons.deleteAll()
+  }
+
+  /// List all intrest zone capture by system
+  /// - Returns: Array of zones
+  public func getZOIs() -> [ZOI] {
+    let zoi = DataZOI().readZOIs()
+    return zoi
+  }
+
+  /// List all region capture by system
+  /// - Returns: Array of regions
+  public func getRegions() -> [Region] {
+    var regions = DataRegion().readRegions()
+    let IsochroneRegion = DataRegion().readIsochroneRegions()
+    IsochroneRegion.forEach { item in
+      let customRegion = Region(
+        latitude: item.latitude,
+        longitude: item.latitude,
+        radius: Double(item.radius),
+        dateCaptured: Date(),
+        identifier: item.identifier ?? "-",
+        didEnter: false,
+        fromPositionDetection: false,
+        eventName: ""
+      )
+      customRegion.type = item.type
+      regions.append(customRegion)
+    }
+
+    if let locationService = self.sdkInstance?.locationService {
+      if let customRegion = locationService.locationManager?.monitoredRegions {
+        customRegion.forEach { item in
+          if locationService.getRegionType(identifier: item.normalizeIdentifier)
+            == RegionType.custom
+          {
+
+            let customRegionItem = Region(
+              latitude: 0,
+              longitude: 0,
+              radius: 0,
+              dateCaptured: Date(),
+              identifier: item.normalizeIdentifier,
+              didEnter: false,
+              fromPositionDetection: false,
+              eventName: ""
+            )
+
+            customRegionItem.identifier = item.normalizeIdentifier
+            if let circleRegion = item as? CLCircularRegion {
+              customRegionItem.latitude = circleRegion.center.latitude
+              customRegionItem.longitude = circleRegion.center.longitude
+              customRegionItem.radius = circleRegion.radius
+              customRegionItem.type = "circle"
             }
+            regions.append(customRegionItem)
+          }
         }
-        return regions
-    }
-    
-    
-    /// Return region info
-    /// - Parameter id: region id
-    /// - Returns: Region
-    public func  getRegions(id:String) -> Region? {
-        var regionId = id
-        if let locationService = WoosmapGeofenceManager.shared.locationService{
-            var regionType = locationService.getRegionType(identifier: id)
-            if(regionType == .none){
-                regionId = "custom<id>\(regionId)"
-            }
-            regionType = locationService.getRegionType(identifier: regionId)
-            if( regionType == RegionType.custom){ //Custom region
-                if let customRegions = locationService.locationManager?.monitoredRegions{
-                    if let watchRegion = customRegions.first(where: { item in
-                        return item.normalizeIdentifier == regionId
-                    }){
-                        let customRegion = Region(latitude: 0, longitude: 0, radius: 0, dateCaptured: Date(), identifier: "-", didEnter: false, fromPositionDetection: false, eventName: "")
-                        
-                        customRegion.identifier = watchRegion.normalizeIdentifier
-                        if let circleRegion = watchRegion as? CLCircularRegion{
-                            customRegion.latitude = circleRegion.center.latitude
-                            customRegion.longitude = circleRegion.center.longitude
-                            customRegion.radius = circleRegion.radius
-                            customRegion.type = "circle"
-                        }
-                        return customRegion
-                    }
-                }
+      }
+    }
+    return regions
+  }
+
+  /// Return region info
+  /// - Parameter id: region id
+  /// - Returns: Region
+  public func getRegions(id: String) -> Region? {
+    var regionId = id
+    if let locationService = self.sdkInstance?.locationService {
+      var regionType = locationService.getRegionType(identifier: id)
+      if regionType == .none {
+        regionId = "custom<id>\(regionId)"
+      }
+      regionType = locationService.getRegionType(identifier: regionId)
+      if regionType == RegionType.custom {  //Custom region
+        if let customRegions = locationService.locationManager?.monitoredRegions
+        {
+          if let watchRegion = customRegions.first(where: { item in
+            return item.normalizeIdentifier == regionId
+          }) {
+            let customRegion = Region(
+              latitude: 0,
+              longitude: 0,
+              radius: 0,
+              dateCaptured: Date(),
+              identifier: "-",
+              didEnter: false,
+              fromPositionDetection: false,
+              eventName: ""
+            )
+
+            customRegion.identifier = watchRegion.normalizeIdentifier
+            if let circleRegion = watchRegion as? CLCircularRegion {
+              customRegion.latitude = circleRegion.center.latitude
+              customRegion.longitude = circleRegion.center.longitude
+              customRegion.radius = circleRegion.radius
+              customRegion.type = "circle"
             }
-        }
-        
-        if let  regions = DataRegion().readRegions(id: id){ //POI
-            return regions
-        }
-        if let  regions = DataRegion().readIsochroneRegions(id: id){ //Isochrone Zone
-            
-            let customRegion = Region(latitude: 0, longitude: 0, radius: 0, dateCaptured: Date(), identifier: "-", didEnter: false, fromPositionDetection: false, eventName: "")
-            customRegion.identifier = regions.identifier ?? "-"
-            customRegion.latitude = regions.latitude
-            customRegion.longitude = regions.longitude
-            customRegion.radius = Double(regions.radius)
-            customRegion.type = regions.type
             return customRegion
+          }
         }
-        
-        return nil
-    }
-    
-    /// List all visits capture by system
-    /// - Returns: Array of visits
-    public func  getVisits() -> [Visit] {
-        let visit = DataVisit().readVisits()
-        return visit
-    }
-
-    /// Delete all visits from system
-    public func  deleteVisits() {
-        DataVisit().eraseVisits()
-    }
-
-    /// Delete all zois form system
-    public func  deleteZoi() {
-        DataZOI().eraseZOIs()
-    }
-    /// Delete all POI from system
-    public func  deletePOI() {
-        DataPOI().erasePOI()
-    }
-
-    /// Delete all location from system
-    public func  deleteAllLocations() {
-        DataLocation().eraseLocations()
-        // Native SDK Works independently
-        // DataPOI().erasePOI()
+      }
     }
 
-    /// Delete all ZOI regions
-    public func  deleteAllZoiRegion() {
-        WoosmapGeofenceManager.shared.locationService.removeRegions(type: RegionType.custom)
+    if let regions = DataRegion().readRegions(id: id) {  //POI
+      return regions
+    }
+    if let regions = DataRegion().readIsochroneRegions(id: id) {  //Isochrone Zone
+
+      let customRegion = Region(
+        latitude: 0,
+        longitude: 0,
+        radius: 0,
+        dateCaptured: Date(),
+        identifier: "-",
+        didEnter: false,
+        fromPositionDetection: false,
+        eventName: ""
+      )
+      customRegion.identifier = regions.identifier ?? "-"
+      customRegion.latitude = regions.latitude
+      customRegion.longitude = regions.longitude
+      customRegion.radius = Double(regions.radius)
+      customRegion.type = regions.type
+      return customRegion
+    }
+
+    return nil
+  }
+
+  /// List all visits capture by system
+  /// - Returns: Array of visits
+  public func getVisits() -> [Visit] {
+    let visit = DataVisit().readVisits()
+    return visit
+  }
+
+  /// Delete all visits from system
+  public func deleteVisits() {
+    DataVisit().eraseVisits()
+  }
+
+  /// Delete all zois form system
+  public func deleteZoi() {
+    DataZOI().eraseZOIs()
+  }
+  /// Delete all POI from system
+  public func deletePOI() {
+    DataPOI().erasePOI()
+  }
+
+  /// Delete all location from system
+  public func deleteAllLocations() {
+    DataLocation().eraseLocations()
+    // Native SDK Works independently
+    // DataPOI().erasePOI()
+  }
+
+  /// Delete all ZOI regions
+  public func deleteAllZoiRegion() {
+    self.sdkInstance?.locationService.removeRegions(type: RegionType.custom)
+  }
+
+  /// Delete all POI regions
+  public func deleteAllPoiRegion() {
+    self.sdkInstance?.locationService.removeRegions(type: RegionType.poi)
+  }
+
+  /// Delete regions by id
+  /// - Parameter id: region id
+  /// - Returns: deleted
+  public func deleteRegions(id: String) throws {
+    if let regionInfo = getRegions(id: id) {
+      if regionInfo.type == "circle" {
+        self.sdkInstance?.locationService.removeRegion(
+          identifier: regionInfo.identifier
+        )
+      } else {
+        DataRegion().eraseRegions(id: regionInfo.identifier)
+      }
+    } else {
+      throw WoosGeofenceError(WoosmapGeofenceMessage.regionid_notexist)
+    }
+
+  }
+
+  /// Delete all regions
+  public func deleteAllRegion() {
+    DataRegion().eraseRegions()
+    self.sdkInstance?.locationService.removeRegions(type: RegionType.none)
+  }
+
+  @objc static public func mockdata() {
+    if WoosmapGeofenceService.shared == nil {
+      WoosmapGeofenceService.setup()
+    }
+    MockDataVisit().mockVisitData()
+  }
+
+  /// Setting up SFMCCredentials
+  /// - Parameter credentials: Key/value pair for credentials settings
+  /// - Throws: Error for required keys
+  @objc public func setSFMCCredentials(credentials: [String: String]) throws {
+    var requiredSatisfied = true
+    if credentials["authenticationBaseURI"] == nil {
+      requiredSatisfied = false
+      throw WoosGeofenceError(
+        WoosmapGeofenceMessage.required_authenticationBaseURI
+      )
+    } else if credentials["restBaseURI"] == nil {
+      requiredSatisfied = false
+      throw WoosGeofenceError(WoosmapGeofenceMessage.required_restBaseURI)
+    } else if credentials["client_id"] == nil {
+      requiredSatisfied = false
+      throw WoosGeofenceError(WoosmapGeofenceMessage.required_client_id)
+    } else if credentials["client_secret"] == nil {
+      requiredSatisfied = false
+      throw WoosGeofenceError(WoosmapGeofenceMessage.required_client_secret)
+    } else if credentials["contactKey"] == nil {
+      requiredSatisfied = false
+      throw WoosGeofenceError(WoosmapGeofenceMessage.required_contactKey)
+    }
+    if requiredSatisfied {
+      self.sdkInstance?.setSFMCCredentials(credentials: credentials)
+    }
+  }
+
+  /// Setting POI redious
+  /// - Parameter radius: integer or string for radius  value
+  public func setPoiRadius(radius: String) {
+    self.defaultPOIRadius = radius
+    self.sdkInstance?.setPoiRadius(radius: formatedRadius(radius: radius))
+  }
+
+  /// Format String value to proper datatype
+  /// - Parameter radius: radius of POI
+  /// - Returns: Formatted radius
+  private func formatedRadius(radius: String) -> Any {
+    if let poiRadius = Int(radius) {
+      return poiRadius
+    } else if let poiRadius = Double(radius) {
+      return poiRadius
+    } else {
+      return radius
+    }
+  }
+  private func isRegionIDExist(id: String) -> Bool {
+    if getRegions(id: id) != nil {
+      return true
+    }
+    return false
+  }
+
+  /// Convert Absolute URL for custom profile
+  /// - Parameters:
+  ///   - mode: location of profle local or external
+  ///   - source: file name
+  /// - Returns: Absolute URL
+  private func getCustomProfileURL(mode: String, source: String) -> String {
+    var customProfile: String = ""
+    if mode == "local" {
+      let bundle = Bundle.main  //Bundle(for: Self.self)
+      if let url = bundle.url(forResource: source, withExtension: nil) {
+        customProfile = url.absoluteString
+      }
+    } else if mode == "external" {
+      customProfile = source
+    }
+    return customProfile
+  }
+
+  public func startCustomTracking(
+    mode: String,
+    source: String,
+    completion: @escaping (_ Value: Bool, _ Error: WoosGeofenceError?) -> Void
+  ) {
+    let customProfile: String = getCustomProfileURL(mode: mode, source: source)
+    if mode == "local" {
+      if customProfile == "" {
+        completion(
+          false,
+          WoosGeofenceError(WoosmapGeofenceMessage.invalid_profilefile)
+        )
+      }
+    } else if mode == "external" {
+      if customProfile == "" {
+        completion(
+          false,
+          WoosGeofenceError(WoosmapGeofenceMessage.invalid_profilesourcetype)
+        )
+      }
     }
 
-    /// Delete all POI regions
-    public func  deleteAllPoiRegion() {
-        WoosmapGeofenceManager.shared.locationService.removeRegions(type: RegionType.poi)
-    }
+    if customProfile != "" {
+      DispatchQueue.main.async {
+        let (status, errors) = self.sdkInstance!.startCustomTracking(
+          url: customProfile
+        )
 
-    /// Delete regions by id
-    /// - Parameter id: region id
-    /// - Returns: deleted
-    public func  deleteRegions(id:String) throws  {
-        if let regionInfo = getRegions(id: id){
-            if(regionInfo.type == "circle"){
-                WoosmapGeofenceManager.shared.locationService.removeRegion(identifier: regionInfo.identifier)
-            }
-            else{
-                DataRegion().eraseRegions(id: regionInfo.identifier)
-            }
-        }
-        else{
-            throw WoosGeofenceError(WoosmapGeofenceMessage.regionid_notexist )
+        if status == false {
+          completion(false, WoosGeofenceError(errors[0]))
+        } else {
+          completion(true, nil)
+          self.defaultProfile = "\(mode):\(source)"
+          let defaults = UserDefaults.standard
+          defaults.set(
+            self.defaultProfile,
+            forKey: "WoosmapGeofenceService.profile"
+          )
         }
-        
-    }
-    
-    /// Delete all regions
-    public func  deleteAllRegion() {
-        DataRegion().eraseRegions()
-        WoosmapGeofenceManager.shared.locationService.removeRegions(type: RegionType.none)
+      }
     }
 
-    @objc static public func mockdata() {
-        if WoosmapGeofenceService.shared == nil {
-            WoosmapGeofenceService.setup()
-        }
-        MockDataVisit().mockVisitData()
-    }
+  }
 
-    /// Setting up SFMCCredentials
-    /// - Parameter credentials: Key/value pair for credentials settings
-    /// - Throws: Error for required keys
-    @objc public func setSFMCCredentials(credentials: [String: String]) throws {
-        var requiredSatisfied = true
-        if credentials["authenticationBaseURI"] == nil {
-            requiredSatisfied = false
-            throw WoosGeofenceError(WoosmapGeofenceMessage.required_authenticationBaseURI )
-        }
-        else if credentials["restBaseURI"] == nil {
-            requiredSatisfied = false
-            throw WoosGeofenceError(WoosmapGeofenceMessage.required_restBaseURI)
-        }
-        else if credentials["client_id"] == nil {
-            requiredSatisfied = false
-            throw WoosGeofenceError(WoosmapGeofenceMessage.required_client_id)
-        }
-        else if credentials["client_secret"] == nil {
-            requiredSatisfied = false
-            throw WoosGeofenceError(WoosmapGeofenceMessage.required_client_secret)
-        }
-        else if credentials["contactKey"] == nil {
-            requiredSatisfied = false
-            throw WoosGeofenceError(WoosmapGeofenceMessage.required_contactKey)
-        }
-        if requiredSatisfied {
-            WoosmapGeofenceManager.shared.setSFMCCredentials(credentials: credentials)
+  public func startCustomTracking1(mode: String, source: String) throws {
+    if mode == "local" {
+      let bundle = Bundle.main  //Bundle(for: Self.self)
+      if let url = bundle.url(forResource: source, withExtension: nil) {
+        let (status, errors) = self.sdkInstance!.startCustomTracking(
+          url: url.absoluteString
+        )
+        if status == false {
+          throw WoosGeofenceError(errors[0])
         }
+      } else {
+        throw WoosGeofenceError(WoosmapGeofenceMessage.invalid_profilefile)
+      }
+    } else if mode == "external" {
+      let (status, errors) = self.sdkInstance!.startCustomTracking(url: source)
+      if status == false {
+        throw WoosGeofenceError(errors[0])
+      }
+    } else {
+      throw WoosGeofenceError(WoosmapGeofenceMessage.invalid_profilesourcetype)
     }
 
-    /// Setting POI redious
-    /// - Parameter radius: integer or string for radius  value
-    public func setPoiRadius(radius: String) {
-        self.defaultPOIRadius = radius
-        WoosmapGeofenceManager.shared.setPoiRadius(radius: formatedRadius(radius: radius))
-    }
+  }
 
-    /// Format String value to proper datatype
-    /// - Parameter radius: radius of POI
-    /// - Returns: Formatted radius
-    private func formatedRadius (radius: String) -> Any {
-        if let poiRadius = Int(radius){
-            return poiRadius
-        }
-        else if let poiRadius = Double(radius){
-            return poiRadius
-        }
-        else{
-            return  radius
-        }
-    }
-    private func isRegionIDExist(id: String) -> Bool{
-        if let _ = getRegions(id: id){
-            return true
-        }
-        return false
-    }
-    
-    public func startCustomTracking(mode: String, source:String, completion: @escaping (_ Value: Bool, _ Error: WoosGeofenceError?)->()){
-        let group = DispatchGroup()
-        group.enter()
-        DispatchQueue.main.async {
-            if(mode == "local"){
-                let bundle = Bundle.main //Bundle(for: Self.self)
-                if let url = bundle.url(forResource: source, withExtension: nil){
-                    let (status,errors) = WoosmapGeofenceManager.shared.startCustomTracking(url: url.absoluteString)
-                    
-                    if(status == false){
-                        completion(false,WoosGeofenceError(errors[0]))
-                    }
-                    else{
-                        completion(true,nil)
-                    }
-                }
-                else{
-                    completion(false,WoosGeofenceError(WoosmapGeofenceMessage.invalid_profilefile))
-                }
-            }
-            else if(mode == "external"){
-                let (status,errors) = WoosmapGeofenceManager.shared.startCustomTracking(url: source)
-                if(status == false){
-                    completion(false,WoosGeofenceError(errors[0]))
-                }
-                else{
-                    completion(true,nil)
-                }
-            }
-            else{
-                completion(false,WoosGeofenceError(WoosmapGeofenceMessage.invalid_profilesourcetype))
-            }
-            group.leave()
-        }
-        group.wait()
-    }
-    
-    public func startCustomTracking1(mode: String, source:String) throws{
-            if(mode == "local"){
-                let bundle = Bundle.main //Bundle(for: Self.self)
-                if let url = bundle.url(forResource: source, withExtension: nil){
-                    let (status,errors) = WoosmapGeofenceManager.shared.startCustomTracking(url: url.absoluteString)
-                    if(status == false){
-                        throw WoosGeofenceError(errors[0])
-                    }
-                }
-                else{
-                    throw WoosGeofenceError(WoosmapGeofenceMessage.invalid_profilefile)
-                }
-            }
-            else if(mode == "external"){
-                let (status,errors) = WoosmapGeofenceManager.shared.startCustomTracking(url: source)
-                if(status == false){
-                    throw WoosGeofenceError(errors[0])
-                }
-            }
-            else{
-                throw WoosGeofenceError(WoosmapGeofenceMessage.invalid_profilesourcetype )
-            }
-        
-    }
+  ///Refresh POI info in storage
+  public func refreshPOI() {
+    self.sdkInstance?.refreshPOIs()
+  }
 
-    ///Refresh POI info in storage
-    public func refreshPOI() {
-        WoosmapGeofenceManager.shared.refreshPOI()
-    }
-    
-    public func isSearviceActive()-> Bool {
-        if(WoosmapGeofenceManager.shared.locationService.locationManager == nil){
-            return false
-        }
-        return true
-    }
-  
-    /// Setting Region Slots to reserver for other 3rd Party SDK to use it
-    /// - Parameter slots: Maximum 3 slots allow
-    public func setProtectedRegionSlot(slots: Int) throws{
-      try WoosmapGeofenceManager.shared.setProtectedRegionSlot(slots)
-      self.protectedRegionSlot = slots
+  public func isSearviceActive() -> Bool {
+    if self.sdkInstance?.locationService.locationManager == nil {
+      return false
     }
+    return true
+  }
+
+  /// Setting Region Slots to reserver for other 3rd Party SDK to use it
+  /// - Parameter slots: Maximum 3 slots allow
+  public func setProtectedRegionSlot(slots: Int) throws {
+    try self.sdkInstance?.setProtectedRegionSlot(slots)
+    self.protectedRegionSlot = slots
+  }
 }
 
 /// WoosGeofense error
 public struct WoosGeofenceError: Error {
 
-    /// Error info
-    let message: String
+  /// Error info
+  let message: String
 
-    /// Initialize
-    /// - Parameter message: error detail text
-    init(_ message: String) {
-        self.message = message
-    }
+  /// Initialize
+  /// - Parameter message: error detail text
+  init(_ message: String) {
+    self.message = message
+  }
 
-    /// Localized Description
-    public var localizedDescription: String {
-        return message
-    }
+  /// Localized Description
+  public var localizedDescription: String {
+    return message
+  }
 }