react-native-spike-sdk 0.1.0

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2020 SpikeAPI <vytenis@spikeapi.com >
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,184 @@
+# Spike ReactNative SDK
+
+Spike API for health and productivity data from wearables and IoT devices
+
+# Table of contents
+
+- [Requirements](#requirements)
+- [Installation](#installation)
+- [Configure and Start](#configure)
+  - [Setup SpikeSDKDelegate](#delegate)
+  - [Setup SpikeSDK](#setup_sdk)
+  - [Get data](#get_data)
+  - [Enable debug mode](#debug)
+- [Background data updates](#background_updates)
+
+## Requirements <a name="requirements"></a>
+
+- iOS 13.0+
+
+#### Add Capabilities
+
+To add HealthKit support to your application's `Capabilities`
+
+- Open the `ios/` folder of your project in Xcode
+- Select the project name in the left sidebar
+- Open `Signing & Capabilities` section.
+- In the main view select '+ Capability' and double click `HealthKit`
+- Allow `Clinical Health Records` and `Background Delivery` if needed.
+
+#### Update Info.plist
+
+Add Health Kit permissions descriptions to your `ios/<Project Name>/Info.plist` file.
+
+```
+<key>NSHealthShareUsageDescription</key>
+<string>We will use your health information to better track Prancercise workouts.</string>
+
+<key>NSHealthUpdateUsageDescription</key>
+<string>We will update your health information to better track Prancercise workouts.</string>
+
+<key>NSHealthClinicalHealthRecordsShareUsageDescription</key>
+<string>We will use your health information to better track Prancercise workouts.</string>
+```
+
+## Installation <a name="installation"></a>
+
+Install the react-native-spike-sdk package from [npm](https://www.npmjs.com/package/react-native-spike-sdk)
+
+```
+yarn add react-native-spike-sdk
+```
+
+Use `pod install` and `pod update` commands from `ios/` folder of your app to install/update pods afterward.
+
+## Configure and Start <a name="configure"></a>
+
+Import SpikeSDK
+
+```
+import Spike from 'react-native-spike-sdk';
+```
+
+Add Spike initialization code to `App.tsx` file outside the App component.
+
+```
+Spike.initialize();
+```
+
+### Setup SpikeSDK Events <a name="delegate"></a>
+
+Use `useSpikeEvents` hook to handle results from SpikeSDK.
+
+```
+import Spike, { useSpikeEvents } from 'react-native-spike-sdk';
+
+...
+
+useSpikeEvents({
+  onInitialize: (uuid) => {
+    console.log(`Event: onInitialize: ${uuid}`);
+  },
+  onInitializationFailure: () => {
+    console.log('Event: onInitializationFailure');
+  },
+  onDataResult: (result) => {
+    console.log(`Event: onDataResult: ${JSON.stringify(result)}`);
+  },
+  onDataFailure: () => {
+    console.log('Event: onDataFailure');
+  },
+});
+```
+
+### Setup SpikeSDK <a name="setup_sdk"></a>
+
+Provide `SpikeSDK` with client id, authorization token, user id and optionally postback url.
+
+```
+Spike.setup({CLIENT_ID}, {AUTH_TOKEN}, {USER_ID}, {URL/undefined});
+```
+
+Check for current session `Promise<string | undefined>`:
+
+```
+await Spike.getCurrentUUID()
+```
+
+Remove session data:
+
+```
+Spike.clearData()
+```
+
+### Get data <a name="get_data"></a>
+
+Get data for specified Spike Data types.
+
+```
+import Spike, { SpikeDataTypesAll } from 'react-native-spike-sdk';
+
+...
+
+Spike.getData(SpikeDataTypesAll);
+```
+
+or
+
+```
+Spike.getData(['DataTypeHeartRate', 'DataTypeBasalEnergy'])
+```
+
+All available Data types `SpikeDataType` or use all of the instantly `SpikeDataTypesAll`:
+`DataTypeStep`
+`DataTypeHeartRate`
+`DataTypeRestingHeartRate`
+`DataTypeActiveEnergy`
+`DataTypeBasalEnergy`
+`DataTypeAppleMoveTime`
+`DataTypeAppleExerciseTime`
+
+### Enable debug mode <a name="debug"></a>
+
+With enabled debug mode SpikeSDK will print performed actions.
+You can see logs directly running application from Xcode. Use logs filter `[SpikeSDK]`.
+It is better to call this before calling `Spike.initialize();`.
+
+```
+Spike.enableDebug();
+```
+
+## Background data updates <a name="background_updates"></a>
+
+Allow update data for specified Spike Data types and send it to Spike.
+
+#### Add Capabilities
+
+Go to your target's `Signing & Capabilities` section and add Background Modes. Allow `Background fetch`. And check `Info.plist` for `UIBackgroundModes`.
+
+```
+...
+<key>UIBackgroundModes</key>
+<array>
+    <string>fetch</string>
+</array>
+...
+```
+
+#### Enable/Disable data background delivery
+
+Enable Health data background delivery for specified Spike Data types.
+
+```
+Spike.enableBackgroundDelivery(SpikeDataTypesAll);
+```
+
+```
+Spike.disableAllBackgroundDelivery();
+```
+
+Check is background delivery is enabled `Promise<boolean>`.
+
+```
+await Spike.isBackgroundUpdateEnabled();
+```

package/android/build.gradle

@@ -0,0 +1,82 @@
+buildscript {
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["SpikeSdk_kotlinVersion"]
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.1"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["SpikeSdk_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["SpikeSdk_" + name]).toInteger()
+}
+
+android {
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+  }
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "SpikeSdk"
+    codegenJavaPackageName = "com.spikesdk"
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+SpikeSdk_kotlinVersion=1.7.0
+SpikeSdk_minSdkVersion=21
+SpikeSdk_targetSdkVersion=31
+SpikeSdk_compileSdkVersion=31
+SpikeSdk_ndkversion=21.4.7075529

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.spikesdk">
+
+</manifest>

package/android/src/main/java/com/spikesdk/SpikeSdkModule.kt

@@ -0,0 +1,18 @@
+package com.spikesdk
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.Promise
+
+class SpikeSdkModule(reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  companion object {
+    const val NAME = "SpikeSdk"
+  }
+}

package/android/src/main/java/com/spikesdk/SpikeSdkPackage.kt

@@ -0,0 +1,17 @@
+package com.spikesdk
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+
+class SpikeSdkPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(SpikeSdkModule(reactContext))
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

package/ios/SpikeSdk-Bridging-Header.h

@@ -0,0 +1,2 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>

package/ios/SpikeSdk.m

@@ -0,0 +1,36 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(SpikeSdk, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(isBackgroundUpdateEnabled: (RCTPromiseResolveBlock)resolve
+                  withRejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(enableDebug)
+
+RCT_EXTERN_METHOD(initialize)
+
+RCT_EXTERN_METHOD(setupWithURL: (NSString)clientId
+                  withAuthToken: (NSString)authToken
+                  withUserId: (NSString)userId
+                  withPostbackURL: (NSString)postbackURL)
+
+RCT_EXTERN_METHOD(setup: (NSString)clientId
+                  withAuthToken: (NSString)authToken
+                  withUserId: (NSString)userId)
+
+RCT_EXTERN_METHOD(getCurrentUUID: (RCTPromiseResolveBlock)resolve
+                  withRejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(clearData)
+
+RCT_EXTERN_METHOD(getData: (NSArray<NSString>)dataTypes)
+
+RCT_EXTERN_METHOD(enableBackgroundDelivery: (NSArray<NSString>)dataTypes 
+                  withResolver: (RCTPromiseResolveBlock)resolve
+                  withRejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(disableAllBackgroundDelivery: (RCTPromiseResolveBlock)resolve
+                  withRejecter: (RCTPromiseRejectBlock)reject)
+
+@end

package/ios/SpikeSdk.swift

@@ -0,0 +1,135 @@
+import Foundation
+import SpikeSDK
+import React
+
+@objc(SpikeSdk)
+class SpikeSdk: RCTEventEmitter {
+
+    override init() {
+        super.init()
+
+        Spike.shared.delegate = self
+    }
+
+    @objc(isBackgroundUpdateEnabled:withRejecter:)
+    func isBackgroundUpdateEnabled(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        resolve(Spike.shared.isBackgroundUpdateEnabled) 
+    }
+
+    @objc(enableDebug)
+    func enableDebug() {
+        Spike.shared.enableDebug()
+    }
+
+    @objc(initialize)
+    func initialize() {
+        Spike.shared.initialize()
+    }
+
+    @objc(setup:withAuthToken:withUserId:)
+    func setup(clientId: String,
+            authToken: String,
+            userId: String) {
+        Spike.shared.setup(clientId: clientId, authToken: authToken, userId: userId)
+    }
+    
+    @objc(setupWithURL:withAuthToken:withUserId:withPostbackURL:)
+    func setupWithURL(clientId: String,
+            authToken: String,
+            userId: String,
+            postbackURL: String?) {
+        Spike.shared.setup(clientId: clientId, authToken: authToken, userId: userId, postbackURL: postbackURL)
+    }
+
+    @objc(getCurrentUUID:withRejecter:)
+    func getCurrentUUID(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        resolve(Spike.shared.getCurrentUUID() ?? "")
+    }
+    
+    @objc(clearData)
+    func clearData() {
+        Spike.shared.clearData()
+    }
+    
+    @objc(getData:)
+    func getData(dataTypes: [String]) {
+        let types = extractDataTypes(dataTypes)
+        Spike.shared.getData(for: types)
+    }
+    
+    @objc(enableBackgroundDelivery:withResolver:withRejecter:)
+    func enableBackgroundDelivery(dataTypes: [String],
+            resolve:  @escaping RCTPromiseResolveBlock,
+            reject: RCTPromiseRejectBlock) {
+        let types = extractDataTypes(dataTypes)
+        Spike.shared.enableBackgroundDelivery(for: types) {
+            resolve(Void.self)
+        }
+    }
+    
+    @objc(disableAllBackgroundDelivery:withRejecter:)
+    func disableAllBackgroundDelivery(resolve:  @escaping RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        Spike.shared.disableAllBackgroundDelivery() {
+            resolve(Void.self)
+        }
+    }
+
+    override func supportedEvents() -> [String]! {
+        return [
+            "onInitialize", 
+            "onInitializationFailure", 
+            "onDataResult", 
+            "onDataFailure", 
+        ]
+    }
+
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+
+    private func extractDataTypes(_ types: [String]) -> [SpikeDataTypes] {
+        return types.compactMap { type in
+            switch (type) {
+            case "DataTypeStep":
+                return SpikeDataTypes.step
+            case "DataTypeHeartRate":
+                return SpikeDataTypes.heartRate
+            case "DataTypeRestingHeartRate":
+                return SpikeDataTypes.restingHeartRate
+            case "DataTypeActiveEnergy":
+                return SpikeDataTypes.activeEnergy
+            case "DataTypeBasalEnergy":
+                return SpikeDataTypes.basalEnergy
+            case "DataTypeAppleMoveTime":
+                return SpikeDataTypes.appleMoveTime
+            case "DataTypeAppleExerciseTime":
+                return SpikeDataTypes.appleExerciseTime
+            default:
+                return nil
+            }
+        }
+    }
+}
+
+extension SpikeSdk: SpikeDelegate {
+    
+    func spikeInitialized(with uuid: String) {
+        sendEvent(withName: "onInitialize", body: ["uuid": uuid])
+    }
+    
+    func spikeInitializationFailure() {
+        sendEvent(withName: "onInitializationFailure", body: [:])
+    }
+    
+    func spikeDataResult(_ result: [SpikeResultData]) { 
+        if let dataString = try? String(data: JSONEncoder().encode(result), encoding: .utf8){
+            sendEvent(withName: "onDataResult", body: ["resultJson": dataString])
+        } else {
+            sendEvent(withName: "onDataResult", body: ["resultJson": "[]"])
+        }
+    }
+    
+    func spikeDataFailure() {
+        sendEvent(withName: "onDataFailure", body: [:])
+    }
+}