@prelude.so/react-native-sdk 0.1.0

package/README.md

@@ -0,0 +1,71 @@
+# Readme
+### Using the Expo React Native SDK
+
+The Expo React Native SDK allows you to capture certain device signals (both in Android and iOS) that will be reported back to Prelude.
+
+It is provided as an Expo module that you can integrate into your React Native Expo Application.
+
+The Android `minSdkVersion` value in the SDK is set to 26 (Android 8.0). If you application has a lower value you may need to update it.
+
+## Configuring the project
+
+First install the SDK dependency in your app:
+
+```
+npm install @prelude.so/react-native-sdk
+```
+
+Then, where ever in your application you want to report the device signals you can use code like this:
+
+```
+...
+// Import the react state types
+import { useEffect, useState } from "react";
+// Import the SDK types
+import * as PreludeReactNativeSdk from '@prelude.so/react-native-sdk';
+...
+
+// Define a state to receive status updates
+const [dispatchStatus, setDispatchStatus] = useState({ dispatchID: "", status: "" });
+
+...
+// Subscribe to the event
+useEffect(() => {
+    const subscription = PreludeReactNativeSdk.onDispatchingSignals((dispatchingSignalsStatus) => {
+      console.log("Dispatch status: " + dispatchingSignalsStatus.status + ". Id: " + dispatchingSignalsStatus.dispatchID);
+      setDispatchStatus(dispatchingSignalsStatus);
+    });
+
+    return () => {
+      subscription.remove();
+    }
+  }, [dispatchStatus]);
+
+...
+// Submit the signals in any of your app event handlers (here is a button example)
+<Button title={`Dispatch Signals`} onPress={() =>
+  PreludeReactNativeSdk.dispatchSignals({
+      sdk_key: "YOUR-SDK-KEY"
+    })
+    .catch((error) => {
+        console.log("Dispatch error: " + error);
+    })
+} />
+
+```
+
+Then run the Expo application normally (in your application's directory):
+
+```
+npx expo run:ios
+```
+
+or
+
+```
+npx expo run:android
+```
+
+Once you get the dispatch ID through the event, you can report it back to your own API to be forwarded in subsequent network calls.
+
+There is no restriction on when to call this API, you just need to take this action before you need to report back the dispatch ID. It is advisable to make the request early on during the user onboarding process to have the dispatch id available when required.

package/android/build.gradle

@@ -0,0 +1,47 @@
+apply plugin: 'com.android.library'
+
+group = 'so.prelude.reactnative.sdk'
+version = '0.1.0'
+
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+apply from: expoModulesCorePlugin
+applyKotlinExpoModulesCorePlugin()
+useCoreDependencies()
+useExpoPublishing()
+
+// If you want to use the managed Android SDK versions from expo-modules-core, set this to true.
+// The Android SDK versions will be bumped from time to time in SDK releases and may introduce breaking changes in your module code.
+// Most of the time, you may like to manage the Android SDK versions yourself.
+def useManagedAndroidSdkVersions = false
+if (useManagedAndroidSdkVersions) {
+  useDefaultAndroidSdkVersions()
+} else {
+  buildscript {
+    // Simple helper that allows the root project to override versions declared by this library.
+    ext.safeExtGet = { prop, fallback ->
+      rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+  }
+  project.android {
+    compileSdkVersion safeExtGet("compileSdkVersion", 34)
+    defaultConfig {
+      minSdkVersion safeExtGet("minSdkVersion", 21)
+      targetSdkVersion safeExtGet("targetSdkVersion", 34)
+    }
+  }
+}
+
+android {
+  namespace "so.prelude.reactnative.sdk"
+  defaultConfig {
+    versionCode 1
+    versionName "0.1.0"
+  }
+  lintOptions {
+    abortOnError false
+  }
+}
+
+dependencies {
+  implementation('so.prelude.android:sdk:0.1.0')
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest>
+</manifest>

package/android/src/main/java/so/prelude/reactnative/sdk/PreludeReactNativeSdkModule.kt

@@ -0,0 +1,44 @@
+package so.prelude.reactnative.sdk
+
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import so.prelude.android.sdk.Configuration
+import so.prelude.android.sdk.Configuration.Companion.DEFAULT_REQUEST_TIMEOUT
+import so.prelude.android.sdk.DispatchStatusListener
+import so.prelude.android.sdk.Endpoint
+import so.prelude.android.sdk.Prelude
+
+class PreludeReactNativeSdkModule : Module() {
+    override fun definition() = ModuleDefinition {
+        Name("PreludeReactNativeSdk")
+
+        Events("onDispatchingSignals")
+
+        AsyncFunction("dispatchSignals") { sdkKey: String, endpointUrl: String?, timeoutMilliseconds: Long? ->
+
+            val endpoint: Endpoint = endpointUrl?.let {
+                Endpoint.Custom(it)
+            } ?: Endpoint.Default
+
+            val context = appContext.reactContext
+            context?.let {
+                Prelude(
+                    Configuration(
+                        it.applicationContext,
+                        sdkKey,
+                        endpoint,
+                        requestTimeout = timeoutMilliseconds ?: DEFAULT_REQUEST_TIMEOUT
+                    )
+                )
+                    .dispatchSignals { status: DispatchStatusListener.Status, dispatchId ->
+                        sendEvent(
+                            "onDispatchingSignals", mapOf(
+                                "status" to status,
+                                "dispatchID" to dispatchId
+                            )
+                        )
+                    }
+            }
+        }
+    }
+}

package/build/PreludeReactNativeSdk.types.d.ts

@@ -0,0 +1,10 @@
+export type DispatchingSignalsStatus = {
+    status: string;
+    dispatchID: string;
+};
+export type Configuration = {
+    sdk_key: string;
+    endpoint?: string;
+    timeout_milliseconds?: number;
+};
+//# sourceMappingURL=PreludeReactNativeSdk.types.d.ts.map

package/build/PreludeReactNativeSdk.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PreludeReactNativeSdk.types.d.ts","sourceRoot":"","sources":["../src/PreludeReactNativeSdk.types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,wBAAwB,GAAG;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B,CAAA"}

package/build/PreludeReactNativeSdk.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=PreludeReactNativeSdk.types.js.map

package/build/PreludeReactNativeSdk.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PreludeReactNativeSdk.types.js","sourceRoot":"","sources":["../src/PreludeReactNativeSdk.types.ts"],"names":[],"mappings":"","sourcesContent":["export type DispatchingSignalsStatus = {\n  status: string,\n  dispatchID: string;\n};\n\nexport type Configuration = {\n  sdk_key: string;\n  endpoint?: string;\n  timeout_milliseconds?: number;\n}"]}

package/build/PreludeReactNativeSdkModule.d.ts

@@ -0,0 +1,3 @@
+declare const _default: any;
+export default _default;
+//# sourceMappingURL=PreludeReactNativeSdkModule.d.ts.map

package/build/PreludeReactNativeSdkModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PreludeReactNativeSdkModule.d.ts","sourceRoot":"","sources":["../src/PreludeReactNativeSdkModule.ts"],"names":[],"mappings":";AAIA,wBAA4D"}

package/build/PreludeReactNativeSdkModule.js

@@ -0,0 +1,5 @@
+import { requireNativeModule } from 'expo-modules-core';
+// It loads the native module object from the JSI or falls back to
+// the bridge module (from NativeModulesProxy) if the remote debugger is on.
+export default requireNativeModule('PreludeReactNativeSdk');
+//# sourceMappingURL=PreludeReactNativeSdkModule.js.map

package/build/PreludeReactNativeSdkModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PreludeReactNativeSdkModule.js","sourceRoot":"","sources":["../src/PreludeReactNativeSdkModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD,kEAAkE;AAClE,4EAA4E;AAC5E,eAAe,mBAAmB,CAAC,uBAAuB,CAAC,CAAC","sourcesContent":["import { requireNativeModule } from 'expo-modules-core';\n\n// It loads the native module object from the JSI or falls back to\n// the bridge module (from NativeModulesProxy) if the remote debugger is on.\nexport default requireNativeModule('PreludeReactNativeSdk');\n"]}

package/build/index.d.ts

@@ -0,0 +1,9 @@
+import { EventSubscription } from 'expo-modules-core';
+import { DispatchingSignalsStatus } from './PreludeReactNativeSdk.types';
+export declare function dispatchSignals(configuration: {
+    sdk_key: string;
+    endpoint?: string;
+}): Promise<void>;
+export declare function onDispatchingSignals(listener: (event: DispatchingSignalsStatus) => void): EventSubscription;
+export { DispatchingSignalsStatus };
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAGtD,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,wBAAsB,eAAe,CAAC,aAAa,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAE1G;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,wBAAwB,KAAK,IAAI,GAAG,iBAAiB,CAE3G;AAED,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

package/build/index.js

@@ -0,0 +1,8 @@
+import PreludeReactNativeSdkModule from './PreludeReactNativeSdkModule';
+export async function dispatchSignals(configuration) {
+    return await PreludeReactNativeSdkModule.dispatchSignals(configuration.sdk_key, configuration.endpoint);
+}
+export function onDispatchingSignals(listener) {
+    return PreludeReactNativeSdkModule.addListener('onDispatchingSignals', listener);
+}
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,2BAA2B,MAAM,+BAA+B,CAAC;AAGxE,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,aAAqD;IACzF,OAAO,MAAM,2BAA2B,CAAC,eAAe,CAAC,aAAa,CAAC,OAAO,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;AAC1G,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,QAAmD;IACtF,OAAO,2BAA2B,CAAC,WAAW,CAAC,sBAAsB,EAAE,QAAQ,CAAC,CAAC;AACnF,CAAC","sourcesContent":["import { EventSubscription } from 'expo-modules-core';\n\nimport PreludeReactNativeSdkModule from './PreludeReactNativeSdkModule';\nimport { DispatchingSignalsStatus } from './PreludeReactNativeSdk.types';\n\nexport async function dispatchSignals(configuration: { sdk_key: string, endpoint?: string }): Promise<void> {\n  return await PreludeReactNativeSdkModule.dispatchSignals(configuration.sdk_key, configuration.endpoint);\n}\n\nexport function onDispatchingSignals(listener: (event: DispatchingSignalsStatus) => void): EventSubscription {\n  return PreludeReactNativeSdkModule.addListener('onDispatchingSignals', listener);\n}\n\nexport { DispatchingSignalsStatus };\n"]}

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["apple", "android"],
+  "apple": {
+    "modules": ["PreludeReactNativeSdkModule"]
+  },
+  "android": {
+    "modules": ["so.prelude.reactnative.sdk.PreludeReactNativeSdkModule"]
+  }
+}

package/ios/PreludeReactNativeSdk.podspec

@@ -0,0 +1,24 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'PreludeReactNativeSdk'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platforms      = { :ios => '15.1', :tvos => '15.1' }
+  s.swift_version  = '5.4'
+  s.source         = { git: 'https://github.com/prelude-so/react-native-sdk' }
+  s.static_framework = true
+  s.dependency 'ExpoModulesCore'
+  s.vendored_frameworks = 'sdk/core/PreludeCore.xcframework'
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule'
+  }
+  s.source_files = "**/*.swift", "../sdk/**/*.swift"
+end

package/ios/PreludeReactNativeSdkModule.swift

@@ -0,0 +1,27 @@
+import ExpoModulesCore
+
+public class PreludeReactNativeSdkModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("PreludeReactNativeSdk")
+
+    Events("onDispatchingSignals")
+
+      AsyncFunction("dispatchSignals") { (sdkKey: String, endpointUrl: String?) in
+        let endpoint = endpointUrl != nil ? Endpoint.custom(endpointUrl!) : .default
+        
+        let configuration = Configuration(
+            sdkKey: sdkKey,
+            endpoint: endpoint
+        )
+
+        let prelude = Prelude(configuration)
+
+        do {
+            let dispatchID = try await prelude.dispatchSignals()
+            self.sendEvent("onDispatchingSignals", ["status": "SUCCESS", "dispatchID": dispatchID])
+        } catch {
+            self.sendEvent("onDispatchingSignals", ["status": "FAILURE", "dispatchID": error.localizedDescription])
+        }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@prelude.so/react-native-sdk",
+  "version": "0.1.0",
+  "description": "Prelude SDK for React Native",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "expo-module build",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "test": "expo-module test",
+    "prepare": "expo-module prepare",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "expo-module": "expo-module",
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "prelude-react-native-sdk",
+    "PreludeReactNativeSdk"
+  ],
+  "files": [
+    "android/build.gradle",
+    "android/src/*",
+    "build/*",
+    "ios/*",
+    "scripts/*",
+    "src/*",
+    "expo-module.config.json",
+    "tsconfig.json"
+  ],
+  "repository": "https://github.com/prelude-so/react-native-sdk",
+  "bugs": {
+    "url": "https://github.com/prelude-so/react-native-sdk/issues"
+  },
+  "author": "Prelude <hello@prelude.so> (https://github.com/prelude-so)",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/prelude-so/react-native-sdk#readme",
+  "dependencies": {},
+  "devDependencies": {
+    "@types/react": "~18.3.12",
+    "expo-module-scripts": "^4.0.2",
+    "expo": "~52.0.9",
+    "react-native": "0.76.2"
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*"
+  },
+  "so_prelude": {
+    "apple_sdk_tag": "0.1.0"
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,116 @@
+const fs = require("fs");
+const child_process = require("node:child_process");
+const util = require("node:util");
+const path = require("path");
+const { Readable } = require("stream");
+const { finished } = require("stream/promises");
+
+async function main() {
+  const packagePath = path.resolve(__dirname, "../package.json");
+  const sdkPath = path.resolve(__dirname, "../ios/sdk");
+  if (fs.existsSync(sdkPath)) {
+    fs.rmSync(sdkPath, { recursive: true });
+  }
+  fs.mkdirSync(sdkPath);
+  const packageFile = require(packagePath);
+  const appleSdkVersion = packageFile.so_prelude.apple_sdk_tag;
+  const appleSdkSources =
+    process.env.APPLE_SDK_LOCATION ||
+    `https://github.com/prelude-so/apple-sdk/archive/refs/tags/${appleSdkVersion}.zip`;
+
+  await configureSources(appleSdkSources, sdkPath, appleSdkVersion);
+
+  logSuccess("The Prelude Apple SDK has been successfully configured.");
+}
+
+async function configureSources(sourcesPath, localSdkPath, appleSdkVersion) {
+  if (sourcesPath.startsWith("http")) {
+    await configureFromUrl(sourcesPath, localSdkPath, appleSdkVersion);
+  } else {
+    fs.cpSync(sourcesPath, localSdkPath, { recursive: true });
+    fs.rmSync(`${localSdkPath}/Package.swift`)
+  }
+}
+
+async function configureFromUrl(url, localSdkPath, appleSdkVersion) {
+  logMessage(`Downloading the Prelude Apple SDK version: ${appleSdkVersion}.`);
+
+  await downloadFile(url, `${localSdkPath}/${appleSdkVersion}.zip`);
+  unzip(`${localSdkPath}/${appleSdkVersion}.zip`, `${localSdkPath}/tmp`);
+  fs.rmSync(`${localSdkPath}/${appleSdkVersion}.zip`, { force: true });
+  const unzipped_to = fs.readdirSync(`${localSdkPath}/tmp`)[0];
+
+  const swiftPackage = `${localSdkPath}/tmp/${unzipped_to}/Package.swift`;
+  const sources = `${localSdkPath}/tmp/${unzipped_to}/Sources`;
+  fs.renameSync(sources, `${localSdkPath}/Sources`);
+
+  const xcframeworkUrl = await extractXcFrameworkUrl(swiftPackage);
+  logMessage("Downloading the Prelude Apple SDK binaries...");
+  const xcframeworkFileName = xcframeworkUrl.split("/").pop();
+  await downloadFile(
+    xcframeworkUrl,
+    `${localSdkPath}/tmp/${xcframeworkFileName}`,
+  );
+
+  unzip(
+    `${localSdkPath}/tmp/${xcframeworkFileName}`,
+    `${localSdkPath}/tmp/core/`,
+  );
+  fs.renameSync(`${localSdkPath}/tmp/core/`, `${localSdkPath}/core`);
+
+  fs.rmSync(`${localSdkPath}/tmp`, { recursive: true, force: true });
+}
+
+async function extractXcFrameworkUrl(packageFileName) {
+  const readline = require("node:readline");
+  const fileStream = fs.createReadStream(packageFileName);
+
+  const rl = readline.createInterface({
+    input: fileStream,
+    crlfDelay: Infinity,
+  });
+  for await (const line of rl) {
+    if (line.includes("url:") && line.includes("xcframework.zip")) {
+      const xcframeworkUrl = line
+        .trim()
+        .replace("url:", "")
+        .replaceAll('"', "")
+        .replace(",", "")
+        .trim();
+      return xcframeworkUrl;
+    }
+  }
+}
+
+const downloadFile = async (url, fileName) => {
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(
+      `Error downloading the Prelude Apple SDK. Response: ${res.statusText}. Tried ${url}.`,
+    );
+  }
+  fs.rmSync(fileName, { force: true });
+  const fileStream = fs.createWriteStream(fileName, { flags: "wx" });
+  await finished(Readable.fromWeb(res.body).pipe(fileStream));
+};
+
+const exec = util.promisify(child_process.execSync);
+
+async function unzip(fileName, destination) {
+  const unzip = await exec("unzip " + fileName + " -d " + destination, {
+    stdio: "inherit",
+  });
+  logMessage(unzip.stdout);
+}
+
+function logMessage(msg) {
+  console.log(msg);
+}
+
+function logSuccess(msg) {
+  console.log(`\x1b[32m ${msg} \x1b[0m`);
+}
+
+(async () => {
+  await main();
+})();

package/src/PreludeReactNativeSdk.types.ts

@@ -0,0 +1,10 @@
+export type DispatchingSignalsStatus = {
+  status: string,
+  dispatchID: string;
+};
+
+export type Configuration = {
+  sdk_key: string;
+  endpoint?: string;
+  timeout_milliseconds?: number;
+}

package/src/PreludeReactNativeSdkModule.ts

@@ -0,0 +1,5 @@
+import { requireNativeModule } from 'expo-modules-core';
+
+// It loads the native module object from the JSI or falls back to
+// the bridge module (from NativeModulesProxy) if the remote debugger is on.
+export default requireNativeModule('PreludeReactNativeSdk');

package/src/index.ts

@@ -0,0 +1,14 @@
+import { EventSubscription } from 'expo-modules-core';
+
+import PreludeReactNativeSdkModule from './PreludeReactNativeSdkModule';
+import { DispatchingSignalsStatus } from './PreludeReactNativeSdk.types';
+
+export async function dispatchSignals(configuration: { sdk_key: string, endpoint?: string }): Promise<void> {
+  return await PreludeReactNativeSdkModule.dispatchSignals(configuration.sdk_key, configuration.endpoint);
+}
+
+export function onDispatchingSignals(listener: (event: DispatchingSignalsStatus) => void): EventSubscription {
+  return PreludeReactNativeSdkModule.addListener('onDispatchingSignals', listener);
+}
+
+export { DispatchingSignalsStatus };

package/tsconfig.json

@@ -0,0 +1,9 @@
+// @generated by expo-module-scripts
+{
+  "extends": "expo-module-scripts/tsconfig.base",
+  "compilerOptions": {
+    "outDir": "./build"
+  },
+  "include": ["./src"],
+  "exclude": ["**/__mocks__/*", "**/__tests__/*", "**/__rsc_tests__/*"]
+}