@tempivo/sensor-beacon 0.2.0 → 0.3.0

package/android/src/main/java/expo/modules/tempivosensorbeacon/TempivoSensorBeaconModule.kt

@@ -0,0 +1,122 @@
+package expo.modules.tempivosensorbeacon
+
+import android.Manifest
+import android.content.Context
+import android.os.Build
+import expo.modules.interfaces.permissions.Permissions
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+class TempivoSensorBeaconModule : Module() {
+  private val native = SensorBeaconNative()
+
+  override fun definition() = ModuleDefinition {
+    Name("TempivoSensorBeacon")
+    Events("onDeviceFound")
+
+    AsyncFunction("requestPermissions") { promise: Promise ->
+      val manager = appContext.permissions
+        ?: throw CodedException("runtimeUnavailable", "Permissions manager is not available.", null)
+      Permissions.askForPermissionsWithPermissionsManager(manager, promise, *blePermissions())
+    }
+
+    AsyncFunction("startScan") {
+      try {
+        native.startScan(requireContext()) { payload ->
+          sendEvent("onDeviceFound", payload)
+        }
+      } catch (error: Throwable) {
+        throw error.toSensorException()
+      }
+    }
+
+    Function("stopScan") {
+      native.stopScan()
+    }
+
+    Function("isScanning") {
+      native.isScanning
+    }
+
+    AsyncFunction("connect") { qrJson: String ->
+      try {
+        native.connect(requireContext(), qrJson)
+      } catch (error: Throwable) {
+        throw error.toSensorException()
+      }
+    }
+
+    AsyncFunction("disconnect") {
+      try {
+        native.disconnect()
+      } catch (error: Throwable) {
+        throw error.toSensorException()
+      }
+    }
+
+    AsyncFunction("getConfigurationJson") {
+      try {
+        native.configurationJson
+      } catch (error: Throwable) {
+        throw error.toSensorException()
+      }
+    }
+
+    AsyncFunction("setConfigurationJson") { json: String ->
+      try {
+        native.setConfigurationJson(json)
+      } catch (error: Throwable) {
+        throw error.toSensorException()
+      }
+    }
+
+    AsyncFunction("triggerTransmission") {
+      try {
+        native.triggerTransmission()
+      } catch (error: Throwable) {
+        throw error.toSensorException()
+      }
+    }
+
+    AsyncFunction("getCalibration") {
+      try {
+        native.calibration
+      } catch (error: Throwable) {
+        throw error.toSensorException()
+      }
+    }
+
+    OnDestroy {
+      native.stopScan()
+    }
+  }
+
+  private fun requireContext(): Context {
+    return appContext.reactContext
+      ?: appContext.currentActivity
+      ?: throw CodedException("runtimeUnavailable", "Android context is not available.", null)
+  }
+
+  private fun blePermissions(): Array<String> {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      arrayOf(Manifest.permission.BLUETOOTH_SCAN, Manifest.permission.BLUETOOTH_CONNECT)
+    } else {
+      arrayOf(
+        Manifest.permission.ACCESS_FINE_LOCATION,
+        Manifest.permission.BLUETOOTH,
+        Manifest.permission.BLUETOOTH_ADMIN,
+      )
+    }
+  }
+}
+
+private fun Throwable.toSensorException(): CodedException {
+  if (this is CodedException) return this
+  val native = this as? SensorBeaconNative.NativeError ?: cause as? SensorBeaconNative.NativeError
+  if (native != null) {
+    return CodedException(native.code, native.message, this)
+  }
+  return CodedException("unknown", message ?: "Sensor request failed.", this)
+}

package/android-aar/build.gradle

@@ -0,0 +1,4 @@
+plugins {
+    id "com.android.library" version "8.7.3" apply false
+    id "org.jetbrains.kotlin.android" version "2.2.21" apply false
+}

package/{android → android-aar}/library/src/main/java/com/tempivo/sensor/beacon/TempivoSensorSession.kt

@@ -3,6 +3,7 @@ package com.tempivo.sensor.beacon
 import android.app.Application
 import android.content.Context
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
@@ -100,6 +101,18 @@ class TempivoSensorSession(
         return runGatt { SensorBleRuntime.readCalibration(requireSession()) }
     }
 
+    fun connectBlocking(qr: TempivoSensorQr) = runBlocking { connect(qr) }
+
+    fun disconnectBlocking() = runBlocking { disconnect() }
+
+    fun getConfigurationJsonBlocking(): String = runBlocking { getConfigurationJson() }
+
+    fun setConfigurationJsonBlocking(json: String) = runBlocking { setConfigurationJson(json) }
+
+    fun triggerTransmissionBlocking(): TriggerResult = runBlocking { triggerTransmission() }
+
+    fun getCalibrationBlocking(): TempivoSensorCalibration = runBlocking { getCalibration() }
+
     private fun requireSession(): SensorBleRuntime.Session =
         session
             ?: throw TempivoSensorException(TempivoSensorException.Code.NOT_CONNECTED, "Not connected.")

package/app.plugin.cjs

@@ -0,0 +1,142 @@
+const Module = require('module');
+const path = require('path');
+
+function loadConfigPlugins() {
+  const candidates = [process.cwd(), path.dirname(process.cwd())];
+  for (const base of candidates) {
+    try {
+      const id = require.resolve('expo/config-plugins', { paths: [base] });
+      return require(id);
+    } catch {
+      // try next
+    }
+  }
+  try {
+    const fromExpo = require.resolve('expo/package.json', { paths: [process.cwd()] });
+    return Module.createRequire(fromExpo)('expo/config-plugins');
+  } catch {
+    return require('expo/config-plugins');
+  }
+}
+
+const {
+  AndroidConfig,
+  withInfoPlist,
+  withProjectBuildGradle,
+  withSettingsGradle,
+  withGradleProperties,
+} = loadConfigPlugins();
+
+const MAVEN_URL = 'https://maven.efento.io/releases';
+const DEFAULT_BLE_MESSAGE = 'Tempivo uses Bluetooth to find and configure sensors.';
+const MIN_SDK = 26;
+
+function insertKotlinStdlibForce(contents, isKts) {
+  if (contents.includes('TEMPIVO_KOTLIN_STDLIB_FORCE')) return contents;
+  const extra = isKts
+    ? `
+// TEMPIVO_KOTLIN_STDLIB_FORCE
+subprojects {
+  configurations.configureEach {
+    resolutionStrategy {
+      force("org.jetbrains.kotlin:kotlin-stdlib:2.1.20")
+      force("org.jetbrains.kotlin:kotlin-stdlib-jdk7:2.1.20")
+      force("org.jetbrains.kotlin:kotlin-stdlib-jdk8:2.1.20")
+      force("org.jetbrains.kotlin:kotlin-reflect:2.1.20")
+    }
+  }
+}
+`
+    : `
+// TEMPIVO_KOTLIN_STDLIB_FORCE
+subprojects { sub ->
+  sub.configurations.configureEach {
+    resolutionStrategy {
+      force 'org.jetbrains.kotlin:kotlin-stdlib:2.1.20'
+      force 'org.jetbrains.kotlin:kotlin-stdlib-jdk7:2.1.20'
+      force 'org.jetbrains.kotlin:kotlin-stdlib-jdk8:2.1.20'
+      force 'org.jetbrains.kotlin:kotlin-reflect:2.1.20'
+    }
+  }
+}
+`;
+  return `${contents.trimEnd()}\n${extra}`;
+}
+
+function insertMavenRepo(contents, isKts) {
+  if (contents.includes('maven.efento.io')) return contents;
+  const line = isKts
+    ? `\n        maven { url = uri("${MAVEN_URL}") }`
+    : `\n        maven { url '${MAVEN_URL}' }`;
+  const token = 'mavenCentral()';
+  const idx = contents.lastIndexOf(token);
+  if (idx === -1) return contents;
+  const at = idx + token.length;
+  return contents.slice(0, at) + line + contents.slice(at);
+}
+
+function ensureGradleProperty(items, key, value, shouldReplace) {
+  const existing = items.find((item) => item.type === 'property' && item.key === key);
+  if (existing && existing.type === 'property') {
+    if (shouldReplace(existing.value)) existing.value = value;
+    return;
+  }
+  items.push({ type: 'property', key, value });
+}
+
+function withTempivoSensorBeacon(config, props = {}) {
+  const bleMessage =
+    (props && props.bluetoothPermission) ||
+    config.ios?.infoPlist?.NSBluetoothAlwaysUsageDescription ||
+    DEFAULT_BLE_MESSAGE;
+
+  config.android = config.android || {};
+  if (!config.android.minSdkVersion || Number(config.android.minSdkVersion) < MIN_SDK) {
+    config.android.minSdkVersion = MIN_SDK;
+  }
+
+  config = withGradleProperties(config, (mod) => {
+    ensureGradleProperty(
+      mod.modResults,
+      'android.minSdkVersion',
+      String(MIN_SDK),
+      (current) => !current || Number(current) < MIN_SDK,
+    );
+    return mod;
+  });
+
+  config = withInfoPlist(config, (mod) => {
+    if (!mod.modResults.NSBluetoothAlwaysUsageDescription) {
+      mod.modResults.NSBluetoothAlwaysUsageDescription = bleMessage;
+    }
+    if (!mod.modResults.NSBluetoothPeripheralUsageDescription) {
+      mod.modResults.NSBluetoothPeripheralUsageDescription = bleMessage;
+    }
+    return mod;
+  });
+
+  config = AndroidConfig.Permissions.withPermissions(config, [
+    'android.permission.BLUETOOTH',
+    'android.permission.BLUETOOTH_ADMIN',
+    'android.permission.BLUETOOTH_SCAN',
+    'android.permission.BLUETOOTH_CONNECT',
+    'android.permission.ACCESS_FINE_LOCATION',
+  ]);
+
+  config = withSettingsGradle(config, (mod) => {
+    const isKts = mod.modResults.language === 'kt' || (mod.modResults.path || '').endsWith('.kts');
+    mod.modResults.contents = insertMavenRepo(mod.modResults.contents, isKts);
+    return mod;
+  });
+
+  config = withProjectBuildGradle(config, (mod) => {
+    const isKts = mod.modResults.language === 'kt' || (mod.modResults.path || '').endsWith('.kts');
+    mod.modResults.contents = insertMavenRepo(mod.modResults.contents, isKts);
+    mod.modResults.contents = insertKotlinStdlibForce(mod.modResults.contents, isKts);
+    return mod;
+  });
+
+  return config;
+}
+
+module.exports = withTempivoSensorBeacon;

package/dist/expo-modules-core.web-stub.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Web/Next stub for optional Expo peer. Native BLE uses the real module in Expo/RN builds.
+ */
+export declare function requireNativeModule(_name: string): never;
+export declare function requireOptionalNativeModule<T = unknown>(_name: string): T | null;

package/dist/expo-modules-core.web-stub.js

@@ -0,0 +1,9 @@
+/**
+ * Web/Next stub for optional Expo peer. Native BLE uses the real module in Expo/RN builds.
+ */
+export function requireNativeModule(_name) {
+    throw new Error('expo-modules-core is not available in the web runtime');
+}
+export function requireOptionalNativeModule(_name) {
+    return null;
+}

package/dist/index.d.ts

@@ -8,3 +8,5 @@ export { DEFAULT_SENSOR_MODEL, bluetoothMacFromSerial, normalizeSensorSerial, en
 export { calibrationFromExtendedJson, decodeLaboratoryCalibrationTimestamp, } from './calibration.js';
 export { DEFAULT_ALERT_HYSTERESIS_C, compileSensorProfileToBleJson, configurationFromApiProfile, parseSensorConfiguration, parseSensorConfigurationJson, pickPartnerConfigurationJson, } from './profile.js';
 export type { TempivoSchedule, TempivoScheduleAlways, TempivoScheduleWeek, TempivoSensorCalibration, TempivoSensorConfiguration, TempivoSensorQr, TempivoSensorSessionType, TempivoTemperatureAlert, TempivoTemperatureChannel, TempivoTemperatureMaxAlert, TempivoTemperatureMinAlert, TempivoTemperatureRangeAlert, TempivoTriggerTransmissionResult, } from './session-types.js';
+export { addDeviceFoundListener, connect, disconnect, getCalibration, getConfiguration, isNativeSensorBeaconAvailable, isScanning, requestPermissions, setConfigurationJson, startScan, stopScan, triggerTransmission, } from './native-bridge.js';
+export type { TempivoDeviceFoundSubscription, TempivoNativeCalibration, TempivoNativeMeasurement, TempivoNativePermissionResponse, TempivoNativePermissionStatus, TempivoNativeQr, TempivoNativeTelemetry, TempivoSensorBeaconDevice, } from './native-types.js';

package/dist/index.js

@@ -7,3 +7,4 @@ export { TempivoSensorError } from './errors.js';
 export { DEFAULT_SENSOR_MODEL, bluetoothMacFromSerial, normalizeSensorSerial, encodeSensorPinPayload, parseSensorQrJson, sessionTypeFromModel, } from './qr.js';
 export { calibrationFromExtendedJson, decodeLaboratoryCalibrationTimestamp, } from './calibration.js';
 export { DEFAULT_ALERT_HYSTERESIS_C, compileSensorProfileToBleJson, configurationFromApiProfile, parseSensorConfiguration, parseSensorConfigurationJson, pickPartnerConfigurationJson, } from './profile.js';
+export { addDeviceFoundListener, connect, disconnect, getCalibration, getConfiguration, isNativeSensorBeaconAvailable, isScanning, requestPermissions, setConfigurationJson, startScan, stopScan, triggerTransmission, } from './native-bridge.js';

package/dist/native-bridge.d.ts

@@ -0,0 +1,14 @@
+import type { TempivoDeviceFoundSubscription, TempivoNativeCalibration, TempivoNativePermissionResponse, TempivoNativeQr, TempivoSensorBeaconDevice } from './native-types.js';
+import type { TempivoSensorConfiguration, TempivoSensorQr, TempivoTriggerTransmissionResult } from './session-types.js';
+export declare function isNativeSensorBeaconAvailable(): Promise<boolean>;
+export declare function requestPermissions(): Promise<TempivoNativePermissionResponse>;
+export declare function startScan(): Promise<void>;
+export declare function stopScan(): Promise<void>;
+export declare function isScanning(): Promise<boolean>;
+export declare function addDeviceFoundListener(listener: (device: TempivoSensorBeaconDevice) => void): Promise<TempivoDeviceFoundSubscription>;
+export declare function connect(qr: string | TempivoSensorQr): Promise<TempivoNativeQr>;
+export declare function disconnect(): Promise<void>;
+export declare function getConfiguration(): Promise<TempivoSensorConfiguration>;
+export declare function setConfigurationJson(config: string | TempivoSensorConfiguration): Promise<void>;
+export declare function triggerTransmission(): Promise<TempivoTriggerTransmissionResult>;
+export declare function getCalibration(): Promise<TempivoNativeCalibration>;

package/dist/native-bridge.js

@@ -0,0 +1,51 @@
+import { TempivoSensorError } from './errors.js';
+async function loadNative() {
+    try {
+        return await import('./native-module.js');
+    }
+    catch {
+        throw new TempivoSensorError('runtimeUnavailable', 'Native BLE needs an Expo development build or React Native with Expo modules. Expo Go is not supported.');
+    }
+}
+export async function isNativeSensorBeaconAvailable() {
+    try {
+        const native = await import('./native-module.js');
+        return native.isNativeSensorBeaconAvailable();
+    }
+    catch {
+        return false;
+    }
+}
+export async function requestPermissions() {
+    return (await loadNative()).requestPermissions();
+}
+export async function startScan() {
+    return (await loadNative()).startScan();
+}
+export async function stopScan() {
+    (await loadNative()).stopScan();
+}
+export async function isScanning() {
+    return (await loadNative()).isScanning();
+}
+export async function addDeviceFoundListener(listener) {
+    return (await loadNative()).addDeviceFoundListener(listener);
+}
+export async function connect(qr) {
+    return (await loadNative()).connect(qr);
+}
+export async function disconnect() {
+    return (await loadNative()).disconnect();
+}
+export async function getConfiguration() {
+    return (await loadNative()).getConfiguration();
+}
+export async function setConfigurationJson(config) {
+    return (await loadNative()).setConfigurationJson(config);
+}
+export async function triggerTransmission() {
+    return (await loadNative()).triggerTransmission();
+}
+export async function getCalibration() {
+    return (await loadNative()).getCalibration();
+}

package/dist/native-helpers.d.ts

@@ -0,0 +1,5 @@
+import { TempivoSensorError } from './errors.js';
+import type { TempivoSensorConfiguration, TempivoSensorQr } from './session-types.js';
+export declare function qrToConnectJson(qr: string | TempivoSensorQr): string;
+export declare function configToJson(config: string | TempivoSensorConfiguration): string;
+export declare function mapNativeError(error: unknown): TempivoSensorError;

package/dist/native-helpers.js

@@ -0,0 +1,33 @@
+import { TempivoSensorError } from './errors.js';
+const SENSOR_CODES = [
+    'invalidPin',
+    'invalidQr',
+    'invalidConfig',
+    'notConnected',
+    'unsupportedCommand',
+    'runtimeUnavailable',
+    'connectFailed',
+    'unknown',
+];
+export function qrToConnectJson(qr) {
+    if (typeof qr === 'string')
+        return qr;
+    return JSON.stringify({
+        sn: qr.serial,
+        pin: qr.pin,
+        model: qr.model ?? 'HC7',
+    });
+}
+export function configToJson(config) {
+    return typeof config === 'string' ? config : JSON.stringify(config);
+}
+function isSensorCode(value) {
+    return !!value && SENSOR_CODES.includes(value);
+}
+export function mapNativeError(error) {
+    if (error instanceof TempivoSensorError)
+        return error;
+    const raw = error;
+    const code = isSensorCode(raw?.code) ? raw.code : 'unknown';
+    return new TempivoSensorError(code, raw?.message || 'Sensor request failed.');
+}

package/dist/native-module.d.ts

@@ -0,0 +1,14 @@
+import type { TempivoDeviceFoundSubscription, TempivoNativeCalibration, TempivoNativePermissionResponse, TempivoNativeQr, TempivoSensorBeaconDevice } from './native-types.js';
+import type { TempivoSensorConfiguration, TempivoSensorQr, TempivoTriggerTransmissionResult } from './session-types.js';
+export declare function isNativeSensorBeaconAvailable(): boolean;
+export declare function requestPermissions(): Promise<TempivoNativePermissionResponse>;
+export declare function startScan(): Promise<void>;
+export declare function stopScan(): void;
+export declare function isScanning(): boolean;
+export declare function addDeviceFoundListener(listener: (device: TempivoSensorBeaconDevice) => void): TempivoDeviceFoundSubscription;
+export declare function connect(qr: string | TempivoSensorQr): Promise<TempivoNativeQr>;
+export declare function disconnect(): Promise<void>;
+export declare function getConfiguration(): Promise<TempivoSensorConfiguration>;
+export declare function setConfigurationJson(config: string | TempivoSensorConfiguration): Promise<void>;
+export declare function triggerTransmission(): Promise<TempivoTriggerTransmissionResult>;
+export declare function getCalibration(): Promise<TempivoNativeCalibration>;

package/dist/native-module.js

@@ -0,0 +1,104 @@
+import { requireOptionalNativeModule } from 'expo-modules-core';
+import { TempivoSensorError } from './errors.js';
+import { configToJson, mapNativeError, qrToConnectJson } from './native-helpers.js';
+import { parseSensorConfigurationJson } from './profile.js';
+function getNative() {
+    const native = requireOptionalNativeModule('TempivoSensorBeacon');
+    if (!native) {
+        throw new TempivoSensorError('runtimeUnavailable', 'Native BLE needs an Expo development build or React Native with Expo modules. Expo Go is not supported.');
+    }
+    return native;
+}
+export function isNativeSensorBeaconAvailable() {
+    return requireOptionalNativeModule('TempivoSensorBeacon') != null;
+}
+export async function requestPermissions() {
+    try {
+        const result = await getNative().requestPermissions();
+        if (result && typeof result.granted === 'boolean')
+            return result;
+        return {
+            granted: true,
+            status: 'granted',
+            canAskAgain: true,
+            expires: 'never',
+        };
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}
+async function ensureBlePermission() {
+    const perms = await requestPermissions();
+    if (perms.granted || perms.status === 'undetermined')
+        return;
+    throw new TempivoSensorError('runtimeUnavailable', 'Bluetooth permission is required.');
+}
+export async function startScan() {
+    await ensureBlePermission();
+    try {
+        await getNative().startScan();
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}
+export function stopScan() {
+    getNative().stopScan();
+}
+export function isScanning() {
+    return getNative().isScanning();
+}
+export function addDeviceFoundListener(listener) {
+    return getNative().addListener('onDeviceFound', listener);
+}
+export async function connect(qr) {
+    await ensureBlePermission();
+    try {
+        return await getNative().connect(qrToConnectJson(qr));
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}
+export async function disconnect() {
+    try {
+        await getNative().disconnect();
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}
+export async function getConfiguration() {
+    try {
+        const json = await getNative().getConfigurationJson();
+        return parseSensorConfigurationJson(json);
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}
+export async function setConfigurationJson(config) {
+    try {
+        await getNative().setConfigurationJson(configToJson(config));
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}
+export async function triggerTransmission() {
+    try {
+        return await getNative().triggerTransmission();
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}
+export async function getCalibration() {
+    try {
+        return await getNative().getCalibration();
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}

package/dist/native-types.d.ts

@@ -0,0 +1,41 @@
+import type { TempivoSensorCalibration, TempivoSensorQr, TempivoSensorSessionType } from './session-types.js';
+export type TempivoNativePermissionStatus = 'granted' | 'denied' | 'undetermined';
+export type TempivoNativePermissionResponse = {
+    granted: boolean;
+    status: TempivoNativePermissionStatus;
+    canAskAgain?: boolean;
+    expires?: string;
+};
+export type TempivoNativeMeasurement = {
+    typeHex: string;
+    raw24: number;
+    text: string;
+};
+export type TempivoNativeTelemetry = {
+    firmware?: string | null;
+    batteryOk?: boolean | null;
+    encryptionEnabled?: boolean | null;
+    cellularStatus?: string | null;
+    measurementCounter?: number | null;
+    readingTimestampUnix?: number | null;
+    readingTimestampIso?: string | null;
+    measurementIntervalSeconds?: number | null;
+    readingsCount?: number;
+    summary?: string | null;
+    readings?: TempivoNativeMeasurement[];
+};
+export type TempivoSensorBeaconDevice = {
+    deviceId: string;
+    rssi: number;
+    bluetoothMacAddress?: string | null;
+    serialNumber?: string | null;
+    summary?: string | null;
+    telemetry?: TempivoNativeTelemetry | null;
+};
+export type TempivoNativeQr = TempivoSensorQr & {
+    sessionType: TempivoSensorSessionType;
+};
+export type TempivoNativeCalibration = TempivoSensorCalibration;
+export type TempivoDeviceFoundSubscription = {
+    remove: () => void;
+};

package/dist/native-types.js

@@ -0,0 +1 @@
+export {};

package/dist/react-native.d.ts

@@ -0,0 +1 @@
+export * from './index.js';

package/dist/react-native.js

@@ -0,0 +1 @@
+export * from './index.js';

package/expo-module.config.json

@@ -0,0 +1,12 @@
+{
+  "platforms": ["apple", "android"],
+  "apple": {
+    "modules": ["TempivoSensorBeaconModule"]
+  },
+  "ios": {
+    "modules": ["TempivoSensorBeaconModule"]
+  },
+  "android": {
+    "modules": ["expo.modules.tempivosensorbeacon.TempivoSensorBeaconModule"]
+  }
+}

package/ios/Frameworks/TempivoSensorBridge.xcframework/Info.plist

@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>AvailableLibraries</key>
+	<array>
+		<dict>
+			<key>BinaryPath</key>
+			<string>TempivoSensorBridge.framework/TempivoSensorBridge</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64</string>
+			<key>LibraryPath</key>
+			<string>TempivoSensorBridge.framework</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+		</dict>
+		<dict>
+			<key>BinaryPath</key>
+			<string>TempivoSensorBridge.framework/TempivoSensorBridge</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64-simulator</string>
+			<key>LibraryPath</key>
+			<string>TempivoSensorBridge.framework</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
+		</dict>
+	</array>
+	<key>CFBundlePackageType</key>
+	<string>XFWK</string>
+	<key>XCFrameworkFormatVersion</key>
+	<string>1.0</string>
+</dict>
+</plist>