react-native-spike-sdk 0.2.10 → 1.0.0

package/README.md

@@ -1,207 +1,170 @@
-# Spike ReactNative SDK
+Spike ReactNative SDK is a library on top of Apple HealthKit and Android HealthConnect that 
 
-Spike API for health and productivity data from wearables and IoT devices
+1.  helps with the extraction of data.
 
-# Table of contents
+2.  pushes data to SpikeAPI and delivers standardized data.
 
-- [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
 
-## Requirements <a name="requirements"></a>
+*   iOS 13.0+
 
-- iOS 13.0+
+*   Android 9.0+
 
-#### Add Capabilities
+### iOS Signing & Capabilities
 
-To add HealthKit support to your application's `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.
+*   Open the ios/ folder of your project in Xcode
 
-#### Update Info.plist
+*   Select the project name in the left sidebar
 
-Add Health Kit permissions descriptions to your `ios/<Project Name>/Info.plist` file.
+*   Open Signing & Capabilities section
 
-```
+*   In the main view select '+ Capability' and double click HealthKit
+
+*   Allow Clinical Health Records.
+
+
+![](https://archbee-image-uploads.s3.amazonaws.com/Gq3NSKcNtQuC0xEw-R9rS/m1edxa1O8BQ9j1xchz9Qq_signing-capabilities2x.png)
+
+More details you can find [here](https://developer.apple.com/documentation/healthkit/setting_up_healthkit).
+
+### Info.plist
+
+Add Health Kit permissions descriptions to your Info.plist file.
+
+```xml
 <key>NSHealthShareUsageDescription</key>
-<string>We will use your health information to better track Prancercise workouts.</string>
+<string>We will use your health information to better track workouts.</string>
 
 <key>NSHealthUpdateUsageDescription</key>
-<string>We will update your health information to better track Prancercise workouts.</string>
+<string>We will update your health information to better track workouts.</string>
 
 <key>NSHealthClinicalHealthRecordsShareUsageDescription</key>
-<string>We will use your health information to better track Prancercise workouts.</string>
+<string>We will use your health information to better track  workouts.</string>
 ```
 
-## Installation <a name="installation"></a>
+## Installation
 
 Install the react-native-spike-sdk package from [npm](https://www.npmjs.com/package/react-native-spike-sdk)
 
-```
-yarn add 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>
+## Configuration
 
-Import SpikeSDK on ReactNative level
+&#x20;    1\. Import Spike to your project.
 
-```
-import Spike from 'react-native-spike-sdk';
-```
+> import Spike from 'react-native-spike-sdk';
 
-Add Spike initialization code to `ios/<Project Name>/AppDelegate.mm` file inside `application:didFinishLaunchingWithOptions:` method.
+&#x20;    2\. Add Spike initialization code to `ios/<Project Name>/AppDelegate.mm` file inside `application:didFinishLaunchingWithOptions: `method.
 
-```
+```javascript
 #import <SpikeSDK/SpikeSDK-Swift.h>
 ...
 
 - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
 {
   ...
-  [[Spike shared] initialize];
+  [Spike configure];
   ...
 
 }
-```
 
-### Setup SpikeSDK Events <a name="delegate"></a>
+```
 
-Use `useSpikeEvents` hook to handle results from SpikeSDK.
+&#x20;    3\. To set up the React Native SDK, please provide the application ID, authentication token, and your customer user ID. You can find the application ID and authentication token in the Spike developer console. Personal identifiable information, such as emails, should not be part of user IDs.
 
-```
-import Spike, { useSpikeEvents } from 'react-native-spike-sdk';
+```javascript
+import Spike from 'react-native-spike-sdk';
 
-...
+const conn = await Spike.createConnection(
+  'my_app_id',
+  'my_app_access_token',
+  'my_user_id'
+);
 
-useSpikeEvents({
-  onInitialize: (uuid) => {
-    console.log(`Event: onInitialize: ${uuid}`);
-  },
-  onInitializationFailure: () => {
-    console.log('Event: onInitializationFailure');
-  },
-  onDataResult: (result: SpikeResult) => {
-    console.log(`Event: onDataResult: ${JSON.stringify(result)}`);
-  },
-  onDataFailure: () => {
-    console.log('Event: onDataFailure');
-  },
-  onWorkoutDataResult: (result: SpikeWorkoutResult) => {
-    console.log(`Event: onWorkoutDataResult: ${JSON.stringify(result)}`);
-  },
-  onWorkoutDataFailure: () => {
-    console.log('Event: onWorkoutDataFailure');
-  },
-  onSleepAnalysisDataResult: (result) => {
-    console.log(`Event: onSleepAnalysisDataResult: ${JSON.stringify(result)}`);
-  },
-  onSleepAnalysisDataFailure: () => {
-    console.log('Event: onSleepAnalysisDataFailure');
-  },
-  onLog: (log) => {
-    console.log(`Event Spike log: ${log}`);
-  },
-});
 ```
 
-`SpikeResult`, `SpikeWorkoutResult` and `SpikeSleepAnalysisResult` now contains of status or array of data.
-If you have provided `postbackURL` to setup method, `status` will be returned, otherwise `data`.
+## Getting and using data
 
-### Setup SpikeSDK <a name="setup_sdk"></a>
+Once a connection has been created data can be retrieved using the extractData method. The below example shows how to retrieve daily steps for today which are returned as part of the activities summary (An instance of SpikeData). The concrete type will depend on the data type requested.
 
-Provide `SpikeSDK` with client id, authorization token, user id and optionally postback url.
+```javascript
+// conn was created in the previous step
 
-```
-Spike.setup({CLIENT_ID}, {AUTH_TOKEN}, {USER_ID}, {URL/undefined});
-```
-
-Check for current session `Promise<string | undefined>`:
+/*
+* Extracting activities summary data for today.
+*/
+const activitiesSummary = await conn.extractData(
+  SpikeDataTypes.activitiesSummary
+);
 
-```
-await Spike.getCurrentUUID()
+/*
+* Accessing daily steps.
+*/
+console.log("Steps:", activitiesSummary.getEntries()[0].steps);
 ```
 
-Remove session data:
+### Extracting data by time range
 
-```
-Spike.clearData()
-```
+Params `from` and `to` enable the extraction of local device data for the given time range. The maximum allowed single-query time interval is 7 days. If required, data of any longer time period can be accessed by iterating multiple queries of 7 days.
 
-### Get data <a name="get_data"></a>
+```javascript
+const toDate = new Date(); // Today's date
 
-Get data for specified Spike Data types.
-Data will be provided for last 3 days.
-You can optionally provide date range which will return data for each day separately.
+const fromDate = new Date(toDate);
+fromDate.setDate(toDate.getDate() - 5); // 5 days ago
 
-```
-import Spike, { SpikeDataTypesAll } from 'react-native-spike-sdk';
+const activitiesSummary = await conn.extractData(
+  SpikeDataTypes.activitiesSummary,
+  fromDate,
+  toDate
+);
 
-...
 
-Spike.getData(SpikeDataTypesAll);
 ```
 
-or
+### Sending data to webhook
 
-```
-Spike.getData(['DataTypeHeartRate', 'DataTypeBasalEnergy'])
-```
+Extracts local device data for the given time range and sends it as a webhook notification to the customer’s backend.
 
-with date range (ex. get data for each 10 days of January 2023)
+```javascript
+import Spike from 'react-native-spike-sdk';
 
-```
-Spike.getDataInRange(SpikeDataTypesAll, new Date('2023-01-01'), new Date('2023-01-10'));
+const conn = await Spike.createConnection(
+  'my_app_id',
+  'my_app_access_token',
+  'my_user_id',
+  'https://example.com/data'
+);
+
+/*
+* Extracting and sending activities summary data.
+*/
+const response = await conn.extractAndPostData(
+  SpikeDataTypes.activitiesSummary,
+  fromDate,
+  toDate
+);
 ```
 
-All available Data types `SpikeDataType` or use all of the instantly `SpikeDataTypesAll`:
-`DataTypeStep`
-`DataTypeHeartRate`
-`DataTypeRestingHeartRate`
-`DataTypeActiveEnergy`
-`DataTypeBasalEnergy`
-`DataTypeAppleMoveTime`
-`DataTypeAppleExerciseTime`
-`DataTypeDistanceWalkingRunning`
-`DataTypeFloors`
-`DataTypeWorkout`
-`DataTypeSleepAnalysis`
-
-Getting `DataTypeWorkout` data will return result through the `onWorkoutDataResult` and `onWorkoutDataFailure` callbacks of `useSpikeEvents` hook.
-Getting `DataTypeSleepAnalysis` data will return result through the `onSleepAnalysisDataResult` and `onSleepAnalysisDataFailure` callbacks of `useSpikeEvents` hook.
-
-### Enable debug mode <a name="debug"></a>
-
-With enabled debug mode SpikeSDK will print performed actions.
-You can handle logs through the `onLog` callback of `useSpikeEvents` hook or
-see logs directly running application from Xcode. Use logs filter `[SpikeSDK]`.
-It is better to enable debug before calling `Spike.initialize();`.
+## Background Delivery
 
-```
-Spike.enableDebug();
-```
+Background delivery enables asynchronous data delivery to the customer backend by means of webhooks. It enables data updates to be sent to the backend even when the application is hidden or closed. Background delivery is only supported on iOS devices at the moment.
 
-## Background data updates <a name="background_updates"></a>
+### Signing & Capabilities
 
-Allow update data for specified Spike Data types and send it to Spike.
+Go to your target’s `Signing & Capabilities` section and add **Background Modes**.&#x20;
 
-#### Add Capabilities
+Allow **Background fetch.**
 
-Go to your target's `Signing & Capabilities` section and add Background Modes.
-Add background task identifier to app `Info.plist` file.
-Allow `Background fetch`. And check `Info.plist` for `UIBackgroundModes`.
+### Info.plist
 
-```
+Add background task identifier to app Info.plist file. And check Info.plist for `UIBackgroundModes`.
+
+```xml
 ...
 <key>BGTaskSchedulerPermittedIdentifiers</key>
 <array>
@@ -215,20 +178,182 @@ Allow `Background fetch`. And check `Info.plist` for `UIBackgroundModes`.
 ...
 ```
 
-#### Enable/Disable data background delivery
+### Example
 
-Enable Health data background delivery for specified Spike Data types.
+```javascript
+import Spike from 'react-native-spike-sdk';
 
-```
-Spike.enableBackgroundDelivery(SpikeDataTypesAll);
-```
+const conn = await Spike.createConnection(
+  'my_app_id',
+  'my_app_access_token',
+  'my_user_id',
+  'https://example.com/data'
+);
+
+/*
+* Enabling background delivery.
+*/
+conn.enableBackgroundDelivery(
+  [SpikeDataTypes.activitiesSummary]
+);
+```
+
+
+
+*   If `dataTypes` is not empty, then a daemon task is started which will listen for data updates coming from the platform and send them via webhooks in the background; the operation is not compound and new data types replace any previously configured ones should they exist;
+
+*   If `dataTypes` parameter is empty or null, then background data delivery is stopped for this connection if it was enabled;
+
+*   Function `conn.getBackgroundDeliveryDataTypes` gets the data types for which background delivery is enabled. If background delivery is not enabled, an empty set is returned.
+
+
+## Logging
+
+Internally, the React Native SDK supports logging on various levels to assist with troubleshooting. However, to avoid imposing additional third-party dependencies on library users, the SDK expects a concrete logging implementation to be provided externally. This can be done by implementing the SpikeLogger class and providing it when creating or unpacking a connection.
+
+Below is an example of how to implement a simple console logger.
+
+```javascript
+class ConsoleLogger implements SpikeLogger {
+    isDebugEnabled() {
+        return true;
+    }
+    
+    isInfoEnabled() {
+        return true;
+    }
+    
+    isErrorEnabled() {
+        return true;
+    }
+    
+    debug(message) {
+        console.log("DEBUG:", message);
+    }
+    
+    info(message) {
+        console.log("INFO:", message);
+    }
+    
+    error(message) {
+        console.log("ERROR:", message);
+    }
+}
 
-```
-Spike.disableAllBackgroundDelivery();
+const conn = Spike.createConnection(
+  'my_app_id',
+  'my_app_access_token',
+  'my_user_id',
+  new ConsoleLogger()
+);
 ```
 
-Check is background delivery is enabled `Promise<boolean>`.
+## Data types
+
+* SpikeDataTypes.activitiesStream
+* SpikeDataTypes.activitiesSummary
+* SpikeDataTypes.body
+* SpikeDataTypes.breathing
+* SpikeDataTypes.calories
+* SpikeDataTypes.distance
+* SpikeDataTypes.glucose
+* SpikeDataTypes.heart
+* SpikeDataTypes.info
+* SpikeDataTypes.oxygenSaturation
+* SpikeDataTypes.sleep
+* SpikeDataTypes.steps
+
+## Classes
+
+### Spike
+
+| Class | Method                      | Description                                                                                                                                                                                                                                                                                                                                                                       |
+| ----- | --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Spike | createConnection            | Creates a new SpikeConnection instance with the given user details.**Parameters**: appId, authToken, customerEndUserId, logger**Returns**: An instance of the SpikeConnection class.                                                                                                                                                                                              |
+| Spike | createConnection            | Creates a new connection instance with the given user details that is capable of delivering data to the customer backend via ***webhooks***.**Parameters**: appId, authToken, customerEndUserId, callbackUrl, logger**Returns**: An instance of the SpikeWebhookConnection class.                                                                                                 |
+| Spike | unpackConnection            | Restores a connection instance from a previously serialised state. A connection cannot be unpacked if a strong reference to a connection with the same session ID already exists.**Parameters:** connection, logger**Returns: **An instance of the SpikeConnection or SpikeWebhookConnection class. The method return type should be that of a base class, i.e., SpikeConnection. |
+| Spike | getBackgroundConnections    | Returns all connections that are configured to deliver data in the background.**Returns: **A collection (a set) of SpikeWebhookConnection instances.                                                                                                                                                                                                                              |
+| Spike | ensurePermissionsAreGranted | Verifies that platform-specific permissions corresponding to the Spike data types provided are granted. In the event that some permissions are not granted, a platform-specific permissions dialogue will be presented to the end-user.This method should only be invoked from a UI component**Parameters: **permissions (Set\<SpikeDataType>)                                    |
+
+### SpikeConnection
+
+| Class           | Method               | Description                                                                                                                                                                                                                                                                                                                                                                                      |
+| --------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| SpikeConnection | getAppId             | Retrieves the unique Spike application identifier.**Returns**: string                                                                                                                                                                                                                                                                                                                            |
+| SpikeConnection | getSpikeEndUserId    | Retrieves the unique identifier assigned to the end-user by Spike.**Returns**: string                                                                                                                                                                                                                                                                                                            |
+| SpikeConnection | getCustomerEndUserId | Retrieves the unique identifier assigned to the end-user by the customer.**Returns**: string                                                                                                                                                                                                                                                                                                     |
+| SpikeConnection | close                | Terminates any ongoing connections with Spike’s backend servers, clears any caches, and removes provided user details and tokens from the memory. Once the connection is closed, it cannot be used, and any method other than close() will throw a *SpikeConnectionIsClosed* exception.                                                                                                          |
+| SpikeConnection | extractData          | Extracts local device data for the current date in the end-user’s time zone.**Parameters**: dataType(SpikeDataType)**Returns**: An instance of SpikeData. The concrete type will depend on the data type requested.                                                                                                                                                                              |
+| SpikeConnection | extractData          | Extracts local device data for the given time range. ****The maximum allowed single-query time interval is 7 days. If required, data of any longer time period can be accessed by iterating multiple queries of 7 days.******Parameters**: dataType(SpikeDataType), from(DateTime), to(DateTime)**Returns**: An instance of SpikeData. The concrete type will depend on the data type requested. |
+| SpikeConnection | pack                 | Creates a string representation of the connection state. This method facilitates the persistence of connections.**Returns**: String                                                                                                                                                                                                                                                              |
+
+### SpikeWebhookConnection
+
+| Class                  | Method                         | Description                                                                                                                                                                                                                                                                                                                                                                                      |
+| ---------------------- | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| SpikeWebhookConnection | getAppId                       | Retrieves the unique Spike application identifier.**Returns**: string                                                                                                                                                                                                                                                                                                                            |
+| SpikeWebhookConnection | getSpikeEndUserId              | Retrieves the unique identifier assigned to the end-user by Spike.**Returns**: string                                                                                                                                                                                                                                                                                                            |
+| SpikeWebhookConnection | getCustomerEndUserId           | Retrieves the unique identifier assigned to the end-user by the customer.**Returns**: string                                                                                                                                                                                                                                                                                                     |
+| SpikeWebhookConnection | getCallbackUrl                 | Returns the URL that will receive webhook notifications.                                                                                                                                                                                                                                                                                                                                         |
+| SpikeWebhookConnection | close                          | Terminates any ongoing connections with Spike’s backend servers, clears any caches, and removes provided user details and tokens from the memory. Once the connection is closed, it cannot be used, and any method other than close() will throw a *SpikeConnectionIsClosed* exception.                                                                                                          |
+| SpikeWebhookConnection | extractData                    | Extracts local device data for the current date in the end-user’s time zone.**Parameters**: dataType(SpikeDataType)**Returns**: An instance of SpikeData. The concrete type will depend on the data type requested.                                                                                                                                                                              |
+| SpikeWebhookConnection | extractData                    | Extracts local device data for the given time range. ****The maximum allowed single-query time interval is 7 days. If required, data of any longer time period can be accessed by iterating multiple queries of 7 days.******Parameters**: dataType(SpikeDataType), from(DateTime), to(DateTime)**Returns**: An instance of SpikeData. The concrete type will depend on the data type requested. |
+| SpikeWebhookConnection | extractAndPostData             | Extracts local device data for the current date in the local user time zone and sends it as a webhook notification to the customer’s backend.**Parameters**: dataType(SpikeDataType)                                                                                                                                                                                                             |
+| SpikeWebhookConnection | extractAndPostData             | Extracts local device data for the given time range and sends it as a webhook notification to the customer’s backend.**Parameters**: dataType(SpikeDataType), from(DateTime), to(DateTime)                                                                                                                                                                                                       |
+| SpikeWebhookConnection | enableBackgroundDelivery&#xA;  | Enables background data delivery for selected data types. No-op on Android (for now).**Parameters**: dataType(SpikeDataType)                                                                                                                                                                                                                                                                     |
+| SpikeWebhookConnection | getBackgroundDeliveryDataTypes | Gets the data types for which background delivery is enabled. If background delivery is not enabled, an empty set is returned.**Returns**: Returns: A collection (a set) of SpikeDataType objects.                                                                                                                                                                                               |
+| SpikeWebhookConnection | pack                           | Creates a string representation of the connection state. This method facilitates the persistence of connections.**Returns**: String                                                                                                                                                                                                                                                              |
+| SpikeWebhookConnection | setListener                    | Sets a listener that is to handle notifications from the background delivery process.**Parameters: **listener(SpikeWebhookConnectionListener)*   If listener is not null, then any existing listener is replaced
+
+*   If listener is null, then any existing listener is removed                                                                                                                 |
+
+### SpikeWebhookConnectionListener
+
+Abstract class allowing to receive notifications from the background data delivery process.
+
+| Class                          | Method              | Description                                                                                                                 |
+| ------------------------------ | ------------------- | --------------------------------------------------------------------------------------------------------------------------- |
+| SpikeWebhookConnectionListener | onSubmissionFailure | Invoked on an asynchronous data submission failure.**Parameters**: webhookJob (SpikeWebhookJob), exception (SpikeException) |
+
+# Errors and Exceptions
+
+## SpikeException
+
+The abstract parent of all concrete exceptions.
+
+## SpikeConnectionAlreadyExistsException
+
+Thrown if an attempt to unpack a Spike connection is made while a strong reference to the same connection already exists.
+
+## SpikeConnectionIsClosedException
+
+Thrown if any method is invoked on [SpikeConnection](https://docs.google.com/document/d/1dB0m5QQ4kpTct-xP4mro9ok3NgwCpzS-dnaZLS9VRo8/edit#heading=h.293fovahtkh1) or one of its subclasses after the connection has been closed.
+
+## SpikeInvalidCredentialsException
+
+Thrown if the credentials provided are not recognised, i.e. are invalid or expired.
+
+## SpikeInvalidDateRangeException
+
+Thrown if duration exceeds the allowed maximum or if ‘from’ date is greater than ‘to’ date. The message will contain a specific cause description.
+
+## SpikeInvalidCallbackUrlException
+
+Thrown if the callback URL is not a valid URL, does not have HTTPS schema, or is not a sub-URL of the main callback URL configured for the application. The exception message will contain a specific reason.
+
+## SpikePackException
+
+Thrown when a connection cannot be serialised to a packed state. The exception cause will contain the underlying error.
+
+## SpikePermissionsNotGrantedException
+
+Thrown when Spike SDK is unable to access the data due to permissions not being granted.
+
+## SpikeServerException
+
+Whenever any operation with the Spike backend fails and the error does not fall into any of the above exceptions. The exception cause will contain the underlying error.
+
+## SpikeUnpackException
+
+Thrown when a connection cannot be deserialised from a packed state. The exception cause will contain the underlying error.
 
-```
-await Spike.isBackgroundUpdateEnabled();
-```

package/android/build.gradle

@@ -4,6 +4,7 @@ buildscript {
 
   repositories {
     google()
+    mavenLocal()
     mavenCentral()
   }
 
@@ -60,7 +61,15 @@ android {
 
 repositories {
   mavenCentral()
+  mavenLocal()
   google()
+  maven {
+    url 'https://spike-artifact-323760463254.d.codeartifact.eu-central-1.amazonaws.com/maven/maven-central-store/'
+    credentials {
+      username "aws"
+      password System.env.CODEARTIFACT_AUTH_TOKEN
+    }
+  }
 }
 
 def kotlin_version = getExtOrDefault("kotlinVersion")
@@ -69,8 +78,12 @@ 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 "com.facebook.react:react-android:0.71.3"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation "com.spikeapi.sdk:spike-sdk:1.0.2"
+  implementation 'androidx.core:core-ktx:1.10.0'
+  implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.6.1'
+  implementation 'com.google.code.gson:gson:2.10.1'
 }
 
 if (isNewArchitectureEnabled()) {

package/android/gradle.properties

@@ -1,5 +1,6 @@
 SpikeSdk_kotlinVersion=1.7.0
-SpikeSdk_minSdkVersion=21
+SpikeSdk_minSdkVersion=28
 SpikeSdk_targetSdkVersion=31
 SpikeSdk_compileSdkVersion=31
 SpikeSdk_ndkversion=21.4.7075529
+android.useAndroidX=true

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

@@ -0,0 +1,37 @@
+package com.spikesdk
+
+import com.spikeapi.SpikeLogger
+
+enum class SpikeLogLevel(val jsEventName: String) {
+    DEBUG(jsEventName = "onDebug"),
+    ERROR(jsEventName = "onError"),
+    INFO(jsEventName = "onInfo")
+}
+
+class SpikeConnectionLogger(
+    private val connectionUUID: String,
+    private val onLog: (
+        connectionUUID: String,
+        logLevel: SpikeLogLevel,
+        message: String
+    ) -> Unit
+) : SpikeLogger {
+
+    override fun debug(message: String) {
+        onLog(connectionUUID, SpikeLogLevel.DEBUG, message)
+    }
+
+    override fun error(message: String) {
+        onLog(connectionUUID, SpikeLogLevel.ERROR, message)
+    }
+
+    override fun info(message: String) {
+        onLog(connectionUUID, SpikeLogLevel.INFO, message)
+    }
+
+    override fun isDebugEnabled(): Boolean = true
+
+    override fun isErrorEnabled(): Boolean = true
+
+    override fun isInfoEnabled(): Boolean = true
+}

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

@@ -0,0 +1,61 @@
+package com.spikesdk
+
+import com.spikeapi.SpikeDataTypes
+import com.spikeapi.SpikeExceptions
+import com.spikeapi.healthconnect.HealthConnectAvailability
+import com.spikeapi.model.SpikeData
+import com.spikeapi.model.SpikeDataType
+import java.time.Instant
+import java.time.OffsetDateTime
+
+fun SpikeExceptions.mapException(): String {
+    return when (this) {
+        is SpikeExceptions.SpikeException -> "SpikeException"
+        SpikeExceptions.SpikeConnectionIsClosedException -> "SpikeConnectionIsClosedException"
+        SpikeExceptions.SpikeInvalidCredentialsException -> "SpikeInvalidCredentialsException"
+        SpikeExceptions.SpikeInvalidDateRangeException -> "SpikeInvalidDateRangeException"
+        SpikeExceptions.SpikeInvalidPostbackUrlException -> "SpikeInvalidPostbackUrlException"
+        SpikeExceptions.SpikePackException -> "SpikePackException"
+        SpikeExceptions.SpikePermissionsNotGrantedException -> "SpikePermissionsNotGrantedException"
+        is SpikeExceptions.SpikeServerException -> "SpikeServerException"
+        SpikeExceptions.SpikeUnpackException -> "SpikeUnpackException"
+    }
+}
+
+fun SpikeDataType<out SpikeData>.toStringType(): String = when (this) {
+    SpikeDataTypes.GLUCOSE -> "glucose"
+    SpikeDataTypes.HEART_RATE -> "heart"
+    SpikeDataTypes.SLEEP -> "sleep"
+    SpikeDataTypes.STEPS -> "steps"
+    SpikeDataTypes.ACTIVITIES_STREAM -> "activities_stream"
+    SpikeDataTypes.ACTIVITIES_SUMMARY -> "activities_summary"
+    SpikeDataTypes.BREATHING -> "breathing"
+    SpikeDataTypes.CALORIES -> "calories"
+    SpikeDataTypes.DISTANCE -> "distance"
+    SpikeDataTypes.OXYGEN_SATURATION -> "oxygen_saturation"
+    SpikeDataTypes.BODY -> "body"
+    else -> "activities_summary"
+}
+
+fun String.toSpikeDataType(): SpikeDataType<out SpikeData> = when (this) {
+    "glucose" -> SpikeDataTypes.GLUCOSE
+    "heart" -> SpikeDataTypes.HEART_RATE
+    "sleep" -> SpikeDataTypes.SLEEP
+    "steps" -> SpikeDataTypes.STEPS
+    "activities_stream" -> SpikeDataTypes.ACTIVITIES_STREAM
+    "activities_summary" -> SpikeDataTypes.ACTIVITIES_SUMMARY
+    "breathing" -> SpikeDataTypes.BREATHING
+    "calories" -> SpikeDataTypes.CALORIES
+    "distance" -> SpikeDataTypes.DISTANCE
+    "oxygen_saturation" -> SpikeDataTypes.OXYGEN_SATURATION
+    "body" -> SpikeDataTypes.BODY
+    else -> SpikeDataTypes.ACTIVITIES_SUMMARY
+}
+
+fun Long.millisToOffsetDataTime(): OffsetDateTime =
+    OffsetDateTime.ofInstant(Instant.ofEpochMilli(this), java.time.ZoneId.systemDefault())
+
+fun HealthConnectAvailability.toStringType(): String = when (this) {
+    HealthConnectAvailability.INSTALLED -> "installed"
+    HealthConnectAvailability.NOT_INSTALLED -> "notInstalled"
+}