react-native-move-sdk 0.1.5 → 0.2.1

package/ios/NativeModule/MoveSdk.swift

@@ -0,0 +1,607 @@
+import CoreMotion
+import Foundation
+import DolphinMoveSDK
+
+internal protocol MoveSDKLauncherDelegate: AnyObject {
+	func send(event: MoveSDKLauncher.Event, data: [String: Any])
+}
+
+typealias MoveSDKErrorListItem = [String:Any]
+
+@objc(RCTMoveSdk)
+class RCTMoveSdk: 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"
+	}
+
+	private enum ErrorCode: String {
+		case setupError = "SETUP_ERROR"
+		case resolveFailed = "RESOLVE_FAILED"
+		case serviceUnavailable = "SERVICE_UNAVAILABLE"
+		case thresholdReached = "THRESHOLD_REACHED"
+		case geocodeError = "GEOCODE_ERROR"
+		case authInvalid = "AUTH_INVALID"
+		case initializationError = "INITIALIZATION_ERROR"
+		case locationError = "LOCATION_ERROR"
+		case networkError = "NETWORK_ERROR"
+		case assistanceCallError = "ASSISTANCE_CALL_ERROR"
+		case configurationError = "CONFIGURATION_ERROR"
+
+	}
+
+	let motionManager = CMMotionActivityManager()
+
+	override func startObserving() {
+		MoveSDKLauncher.shared.delegate = self
+	}
+
+	@objc
+	func setup(_ contractId: String,
+			   accessToken: String,
+			   refreshToken: String,
+			   productId: Int64,
+			   timelineDetectionServices: Array<String>,
+			   drivingServices: Array<String>,
+			   walkingServices: Array<String>,
+			   resolve: @escaping RCTPromiseResolveBlock,
+			   reject: @escaping RCTPromiseRejectBlock) {
+
+		do {
+
+			let transformedServices: [MoveConfig.DrivingService] = try drivingServices.map {
+				switch $0 {
+				case "DISTRACTION_FREE_DRIVING":
+					return .distractionFreeDriving
+				case "DRIVING_BEHAVIOUR":
+					return .drivingBehavior
+				default:
+					throw CError.transformedServices
+				}
+			}
+
+			let transformedWalkingServices: [MoveConfig.WalkingService] = try walkingServices.map {
+				if $0 == "LOCATION" {
+					return .location
+				}
+				throw CError.transformedWalkingServices
+			}
+
+			let transformedDetectionServices: [MoveConfig.DetectionService] = try! timelineDetectionServices.map {
+				switch $0 {
+				case "DRIVING":
+					return .driving(transformedServices)
+				case "WALKING":
+					return .walking(transformedWalkingServices)
+				case "CYCLING":
+					return .cycling
+				case "PUBLIC_TRANSPORT":
+					return .publicTransport
+				case "ASSISTANCE_CALL":
+					return .assistanceCall
+				case "POINTS_OF_INTEREST":
+					return .pointsOfInterest
+				case "AUTOMATIC_IMPACT_DETECTION":
+					return .automaticImpactDetection
+				default:
+					throw CError.transformedTimelineDetectionServices
+				}
+			}
+
+			// TODO: Fix wrapper and add config option from RN for walking services (actually only 1 now)
+			let sdkConfig = MoveConfig(detectionService: transformedDetectionServices)
+			let auth = MoveAuth(userToken: accessToken, refreshToken: refreshToken, userID: contractId, projectID: productId)
+
+			DispatchQueue.main.async {
+				MoveSDKLauncher.shared.setup(auth: auth, config: sdkConfig)
+			}
+			resolve("OK")
+		} catch {
+			reject(ErrorCode.setupError.rawValue, "\(error)", nil)
+		}
+	}
+
+	@objc
+	func getState(
+		_ resolve: RCTPromiseResolveBlock,
+		rejecter reject: RCTPromiseRejectBlock
+	) {
+		let value = "\(MoveSDK.shared.getSDKState())".uppercased()
+		resolve(value)
+	}
+
+	@objc
+	func getAuthState(
+		_ resolve: RCTPromiseResolveBlock,
+		rejecter reject: RCTPromiseRejectBlock
+	) {
+		let value = "\(MoveSDK.shared.getAuthState())".uppercased()
+		resolve(value)
+	}
+
+	@objc
+	func setAssistanceMetaData(_ data: String) {
+
+	}
+
+	@objc
+	func geocode(_ latitude: Double, _ longitude: Double,
+				 resolver resolve: @escaping RCTPromiseResolveBlock,
+				 rejecter reject: @escaping RCTPromiseRejectBlock
+	) {
+		MoveSDK.shared.geocode(latitude: latitude, longitude: longitude) { result in
+			switch result {
+			case let .success(value):
+				resolve(value)
+			case let .failure(err):
+				switch err {
+				case .resolveFailed:
+					reject(ErrorCode.resolveFailed.rawValue, nil, nil)
+				case .serviceUnreachable:
+					reject(ErrorCode.serviceUnavailable.rawValue, nil, nil)
+				case .thresholdReached:
+					reject(ErrorCode.thresholdReached.rawValue, nil, nil)
+				@unknown default:
+					reject(ErrorCode.geocodeError.rawValue, nil, nil)
+				}
+			}
+		}
+	}
+
+	@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, userID: contractId, projectID: productId)
+
+		MoveSDKLauncher.shared.sdk.update(auth: auth) { configurationError in
+			if let configurationError = configurationError {
+				switch configurationError {
+				case .authInvalid:
+					reject(ErrorCode.authInvalid.rawValue, nil, nil)
+				@unknown default:
+					reject(ErrorCode.configurationError.rawValue, nil, nil)
+				}
+			} else {
+				resolve("OK")
+			}
+		}
+	}
+
+	@objc
+	func getTripState(
+		_ resolve: RCTPromiseResolveBlock,
+		rejecter reject: RCTPromiseRejectBlock
+	) {
+		let value = "\(MoveSDK.shared.getTripState())".uppercased()
+		resolve(value)
+	}
+
+	@objc
+	func getWarnings(
+		_ resolve: RCTPromiseResolveBlock,
+		rejecter reject: RCTPromiseRejectBlock
+	) {
+		resolve(MoveSDKLauncher.shared.getServiceWarnings())
+	}
+
+	@objc
+	func getErrors(
+		_ resolve: RCTPromiseResolveBlock,
+		rejecter reject: RCTPromiseRejectBlock
+	) {
+		resolve(MoveSDKLauncher.shared.getServiceFailures())
+	}
+
+	@objc
+	func startAutomaticDetection() {
+		MoveSDK.shared.startAutomaticDetection()
+	}
+
+	@objc
+	func stopAutomaticDetection() {
+		MoveSDK.shared.stopAutomaticDetection()
+	}
+
+	@objc
+	func shutdown() {
+		MoveSDKLauncher.shared.shutdown()
+	}
+
+	@objc
+	func forceTripRecognition() {
+		MoveSDKLauncher.shared.sdk.forceTripRecognition()
+	}
+
+	@objc
+	func synchronizeUserData(
+		_ resolve: @escaping RCTPromiseResolveBlock,
+		rejecter reject: @escaping RCTPromiseRejectBlock) {
+		MoveSDKLauncher.shared.sdk.synchronizeUserData() { success in
+			resolve(success)
+		}
+	}
+
+	@objc
+	func initiateAssistanceCall(
+		_ resolve: @escaping(RCTPromiseResolveBlock),
+		rejecter reject: @escaping(RCTPromiseRejectBlock)
+	) {
+		MoveSDKLauncher.shared.sdk.initiateAssistanceCall { status in
+			switch status {
+			case .success:
+				resolve(true)
+			case .initializationError:
+				reject(ErrorCode.initializationError.rawValue, nil, nil)
+			case .locationError:
+				reject(ErrorCode.locationError.rawValue, nil, nil)
+			case .networkError:
+				reject(ErrorCode.networkError.rawValue, nil, nil)
+			@unknown default:
+				reject(ErrorCode.assistanceCallError.rawValue, nil, nil)
+			}
+		}
+	}
+
+	@objc
+	func ignoreCurrentTrip() {
+		MoveSDKLauncher.shared.sdk.ignoreCurrentTrip()
+	}
+
+	@objc
+	func finishCurrentTrip() {
+		MoveSDKLauncher.shared.sdk.finishCurrentTrip()
+	}
+
+	@objc
+	func resolveError() {
+		MoveSDKLauncher.shared.sdk.resolveSDKStateError()
+	}
+
+	@objc
+	func sendAppEvent(_ eventInfo: NSString) {
+		send(event: .appEvent, data: ["eventInfo": "\(eventInfo)"])
+	}
+
+	@objc
+	func requestMotionPermission() {
+		motionManager.queryActivityStarting(from: Date(), to: Date(), to: OperationQueue.main) { _, error in
+		}
+	}
+
+	@objc public static func initIfPossible(launchOptions: [UIApplication.LaunchOptionsKey: Any]?) {
+		MoveSDKLauncher.shared.initIfPossibleWith(launchOptions: launchOptions)
+	}
+
+	@objc public static func performBackgroundFetch(_ completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
+		MoveSDKLauncher.shared.performBackgroundFetch(completionHandler)
+	}
+
+	override func supportedEvents() -> [String]! {
+		MoveSDKLauncher.Event.allCases.map { $0.rawValue }
+	}
+
+	static override func moduleName() -> String! {
+		return "MoveSdk"
+	}
+
+	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 RCTMoveSdk: MoveSDKLauncherDelegate {
+	func send(event: MoveSDKLauncher.Event, data: [String: Any]) {
+		sendEvent(withName: event.rawValue, body: data)
+	}
+}
+
+internal class MoveSDKLauncher {
+	internal enum Event: String, CaseIterable {
+		case appEvent = "MOVE_SDK_APP_EVENT"
+		case sdkState = "MOVE_SDK_STATE"
+		case tripState = "MOVE_SDK_TRIP_STATE"
+		case authState = "MOVE_SDK_AUTH_STATE"
+		case warning = "MOVE_SDK_WARNINGS"
+		case failure = "MOVE_SDK_ERRORS"
+	}
+
+	private enum DefaultsKey: String {
+		case auth = "MOVE.WRAPPER.AUTH"
+		case config = "MOVE.WRAPPER.CONFIG"
+	}
+
+	weak var delegate: MoveSDKLauncherDelegate?
+
+	static let shared = MoveSDKLauncher()
+
+	let sdk = MoveSDK.shared
+	var launchOptions: [UIApplication.LaunchOptionsKey: Any]?
+
+	init() {
+		sdk.setSDKStateListener { state in
+			let value = "\(state)".uppercased()
+			self.delegate?.send(event: .sdkState, data: ["state": "\(value)"])
+		}
+
+		sdk.setTripStateListener { state in
+			let value = "\(state)".uppercased()
+			self.delegate?.send(event: .tripState, data: ["state": "\(value)"])
+		}
+
+		sdk.setAuthStateUpdateListener { state in
+			let value = "\(state)".uppercased()
+			self.delegate?.send(event: .authState, data: ["state": "\(value)"])
+		}
+
+		sdk.setServiceFailureListener { failures in
+			let data: [String: Any] = ["errors": self.convert(failures: failures)]
+			self.delegate?.send(event: .failure, data: data)
+		}
+
+		sdk.setServiceWarningListener { warnings in
+			let data: [String: Any] = ["warnings": self.convert(warnings: warnings)]
+			self.delegate?.send(event: .warning, data: data)
+		}
+	}
+
+	func getServiceWarnings() -> [MoveSDKErrorListItem] {
+		return convert(warnings: sdk.getServiceWarnings())
+	}
+
+	func getServiceFailures() -> [MoveSDKErrorListItem] {
+		return convert(failures: sdk.getServiceFailures())
+	}
+
+	func convert(service: DolphinMoveSDK.MoveConfig.DetectionService) -> String {
+		return service.debugDescription
+//		switch service {
+//		case let .driving(sub):
+//			if sub.isEmpty {
+//				return "DRIVING"
+//			} else {
+//				return service.debugDescription
+//			}
+//		case .cycling:
+//			return "CYCLING"
+//		case let .walking(sub):
+//			if sub.isEmpty {
+//				return "WALKING"
+//			} else {
+//				return service.debugDescription
+//			}
+//		case .places:
+//			return "PLACES"
+//		case .publicTransport:
+//			return "PUBLIC_TRANSPORT"
+//		case .pointsOfInterest:
+//			return "POINTS_OF_INTEREST"
+//		case .automaticImpactDetection:
+//			return "AUTOMATIC_IMPACT_DETECTION"
+//		case .assistanceCall:
+//			return "ASSISTANCE_CALL"
+//		@unknown default:
+//			return service.debugDescription
+//		}
+	}
+
+	func convert(failures: [DolphinMoveSDK.MoveServiceFailure]) -> [MoveSDKErrorListItem] {
+		var converted: [MoveSDKErrorListItem] = []
+
+		for failure in failures {
+			var reasons: [String] = []
+			switch failure.reason {
+			case let .missingPermission(permissions):
+				let content: [String] = permissions.map { self.permissionString($0) }
+				reasons = content
+			case .unauthorized:
+				reasons = ["Unauthorized"]
+			@unknown default:
+				break
+			}
+			converted.append(["service": convert(service: failure.service), "reasons": reasons])
+		}
+
+		return converted
+	}
+
+	func convert(warnings: [DolphinMoveSDK.MoveServiceWarning]) -> [MoveSDKErrorListItem] {
+		var converted: [MoveSDKErrorListItem] = []
+
+		for warning in warnings {
+			var reasons: [String] = []
+			switch warning.reason {
+			case let .missingPermission(permissions):
+				let content: [String] = permissions.map { self.permissionString($0) }
+				reasons = content
+			@unknown default:
+				break
+			}
+			converted.append(["service": convert(service: warning.service), "reasons": reasons])
+		}
+
+		return converted
+	}
+
+	func permissionString(_ permission: DolphinMoveSDK.MovePermission) -> String {
+		switch permission {
+		case .location:
+			return "LOCATION_PERMISSION_MISSING"
+		case .backgroundLocation:
+			return "BACKGROUND_PERMISSION_MISSING"
+		case .preciseLocation:
+			return "PRECISE_LOCATION_PERMISSION_MISSING"
+		case .motionActivity:
+			return "MOTION_PERMISSION_MISSING"
+		case .gyroscope:
+			return "GYROSCOPE_BROKEN"
+		case .accelerometer:
+			return "ACCELEROMETER_BROKEN"
+		@unknown default:
+			return "UNKNOWN"
+		}
+	}
+
+	internal func initIfPossibleWith(launchOptions: [UIApplication.LaunchOptionsKey: Any]?) {
+		self.launchOptions = launchOptions
+		MoveSDK.shared.initialize(launchOptions: launchOptions)
+
+		let oldConfig: OldConfig? = MoveSDKLauncher.decode(.config)
+		let oldAuth: OldAuth? = MoveSDKLauncher.decode(.auth)
+
+		/// migrate
+		if let oldAuth = oldAuth, let oldConfig = oldConfig {
+			let auth = DolphinMoveSDK.MoveAuth(userToken: oldAuth.userToken, refreshToken: oldAuth.refreshToken, userID: oldAuth.contractID, projectID: oldAuth.productID)
+
+			MoveSDK.shared.setup(auth: auth, config: oldConfig.convert())
+			MoveSDKLauncher.encode(nil as OldAuth?, forKey: .auth)
+		}
+
+		let isInRunningState = UserDefaults.standard.bool(forKey: "MOVE.WRAPPER.RUNNING")
+		if isInRunningState {
+			sdk.startAutomaticDetection()
+			UserDefaults.standard.removeObject(forKey: "MOVE.WRAPPER.RUNNING")
+		}
+	}
+
+	internal func performBackgroundFetch(_ completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
+		MoveSDK.shared.performBackgroundFetch(completionHandler)
+	}
+
+	internal func setup(auth: DolphinMoveSDK.MoveAuth, config: DolphinMoveSDK.MoveConfig) {
+		MoveSDK.shared.setup(auth: auth, config: config)
+	}
+
+	func shutdown() {
+		sdk.shutDown()
+	}
+
+	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)
+		}
+	}
+}
+
+struct OldAuth: Codable {
+	var userToken: String
+	var refreshToken: String
+	var contractID: String
+	var productID: Int64
+}
+
+struct OldConfig: Codable {
+	/// Expresses modes of transport to be detected
+	enum TimelineDetectionService: Int, Codable {
+		/// Detect driving behaviour
+		case driving = 1
+
+		/// Detect cycling behaviour
+		case bicycle = 2
+
+		/// Detect walking behaviour
+		case walking = 3
+
+		/// Detect visits
+		case places = 4
+
+		case publicTransport = 5
+	}
+
+	/// Expresses driving services to be detected
+	enum DrivingService: Int, Codable {
+		/// Detect distraction free driving
+		case dfd = 101
+
+		/// Detect driving behaviour
+		case behaviour = 102
+	}
+
+	/// Expresses walking services to be detected
+	enum WalkingService: Int, Codable {
+		/// Detects GPS location for collected walking events
+		case location = 301
+	}
+
+	/// Expresses other services to be detected
+	enum OtherService: Int, Codable {
+		/// Monitor points of intrest
+		case poi = 401
+		case impact = 402
+	}
+
+	var timelineDetectionService: [TimelineDetectionService]
+	var drivingServices: [DrivingService]
+	var walkingServices: [WalkingService]
+	var otherServices: [OtherService]
+	var tripStatusUpdateFrequency: Double = -1
+
+	func convert() -> DolphinMoveSDK.MoveConfig {
+		let driving: [DolphinMoveSDK.MoveConfig.DrivingService] = drivingServices.map {
+			switch $0 {
+			case .behaviour:
+				return .drivingBehavior
+			case .dfd:
+				return .distractionFreeDriving
+			}
+		}
+
+		let walking: [DolphinMoveSDK.MoveConfig.WalkingService] = walkingServices.map {
+			switch $0 {
+			case .location:
+				return .location
+			}
+		}
+
+		let services: [DolphinMoveSDK.MoveConfig.DetectionService] = timelineDetectionService.map {
+			switch $0 {
+
+			case .driving:
+				return .driving(driving)
+			case .bicycle:
+				return .cycling
+			case .walking:
+				return .walking(walking)
+			case .places:
+				return .places
+			case .publicTransport:
+				return .publicTransport
+			}
+		}
+
+		let otherServices: [DolphinMoveSDK.MoveConfig.DetectionService] = otherServices.map {
+			switch $0 {
+			case .poi:
+				return .pointsOfInterest
+			case .impact:
+				return .automaticImpactDetection
+			}
+		}
+
+		return DolphinMoveSDK.MoveConfig(detectionService: services + otherServices)
+	}
+}