@woosmap/react-native-plugin-geofencing 0.1.2

package/android/src/main/java/com/reactnativeplugingeofencing/PluginGeofencingModule.java

@@ -0,0 +1,365 @@
+package com.reactnativeplugingeofencing;
+
+import android.Manifest;
+import android.app.Activity;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.util.ArraySet;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.core.app.ActivityCompat;
+
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.LifecycleEventListener;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.modules.core.PermissionAwareActivity;
+import com.facebook.react.modules.core.PermissionListener;
+import com.webgeoservices.woosmapgeofencing.Woosmap;
+import com.webgeoservices.woosmapgeofencing.WoosmapSettings;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+
+@ReactModule(name = PluginGeofencingModule.NAME)
+public class PluginGeofencingModule extends ReactContextBaseJavaModule implements PermissionListener, LifecycleEventListener {
+    public static final String NAME = "PluginGeofencing";
+
+    private ReactApplicationContext reactContext;
+    private Woosmap woosmap;
+    private static final int PERMISSIONS_REQUEST_CODE = 150; // random request code
+    private Promise mPermissionsRequestPromise;
+    private WoosLocationReadyListener locationReadyListener;
+
+    public PluginGeofencingModule(ReactApplicationContext reactContext) {
+      super(reactContext);
+      this.reactContext = reactContext;
+      this.reactContext.addLifecycleEventListener(this);
+    }
+
+    @Override
+    @NonNull
+    public String getName() {
+      return NAME;
+    }
+
+
+    // Example method
+    // See https://reactnative.dev/docs/native-modules-android
+    @ReactMethod
+    public void multiply(int a, int b, Promise promise) {
+      promise.resolve(a * b);
+    }
+
+
+    @ReactMethod
+    public void initialize(ReadableMap map, Promise promise) {
+      String trackingProfile = "";
+      try {
+        if (woosmap != null) {
+          promise.resolve(WoosmapMessageAndKey.successMessage);
+          return;
+        } else if (hasPermission(false)) {
+          //check required permission first
+          if (map.hasKey(WoosmapMessageAndKey.profileTrackingKey)) {
+            if (map.getString(WoosmapMessageAndKey.profileTrackingKey).equals(Woosmap.ConfigurationProfile.liveTracking)) {
+              trackingProfile = Woosmap.ConfigurationProfile.liveTracking;
+            } else if (map.getString(WoosmapMessageAndKey.profileTrackingKey).equals(Woosmap.ConfigurationProfile.passiveTracking)) {
+              trackingProfile = Woosmap.ConfigurationProfile.passiveTracking;
+            } else if (map.getString(WoosmapMessageAndKey.profileTrackingKey).equals(Woosmap.ConfigurationProfile.visitsTracking)) {
+              trackingProfile = Woosmap.ConfigurationProfile.visitsTracking;
+            } else {
+              promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.invalidProfileTrackingError);
+              return;
+            }
+          }
+          woosmap = Woosmap.getInstance().initializeWoosmap(reactContext);
+          if (map.hasKey(WoosmapMessageAndKey.woosmapPrivateKeyString)) {
+            WoosmapSettings.privateKeyWoosmapAPI = map.getString(WoosmapMessageAndKey.woosmapPrivateKeyString);
+          }
+          // Set the Delay of Duration data
+          WoosmapSettings.numberOfDayDataDuration = 30;
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            this.woosmap.createWoosmapNotifChannel();
+          }
+          this.woosmap.onResume();
+          if (!trackingProfile.isEmpty()) {
+            woosmap.startTracking(trackingProfile);
+          }
+          promise.resolve(WoosmapMessageAndKey.successMessage);
+        } else {
+          promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.permissionNotGrantedMessage);
+        }
+      } catch (Exception ex) {
+        promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+      }
+
+    }
+
+    private boolean isWoosmapInitialized() {
+      if (woosmap == null) {
+        return false;
+      }
+      return true;
+    }
+
+    @ReactMethod
+    private void requestPermissions(ReadableArray data, Promise promise) {
+      try {
+        if (data.isNull(0)) {
+          promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.permissionValueNotProvided);
+        }
+        boolean isBackground = data.getBoolean(0);
+        PermissionAwareActivity activity = (PermissionAwareActivity) getCurrentActivity();
+        mPermissionsRequestPromise = promise;
+        if (activity != null) {
+          if (Build.VERSION.SDK_INT >= 23) {
+            if (isBackground && Build.VERSION.SDK_INT >= 29) {
+              activity.requestPermissions(new String[]{Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_BACKGROUND_LOCATION}, PERMISSIONS_REQUEST_CODE, this);
+            } else {
+              activity.requestPermissions(new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, PERMISSIONS_REQUEST_CODE, this);
+            }
+          }
+        }
+      } catch (Exception ex) {
+        promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+      }
+    }
+
+
+    @Override
+    public boolean onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
+      if (requestCode == PERMISSIONS_REQUEST_CODE && mPermissionsRequestPromise != null) {
+        providePermissionStatus(mPermissionsRequestPromise);
+        mPermissionsRequestPromise = null;
+      }
+      return true;
+    }
+
+    private void providePermissionStatus(final Promise promise) {
+      try {
+        if (promise == null) {
+          return;
+        }
+        Activity activity = getCurrentActivity();
+        if (activity == null) {
+          promise.resolve(WoosmapMessageAndKey.unknownMessage);
+          return;
+        }
+
+        boolean foreground = ActivityCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED;
+        boolean background = foreground;
+        boolean denied = ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.ACCESS_FINE_LOCATION);
+
+        if (Build.VERSION.SDK_INT >= 29) {
+          background = ActivityCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_BACKGROUND_LOCATION) == PackageManager.PERMISSION_GRANTED;
+        }
+
+        if (background) {
+          promise.resolve(WoosmapMessageAndKey.backgroundPermissionGrantedMessage);
+        } else if (foreground) {
+          promise.resolve(WoosmapMessageAndKey.foregroundPermissionGrantedMessage);
+        } else if (denied) {
+          promise.resolve(WoosmapMessageAndKey.deniedPermissionMessage);
+        } else {
+          promise.resolve(WoosmapMessageAndKey.unknownMessage);
+        }
+      } catch (Exception ex) {
+        promise.resolve(WoosmapMessageAndKey.unknownMessage);
+      }
+    }
+
+    @ReactMethod
+    public void getPermissionsStatus(final Promise promise) {
+      providePermissionStatus(promise);
+    }
+
+    private boolean hasPermission(boolean isBackground) {
+      try {
+        Activity activity = getCurrentActivity();
+        if (activity == null) {
+          return false;
+        }
+        if (!isBackground) {
+          return ActivityCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED;
+        }
+        if (isBackground && Build.VERSION.SDK_INT >= 29) {
+          return ActivityCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_BACKGROUND_LOCATION) == PackageManager.PERMISSION_GRANTED;
+        }
+
+      } catch (Exception ex) {
+        Log.e(NAME, ex.toString());
+      }
+      return false;
+    }
+
+
+    @Override
+    public void onHostResume() {
+      if (woosmap != null) {
+        woosmap.onResume();
+      }
+    }
+
+    @Override
+    public void onHostPause() {
+      if (woosmap != null) {
+        woosmap.onPause();
+      }
+    }
+
+    @Override
+    public void onHostDestroy() {
+      if (woosmap != null) {
+        woosmap.onDestroy();
+      }
+    }
+    @ReactMethod
+    public void setWoosmapApiKey(ReadableArray data, Promise promise) {
+      try {
+        if (isWoosmapInitialized()) {
+          String apiKey = "";
+          if (!data.isNull(0)) {
+            apiKey = data.getString(0);
+          }
+          if (!apiKey.isEmpty()) {
+            WoosmapSettings.privateKeyWoosmapAPI = apiKey;
+            promise.resolve(WoosmapMessageAndKey.successMessage);
+          } else {
+            promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapKeyNotProvide);
+          }
+        } else {
+          promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        }
+
+      } catch (Exception ex) {
+        promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+      }
+    }
+
+    @ReactMethod
+    public void startTracking(ReadableArray data, Promise promise) {
+      try {
+        if (isWoosmapInitialized()) {
+          if (data.isNull(0)) {
+            promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.trackingProfileNotProvided);
+          }
+
+          String trackingProfile = data.getString(0);
+          if (trackingProfile.equals(Woosmap.ConfigurationProfile.liveTracking) ||
+            trackingProfile.equals(Woosmap.ConfigurationProfile.passiveTracking) ||
+            trackingProfile.equals(Woosmap.ConfigurationProfile.visitsTracking)) {
+            woosmap.startTracking(trackingProfile);
+            promise.resolve(WoosmapMessageAndKey.successMessage);
+          } else {
+            promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.invalidProfileTrackingError);
+          }
+        } else {
+          promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        }
+      } catch (Exception ex) {
+        promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+      }
+    }
+
+    @ReactMethod
+    public void stopTracking(Promise promise) {
+      try {
+        if (isWoosmapInitialized()) {
+          woosmap.stopTracking();
+          promise.resolve(WoosmapMessageAndKey.successMessage);
+        } else {
+          promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        }
+
+      } catch (Exception ex) {
+        promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+      }
+    }
+    @ReactMethod
+    public void watchLocation(String watchID,Promise promise){
+      try {
+        if(isWoosmapInitialized()){
+          if(locationReadyListener==null){
+            locationReadyListener=new WoosLocationReadyListener(reactContext);
+            woosmap.setLocationReadyListener(locationReadyListener);
+            promise.resolve(watchID);
+          }else {
+            promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.locationWatchAlreadyStarted);
+          }
+        }else {
+          promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        }
+      }catch (Exception ex){
+        promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+      }
+    }
+    @ReactMethod
+    public void clearLocationWatch(String watchID,Promise promise){
+      try {
+        if(locationReadyListener!=null){
+          woosmap.setLocationReadyListener(null);
+          locationReadyListener=null;
+          promise.resolve(watchID);
+        }else {
+          promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.locationWatchNotStarted);
+        }
+      }catch (Exception ex){
+        promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+      }
+    }
+    @ReactMethod
+    private void setSFMCCredentials(ReadableMap map, Promise promise){
+      try{
+        if(isWoosmapInitialized()){
+          if (!map.toHashMap().isEmpty()){
+            HashMap<String, String> SFMCInfo = new HashMap<>();
+            String key;
+            if (!map.hasKey(WoosmapMessageAndKey.SMFCauthenticationBaseURIkey)){
+              throw new Exception(WoosmapMessageAndKey.keyMissingMessage+": "+WoosmapMessageAndKey.SMFCauthenticationBaseURIkey);
+            }
+            if (!map.hasKey(WoosmapMessageAndKey.SMFCrestBaseURIkey)){
+              throw new Exception(WoosmapMessageAndKey.keyMissingMessage+": "+WoosmapMessageAndKey.SMFCrestBaseURIkey);
+            }
+            if (!map.hasKey(WoosmapMessageAndKey.SMFCclient_idkey)){
+              throw new Exception(WoosmapMessageAndKey.keyMissingMessage+": "+WoosmapMessageAndKey.SMFCclient_idkey );
+            }
+            if (!map.hasKey(WoosmapMessageAndKey.SMFCclient_secretkey)){
+              throw new Exception(WoosmapMessageAndKey.keyMissingMessage+": "+WoosmapMessageAndKey.SMFCclient_secretkey );
+            }
+            if (!map.hasKey(WoosmapMessageAndKey.SMFCcontactKey)){
+              throw new Exception(WoosmapMessageAndKey.keyMissingMessage+": "+WoosmapMessageAndKey.SMFCcontactKey );
+            }
+
+            Iterator<String> keys = map.toHashMap().keySet().iterator();
+
+            while (keys.hasNext()){
+              key = keys.next();
+              SFMCInfo.put(key,map.getString(key));
+            }
+            WoosmapSettings.SFMCCredentials = SFMCInfo;
+            promise.resolve(WoosmapMessageAndKey.successMessage);
+          }
+          else{
+            promise.reject(WoosmapMessageAndKey.errorCode,WoosmapMessageAndKey.credentialEmptyMessage);
+          }
+        }else {
+          promise.reject(WoosmapMessageAndKey.errorCode,WoosmapMessageAndKey.woosmapNotInitialized);
+        }
+
+      }
+      catch (Exception ex){
+        promise.reject(WoosmapMessageAndKey.errorCode,ex.getMessage());
+      }
+    }
+
+  }

package/android/src/main/java/com/reactnativeplugingeofencing/PluginGeofencingPackage.java

@@ -0,0 +1,28 @@
+package com.reactnativeplugingeofencing;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class PluginGeofencingPackage implements ReactPackage {
+    @NonNull
+    @Override
+    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new PluginGeofencingModule(reactContext));
+        return modules;
+    }
+
+    @NonNull
+    @Override
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

package/android/src/main/java/com/reactnativeplugingeofencing/WoosLocationReadyListener.java

@@ -0,0 +1,38 @@
+package com.reactnativeplugingeofencing;
+
+import android.content.Context;
+import android.location.Location;
+
+import com.facebook.react.ReactApplication;
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.ReactNativeHost;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.webgeoservices.woosmapgeofencing.Woosmap;
+
+public class WoosLocationReadyListener implements Woosmap.LocationReadyListener {
+  private ReactNativeHost reactNativeHost;
+  private Context context;
+  public WoosLocationReadyListener(Context context){
+    this.context=context;
+  }
+
+  private void sendEvent(final String eventName, final Object data) {
+    final ReactInstanceManager reactInstanceManager = reactNativeHost.getReactInstanceManager();
+    ReactContext reactContext = reactInstanceManager.getCurrentReactContext();
+    if (reactContext != null) {
+      reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class).emit(eventName, data);
+    }
+  }
+  @Override
+  public void LocationReadyCallback(Location location) {
+    try {
+      ReactApplication reactApplication = ((ReactApplication)context.getApplicationContext());
+      reactNativeHost = reactApplication.getReactNativeHost();
+      sendEvent(WoosmapMessageAndKey.locationSuccessCallbackName, WoosmapUtil.getLocationWritableMap(location));
+    }catch (Exception ex){
+      sendEvent(WoosmapMessageAndKey.locationErrorCallbackName, ex.getMessage());
+    }
+
+  }
+}

package/android/src/main/java/com/reactnativeplugingeofencing/WoosmapMessageAndKey.java

@@ -0,0 +1,36 @@
+package com.reactnativeplugingeofencing;
+
+public class WoosmapMessageAndKey {
+  protected static String errorCode = "1001";
+  protected static String successMessage="OK";
+  protected static String profileTrackingKey="trackingProfile";
+  protected static String woosmapPrivateKeyString="privateKeyWoosmapAPI";
+  protected static String invalidProfileTrackingError="Invalid tracking profile. Only possible values are liveTracking, passiveTracking, visitsTracking";
+  protected static String permissionNotGrantedMessage="Required permissions not granted";
+  protected static String permissionValueNotProvided="Permission value not provided";
+  protected static String unknownMessage="UNKNOWN";
+  protected static String deniedPermissionMessage="PERMISSION_STATUS_DENIED";
+  protected static String foregroundPermissionGrantedMessage="PERMISSION_STATUS_GRANTED_FOREGROUND";
+  protected static String backgroundPermissionGrantedMessage="PERMISSION_STATUS_GRANTED_BACKGROUND";
+  protected static String woosmapKeyNotProvide="Woosmap API Key not provided";
+  protected static String woosmapNotInitialized="Woosmap not initialized";
+  protected static String trackingProfileNotProvided="Tracking profile is missing";
+  protected static String locationSuccessCallbackName="geolocationDidChange";
+  protected static String locationErrorCallbackName="geolocationError";
+  protected static String locationWatchNotStarted="Location watch not started";
+  protected static String locationWatchAlreadyStarted="Location watch already added";
+  protected static String keyMissingMessage="Required key missing";
+  protected static String SMFCauthenticationBaseURIkey="authenticationBaseURI";
+  protected static String SMFCrestBaseURIkey="restBaseURI";
+  protected static String SMFCclient_idkey="client_id";
+  protected static String SMFCclient_secretkey="client_secret";
+  protected static String SMFCcontactKey="contactKey";
+  protected static String credentialEmptyMessage="Credentials cannot be empty.";
+
+
+
+
+
+
+
+}

package/android/src/main/java/com/reactnativeplugingeofencing/WoosmapUtil.java

@@ -0,0 +1,34 @@
+package com.reactnativeplugingeofencing;
+
+import android.location.Location;
+import android.util.Log;
+
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeArray;
+import com.facebook.react.bridge.WritableNativeMap;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.Iterator;
+
+public class WoosmapUtil {
+  private static final String TAG="WoosmapUtil";
+
+  protected static WritableMap getLocationWritableMap(Location location){
+    WritableMap map=new WritableNativeMap();
+    try {
+      map.putDouble("latitude", location.getLatitude());
+      map.putDouble("longitude", location.getLongitude());
+      map.putString("locationid", "1");
+      map.putString("locationdescription", "description");
+      map.putDouble("date", location.getTime());
+    }catch (Exception ex){
+      Log.e(TAG,ex.toString());
+    }
+    return map;
+  }
+
+}

package/ios/AirshipEvents.swift

@@ -0,0 +1,73 @@
+//
+//  AirshipEvents.swift
+//  Sample
+//
+//
+
+import Foundation
+import CoreLocation
+import WoosmapGeofencing
+#if canImport(AirshipCore)
+  import AirshipCore
+#endif
+
+class AirshipData {
+    var eventname: String = ""
+    var properties: [String: Any]
+
+    required init(eventname: String, properties: [String: Any]) {
+        self.eventname = eventname
+        self.properties = properties
+    }
+}
+
+public class AirshipEvents: AirshipEventsDelegate {
+
+    public init() {}
+
+    public func regionEnterEvent(regionEvent: [String: Any], eventName: String) {
+        #if canImport(AirshipCore)
+        var result: AirshipData = AirshipData.init(eventname: eventName, properties: regionEvent)
+        NotificationCenter.default.post(name: .airshipEvent, object: self, userInfo: ["Airship": result])
+        #endif
+    }
+
+    public func regionExitEvent(regionEvent: [String: Any], eventName: String) {
+        #if canImport(AirshipCore)
+        var result: AirshipData = AirshipData.init(eventname: eventName, properties: regionEvent)
+        NotificationCenter.default.post(name: .airshipEvent, object: self, userInfo: ["Airship": result])
+        #endif
+    }
+
+    public func visitEvent(visitEvent: [String: Any], eventName: String) {
+        #if canImport(AirshipCore)
+        var result: AirshipData = AirshipData.init(eventname: eventName, properties: regionEvent)
+        NotificationCenter.default.post(name: .airshipEvent, object: self, userInfo: ["Airship": result])
+        #endif
+    }
+
+    public func poiEvent(POIEvent: [String: Any], eventName: String) {
+        #if canImport(AirshipCore)
+        var result: AirshipData = AirshipData.init(eventname: eventName, properties: regionEvent)
+        NotificationCenter.default.post(name: .airshipEvent, object: self, userInfo: ["Airship": result])
+        #endif
+    }
+
+    public func ZOIclassifiedEnter(regionEvent: [String: Any], eventName: String) {
+        #if canImport(AirshipCore)
+        var result: AirshipData = AirshipData.init(eventname: eventName, properties: regionEvent)
+        NotificationCenter.default.post(name: .airshipEvent, object: self, userInfo: ["Airship": result])
+        #endif
+    }
+
+    public func ZOIclassifiedExit(regionEvent: [String: Any], eventName: String) {
+        #if canImport(AirshipCore)
+        var result: AirshipData = AirshipData.init(eventname: eventName, properties: regionEvent)
+        NotificationCenter.default.post(name: .airshipEvent, object: self, userInfo: ["Airship": result])
+        #endif
+    }
+}
+
+extension Notification.Name {
+    static let airshipEvent = Notification.Name("airshipEvent")
+}

package/ios/DataDistance.swift

@@ -0,0 +1,61 @@
+//
+//  DataDistance.swift
+//  Sample
+//
+//
+
+import Foundation
+import CoreLocation
+import WoosmapGeofencing
+
+public class DataDistance: DistanceAPIDelegate {
+    public func distanceAPIResponse(distance: [Distance]) {
+        
+    }
+    
+    public init() {}
+
+    public func distanceAPIResponseData(distanceAPIData: DistanceAPIData, locationId: String) {
+        if distanceAPIData.status == "OK" {
+            if distanceAPIData.rows?.first?.elements?.first?.status == "OK" {
+                let distance = distanceAPIData.rows?.first?.elements?.first?.distance
+                let duration = distanceAPIData.rows?.first?.elements?.first?.duration
+                if distance != nil && duration != nil {
+                    // TODO: Implementation missing
+                    //let result: DistanceResponseResult = DistanceResponseResult.init(locationId: locationId, distance: distance!, duration: duration!)
+                    //NotificationCenter.default.post(name: .distanceCalculated, object: self, userInfo: ["Distance": result])
+                }
+            }
+        } else {
+            let result: DistanceResponseError = DistanceResponseError.init(locationId: locationId, error: distanceAPIData.status ?? "-")
+            NotificationCenter.default.post(name: .distanceCalculated, object: self, userInfo: ["Distance": result])
+        }
+    }
+
+    public func distanceAPIError(error: String) {
+        print(error)
+    }
+
+}
+extension Notification.Name {
+    static let distanceCalculated = Notification.Name("POIDistanceCalculated")
+}
+
+class DistanceResponseResult {
+    var locationId: String = ""
+    var distance: Distance
+    var duration: Distance
+    required init(locationId: String, distance: Distance, duration: Distance) {
+        self.locationId = locationId
+        self.distance = distance
+        self.duration = duration
+    }
+}
+class DistanceResponseError {
+    var locationId: String = ""
+    var error: String
+    required init(locationId: String, error: String ) {
+        self.locationId = locationId
+        self.error = error
+    }
+}

package/ios/DataLocation.swift

@@ -0,0 +1,36 @@
+//
+//  DataLocation.swift
+//  WoosmapGeofencing
+//
+//
+
+import Foundation
+import UIKit
+import CoreLocation
+import WoosmapGeofencing
+
+public class DataLocation: LocationServiceDelegate {
+
+    public init() {}
+
+    public func tracingLocation(location: Location) {
+        NotificationCenter.default.post(name: .newLocationSaved, object: self, userInfo: ["Location": location])
+    }
+
+    public func tracingLocationDidFailWithError(error: Error) {
+        NSLog("\(error)")
+    }
+
+    public func readLocations() -> [Location] {
+        return Locations.getAll()
+    }
+
+    public func eraseLocations() {
+        Locations.deleteAll()
+    }
+
+}
+
+extension Notification.Name {
+    static let newLocationSaved = Notification.Name("newLocationSaved")
+}