react-native-move-sdk 0.1.5 → 0.2.0

package/ios/NativeModule/DolphinSdk.swift

@@ -1,357 +0,0 @@
-import Foundation
-import DolphinMoveSDK
-
-internal protocol DolphinSDKLauncherDelegate: AnyObject {
-	func send(event: DolphinSDKLauncher.Event, data: [String: Any])
-}
-
-@objc(DolphinSdk)
-class DolphinSdk: RCTEventEmitter {
-	private enum CError: String, Error {
-		case transformedServices = "Unknown driving service identifier in init parameters"
-		case transformedTimelineDetectionServices = "Unknown timeline service identifier in init parameters"
-		case transformedWalkingServices = "Unknown walking service identifier in init parameters"
-		case transformedOtherServices = "Unknown other service identifier in init parameters"
-	}
-
-	var ERROR_CODE = "DOLPHIN_SDK_ERROR"
-	
-	override init() {
-		super.init()
-		DolphinSDKLauncher.shared.delegate = self
-	}
-	
-	@objc
-	func initialize(_ contractId: String,
-									accessToken: String,
-									refreshToken: String,
-									productId: Int64,
-									timelineDetectionServices: Array<String>,
-									drivingServices: Array<String>,
-									walkingServices: Array<String>,
-									otherServices: Array<String>,
-									resolve: @escaping RCTPromiseResolveBlock,
-									reject: @escaping RCTPromiseRejectBlock) {
-		
-		do {
-			
-			let transformedServices: Array<MoveConfig.DrivingService> = try drivingServices.map {(s) -> MoveConfig.DrivingService in
-				if(s == "DistractionFreeDriving") {
-					return MoveConfig.DrivingService.dfd
-				}
-				else if(s == "DrivingBehaviour") {
-					return MoveConfig.DrivingService.behaviour
-				}
-				else {
-					throw CError.transformedServices
-				}
-			}
-			
-			let transformedTimelineDetectionServices: Array<MoveConfig.TimelineDetectionService> = try! timelineDetectionServices.map {(s) -> MoveConfig.TimelineDetectionService in
-				if(s == "DRIVING") {
-					return MoveConfig.TimelineDetectionService.driving
-				}
-				else if(s == "BICYCLE") {
-					return MoveConfig.TimelineDetectionService.bicycle
-				}
-				else if(s == "WALKING") {
-					return MoveConfig.TimelineDetectionService.walking
-				}
-				else if(s == "PUBLIC_TRANSPORT") {
-					return MoveConfig.TimelineDetectionService.publicTransport
-				}
-				else {
-					throw CError.transformedTimelineDetectionServices
-				}
-			}
-			
-			let transformedWalkingServices: Array<MoveConfig.WalkingService> = try walkingServices.map {(s) -> MoveConfig.WalkingService in
-				if(s == "Location") {
-					return MoveConfig.WalkingService.location
-				}
-				else {
-					throw CError.transformedWalkingServices
-				}
-			}
-			
-			let transformedOtherServices:  Array<MoveConfig.OtherService> = try otherServices.map {(s) -> MoveConfig.OtherService in
-				if(s == "PointsOfInterest") {
-					return MoveConfig.OtherService.poi
-				}
-				else {
-					throw CError.transformedOtherServices
-				}
-			}
-			
-			// TODO: Fix wrapper and add config option from RN for walking services (actually only 1 now)
-			let sdkConfig = MoveConfig(timelineDetectionService: transformedTimelineDetectionServices, drivingServices: transformedServices, walkingServices: transformedWalkingServices, otherServices: transformedOtherServices)
-			let auth = MoveAuth(userToken: accessToken, refreshToken: refreshToken, contractID: contractId, productID: productId)
-			
-			DispatchQueue.main.async {
-				DolphinSDKLauncher.shared.initialize(auth: auth, config: sdkConfig)
-			}
-			resolve("OK")
-		} catch {
-			reject("DOLPHIN_SDK_ERROR", "\(error)", nil)
-		}
-	}
-	
-	@objc
-	func getState(
-		_ resolve: RCTPromiseResolveBlock,
-		rejecter reject: RCTPromiseRejectBlock
-	) {
-		resolve("\(DolphinSDKLauncher.shared.sdk.getSDKState())")
-	}
-	
-	@objc
-	func getAuthState(
-		_ resolve: RCTPromiseResolveBlock,
-		rejecter reject: RCTPromiseRejectBlock
-	) {
-		resolve("\(DolphinSDKLauncher.shared.sdk.getAuthState())")
-	}
-	
-	@objc
-	func updateAuth(
-		_ contractId: String,
-		accessToken: String,
-		refreshToken: String,
-		productId: Int64,
-		resolver resolve: @escaping RCTPromiseResolveBlock,
-		rejecter reject: @escaping RCTPromiseRejectBlock
-	) {
-		let auth = MoveAuth(userToken: accessToken, refreshToken: refreshToken, contractID: contractId, productID: productId)
-
-		DolphinSDKLauncher.shared.sdk.update(auth: auth) { configurationError in
-			if let configurationError = configurationError {
-				reject("DolphinSdk-AuthState-ConfigurationError", "\(configurationError)", nil)
-			} else {
-				DolphinSDKLauncher.shared.sdkAuth = auth
-				resolve("OK")
-			}
-		}
-	}
-	
-	@objc
-	func getTripState(
-		_ resolve: RCTPromiseResolveBlock,
-		rejecter reject: RCTPromiseRejectBlock
-	) {
-		resolve("\(DolphinSDKLauncher.shared.sdk.getTripState())")
-	}
-	
-	@objc
-	func startAutomaticDetection() {
-		DolphinSDKLauncher.shared.startAutomaticDetection()
-	}
-	
-	@objc
-	func stopAutomaticDetection() {
-		DolphinSDKLauncher.shared.stopAutomaticDetection()
-	}
-	
-	@objc
-	func shutdown() {
-		DolphinSDKLauncher.shared.shutdown()
-	}
-	
-	@objc
-	func forceTripRecognition() {
-		DolphinSDKLauncher.shared.sdk.forceTripRecognition()
-	}
-	
-	@objc
-	func synchronizeUserData(
-		_ resolve: @escaping RCTPromiseResolveBlock,
-		rejecter reject: @escaping RCTPromiseRejectBlock) {
-		DolphinSDKLauncher.shared.sdk.synchronizeUserData() { success in
-			resolve(success)
-		}
-	}
-	
-	@objc
-	func ignoreCurrentTrip() {
-		DolphinSDKLauncher.shared.sdk.ignoreCurrentTrip()
-	}
-	
-	@objc
-	func finishCurrentTrip() {
-		DolphinSDKLauncher.shared.sdk.finishCurrentTrip()
-	}
-
-	@objc
-	func resolveError() {
-		DolphinSDKLauncher.shared.sdk.resolveSDKStateError()
-	}
-	
-	@objc
-	func sendAppEvent(_ eventInfo: NSString) {
-	  self.sendEvent(withName: "DolphinSdk-AppEvent", body: ["eventInfo": "\(eventInfo)"])
-	}
-	
-	@objc public static func initIfPossibleWith(launchOptions: [UIApplication.LaunchOptionsKey: Any]?) {
-		DolphinSDKLauncher.shared.initIfPossibleWith(launchOptions: launchOptions)
-	}
-
-	override func supportedEvents() -> [String]! {
-	  return ["DolphinSdk-InitError", "DolphinSdk-State", "DolphinSdk-TripState", "DolphinSdk-AuthState", "DolphinSdk-AppEvent"]
-	}
-	
-	static override func moduleName() -> String! {
-		return "DolphinSdk"
-	}
-	
-	static override func requiresMainQueueSetup() -> Bool {
-		// To let React Native know if your module needs to be initialized on the main thread, before any JavaScript code executes.
-		// Otherwise you will see a warning that in the future your module may be initialized on a background thread unless you explicitly opt out
-		return true
-	}
-}
-
-extension DolphinSdk: DolphinSDKLauncherDelegate {
-	func send(event: DolphinSDKLauncher.Event, data: [String: Any]) {
-		sendEvent(withName: event.rawValue, body: data)
-	}
-}
-
-internal class DolphinSDKLauncher {
-	internal enum Event: String {
-		case sdkState = "DolphinSdk-State"
-		case tripState = "DolphinSdk-TripState"
-		case authState = "DolphinSdk-AuthState"
-		case initError = "DolphinSdk-InitError"
-	}
-
-	private enum DefaultsKey: String {
-		case auth = "MOVE.WRAPPER.AUTH"
-		case config = "MOVE.WRAPPER.CONFIG"
-	}
-	
-	weak var delegate: DolphinSDKLauncherDelegate?
-
-	static let shared = DolphinSDKLauncher()
-
-	let sdk = MoveSDK.shared
-	var launchOptions: [UIApplication.LaunchOptionsKey: Any]?
-
-	/// Persistence
-	internal var sdkAuth: DolphinMoveSDK.MoveAuth? {
-		didSet { DolphinSDKLauncher.encode(sdkAuth, forKey: .auth) }
-	}
-
-	private var sdkConfig: DolphinMoveSDK.MoveConfig? {
-		didSet { DolphinSDKLauncher.encode(sdkConfig, forKey: .config) }
-	}
-
-	private var isInRunningState: Bool {
-		didSet {
-			UserDefaults.standard.set(isInRunningState, forKey: "MOVE.WRAPPER.RUNNING")
-		}
-	}
-
-	init() {
-		sdkConfig = DolphinSDKLauncher.decode(.config)
-		sdkAuth = DolphinSDKLauncher.decode(.auth)
-
-		isInRunningState = UserDefaults.standard.bool(forKey: "MOVE.WRAPPER.RUNNING")
-
-		sdk.setSDKStateListener { state in
-			var data = ["state": "\(state)"]
-			switch (state) {
-			case let .error(stateError):
-				data["errorReason"] = "\(stateError)"
-			case .ready:
-				if self.isInRunningState {
-					self.sdk.startAutomaticDetection()
-				}
-			default:
-				break;
-			}
-			self.delegate?.send(event: .sdkState, data: data)
-		}
-		
-		sdk.setTripStateListener { state in
-			self.delegate?.send(event: .tripState, data: ["state": "\(state)"])
-		}
-		
-		sdk.setAuthStateUpdateListener { state in
-			var data = ["state": "\(state)"]
-			switch (state) {
-			case let .valid(auth):
-				self.sdkAuth = auth
-				data["accessToken"] = "\(auth.userToken)"
-				data["refreshToken"] = "\(auth.refreshToken)"
-			default:
-				break
-			}
-
-			self.delegate?.send(event: .authState, data: data)
-		}
-	}
-
-	internal func initIfPossibleWith(launchOptions: [UIApplication.LaunchOptionsKey: Any]?) {
-		self.launchOptions = launchOptions
-		/// warm start SDK
-		if isInRunningState, let auth = sdkAuth, let config = sdkConfig {
-			MoveSDK.shared.initialize(auth: auth, config: config, launchOptions: launchOptions) { initError in
-				if let error = initError {
-					self.delegate?.send(event: .initError, data: ["error": "\(error)"])
-				}
-			}
-		}
-	}
-	
-	internal func initialize(auth: DolphinMoveSDK.MoveAuth, config: DolphinMoveSDK.MoveConfig) {
-		MoveSDK.shared.initialize(auth: auth, config: config, launchOptions: self.launchOptions) { initError in
-			if let error = initError {
-				self.delegate?.send(event: .initError, data: ["error": "\(error)"])
-			} else {
-				/// store back config and auth for bg launch
-				self.sdkConfig = config
-				self.sdkAuth = auth
-			}
-		}
-	}
-	
-	func shutdown() {
-		isInRunningState = false
-		sdkAuth = nil
-		sdk.shutDown()
-	}
-	
-	func startAutomaticDetection() {
-		if !isInRunningState {
-			isInRunningState = true
-			sdk.startAutomaticDetection()
-		}
-	}
-
-	func stopAutomaticDetection() {
-		if isInRunningState {
-			isInRunningState = false
-			sdk.stopAutomaticDetection()
-		}
-	}
-
-	private static func decode<T>(_ key: DefaultsKey) -> T? where T: Decodable {
-		let decoder = PropertyListDecoder()
-
-		if let data = UserDefaults.standard.object(forKey: key.rawValue) as? Data {
-			return try? decoder.decode(T.self, from: data)
-		}
-
-		return nil
-	}
-
-	private static func encode<T>(_ encodable: T?, forKey key: DefaultsKey) where T: Encodable {
-		if let encodable = encodable {
-			let encoder = PropertyListEncoder()
-			if let data = try? encoder.encode(encodable) {
-				UserDefaults.standard.set(data, forKey: key.rawValue)
-			}
-		} else {
-			UserDefaults.standard.removeObject(forKey: key.rawValue)
-		}
-	}
-}

package/ios/NativeModule/DolphinSdkDemoReactNative-Bridging-Header.h

@@ -1,8 +0,0 @@
-//
-//  Use this file to import your target's public headers that you would like to expose to Swift.
-//
-
-#import "React/RCTBridgeModule.h"
-#import "React/RCTEventEmitter.h"
-
-#import <React/RCTBundleURLProvider.h>