@tempivo/sensor-beacon 0.1.0 → 0.2.0

package/README.md

@@ -1,87 +1,246 @@
 # @tempivo/sensor-beacon
 
-Decode **Tempivo sensor** BLE **manufacturer data** (company id **0x026C**). Use this in partner apps, gateways, or Node scripts that scan advertisements. **No GATT connection** is required.
-
-## Install
+Tempivo partner SDK for sensors over BLE. Advertisement decode (manufacturer id **0x026C**) plus GATT session for alert rules, an immediate uplink, and laboratory calibration date.
 
 ```bash
 npm install @tempivo/sensor-beacon
 ```
 
-Node.js 18+.
+| Path | Use |
+|------|-----|
+| `dist/` | Node / TypeScript: advertising decode, QR parse, config JSON |
+| `android/` + `dist/tempivo-sensor-beacon.aar` | Android scan + GATT |
+| `ios/` | iOS Swift Package (scan + session) |
+
+GATT runs on a phone (Android / iOS), not in Node. Always pass the sticker PIN to `connect`. Wrong PIN maps to `invalidPin`.
+
+## QR object
 
-## Quick start
+Sticker QR is JSON. Parse with `parseSensorQrJson` (Node) or `TempivoSensorQrParser.parse` (Android / iOS).
 
-Many platforms return manufacturer bytes **without** the 2-byte company id (`6C 02`). If your stack includes the id, strip it first:
+```json
+{ "sn": "282C024F0012", "pin": "111111", "model": "HC7" }
+```
+
+```ts
+const qr = parseSensorQrJson(stickerQrText);
+```
+
+| Field | Type | Meaning |
+|-------|------|---------|
+| `serial` | string | Device serial, 12 hex chars, no colons. From QR `sn`. |
+| `pin` | string | Sticker PIN. Required on `connect`. Also accepted as QR `resetCode`. |
+| `model` | string | Sticker model. Omitted QR `model` becomes **HC7**. `HC5` selects legacy GATT. |
+| `sessionType` | `modern` \| `legacy` | GATT path. HC7 / firmware 7+ is `modern`. HC5 / firmware 6.x is `legacy`. |
+| `bluetoothMac` | string | BLE MAC with colons, derived from `serial`. |
+
+## Config JSON (same as Cellular API)
+
+`setConfiguration` / `getConfiguration` use the same `temperatureAlerts` + `schedule` shape as `POST /api/v1/devices/config-profiles`.
+
+```json
+{
+  "schedule": { "always": true },
+  "temperatureAlerts": [
+    {
+      "type": "range",
+      "channel": "probe",
+      "lowC": -30,
+      "highC": -10,
+      "hysteresisC": 0.5,
+      "transmitOnBreach": true,
+      "transmitOnReturn": true
+    }
+  ]
+}
+```
+
+**Root**
+
+| Field | Meaning |
+|-------|---------|
+| `temperatureAlerts` | Alert list. Empty array is valid (no temperature alerts). |
+| `schedule` | When alerts are active. `{ "always": true }` is 24/7. |
+
+Ignored over BLE: `slug`, `name`, `measurementIntervalMinutes`, `transmissionIntervalSeconds`. Do not pass `GET /devices/{serial}/config` (`alarmRules`).
+
+**Each `temperatureAlerts[]` item**
+
+| Field | Meaning |
+|-------|---------|
+| `type` | `range` (band), `min` (below), or `max` (above). |
+| `channel` | `ambient` or `probe`. |
+| `lowC` / `highC` | Inclusive band for `type: "range"`. |
+| `minC` | Threshold for `type: "min"`. |
+| `maxC` | Threshold for `type: "max"`. |
+| `hysteresisC` | Degrees of hysteresis. Omitted: **1**. |
+| `transmitOnBreach` | Uplink when the alert trips. Omitted: **true**. |
+| `transmitOnReturn` | Extra uplink when temp returns inside a `range`. Omitted: **true**. Range only. |
+
+**`schedule` weekday window** (instead of `always`)
+
+| Field | Meaning |
+|-------|---------|
+| `weekdays` | **0 = Monday** … **6 = Sunday**. |
+| `from` / `to` | 24h `HH:MM`. |
+| `utcOffsetMinutes` | Offset from UTC for `from` / `to`. |
+
+## Fetch a profile, apply over BLE
+
+`GET /api/v1/devices/config-profiles/{slug}` returns `{ "profile": { … } }`. Pass the GET body or `profile` to `setConfigurationJson`.
+
+```ts
+import { parseSensorQrJson, configurationFromApiProfile } from '@tempivo/sensor-beacon';
+
+const qr = parseSensorQrJson(stickerQrText);
+const res = await fetch(
+  `https://app.tempivo.com/api/v1/devices/config-profiles/${slug}`,
+  { headers: { Authorization: `Bearer ${apiKey}` } }
+);
+const body = await res.json();
+const cfg = configurationFromApiProfile(body); // or body.profile
+```
+
+On the phone, after `connect(qr)`:
+
+```kotlin
+session.setConfigurationJson(profileJson) // GET body or profile object
+session.triggerTransmission()
+```
+
+BLE does not write measurement interval, transmission interval, server, APN, name, or token.
+
+## Node / TypeScript helpers
 
 ```ts
 import {
-  TEMPVO_SENSOR_MANUFACTURER_ID,
   normalizeManufacturerBytes,
   decodeSensorBeaconPayload,
+  parseSensorQrJson,
+  parseSensorConfigurationJson,
 } from '@tempivo/sensor-beacon';
 
-// Web Bluetooth: manufacturerData.get(0x026C) → DataView
-const payload = normalizeManufacturerBytes(manufacturerDataView);
-const reading = decodeSensorBeaconPayload(payload);
-if (reading) {
-  console.log(reading.serialMac, reading.firmware, reading.temperatures);
+const qr = parseSensorQrJson('{"sn":"282C024F0012","pin":"111111","model":"HC7"}');
+const reading = decodeSensorBeaconPayload(normalizeManufacturerBytes(advertisementBytes));
+const cfg = parseSensorConfigurationJson(/* config JSON above */);
+```
+
+Invalid QR or config throws `TempivoSensorError` (`invalidQr`, `invalidPin`, `invalidConfig`).
+
+## Android (GATT)
+
+`connect` / `setConfigurationJson` / `triggerTransmission` are `suspend`. Request `BLUETOOTH_SCAN` and `BLUETOOTH_CONNECT` (API 31+) or location on older APIs.
+
+```kotlin
+val qr = TempivoSensorQrParser.parse(stickerQrText)
+val session = TempivoSensorSession(context)
+
+session.connect(qr)
+try {
+    session.setConfigurationJson(profileJson)
+    val trigger = session.triggerTransmission()
+    val applied = session.getConfiguration()
+    val cal = session.getCalibration()
+} finally {
+    session.disconnect()
 }
 ```
 
-`TEMPVO_SENSOR_MANUFACTURER_ID` is `0x026c` (same id on air as little-endian `6C 02`).
+**`triggerTransmission()`**
 
-## Advertising-only workflow
+| Field | Meaning |
+|-------|---------|
+| `ok` | Device accepted the uplink request. |
+| `supported` | Firmware implements the command. `false` is not an error. |
 
-1. Scan BLE advertisements (no connect).
-2. Read manufacturer specific data for **0x026C**.
-3. Call `normalizeManufacturerBytes` then `decodeSensorBeaconPayload`, or cache frames with `ingestManufacturerPayload` and merge with `buildSensorBeaconReading`.
+**`getCalibration()`**
 
-FW6 devices split data across:
+| Field | Meaning |
+|-------|---------|
+| `laboratoryCalibrationDate` | ISO date (`YYYY-MM-DD`), or null if unset. |
+| `laboratoryCalibrationTimestamp` | Same instant as unix seconds, or null. No expiry field on the device. |
 
-- **`0x03` frame** (22 bytes): serial/MAC, firmware, battery, period, timestamp.
-- **`0x04` frame** (scan response): measurement slots (temperature, humidity, CO₂, etc.).
+## iOS (GATT)
 
-You may receive `0x03` and `0x04` in separate packets. Use `SensorBeaconFrameCache` to merge by device key:
+Needs a physical device and the native `TempivoSensorBridge` XCFramework (`scripts/build-ios-bridge.sh`). Set **`NSBluetoothAlwaysUsageDescription`** in Info.plist. Simulator can scan advertisements only.
 
-```ts
-import {
-  createSensorBeaconFrameCache,
-  ingestManufacturerPayload,
-  buildSensorBeaconReading,
-  macKeyFromAddress,
-} from '@tempivo/sensor-beacon';
+```swift
+let qr = try TempivoSensorQrParser.parse(stickerQrText)
+let session = TempivoSensorSession()
+try session.connect(qr: qr)
+defer { session.disconnect() }
+try session.setConfigurationJson(profileJson)
+_ = try session.triggerTransmission()
+let applied = try session.getConfiguration()
+let cal = try session.getCalibration()
+```
 
-const cache = createSensorBeaconFrameCache();
-const macKey = macKeyFromAddress('28:2C:02:4F:00:12');
+## Advertising (no pairing)
 
-ingestManufacturerPayload(advPayload, macKey, cache);
-ingestManufacturerPayload(scanPayload, macKey, cache);
+Filter manufacturer data on company id **0x026C**. Use **active scanning** so scan-response packets arrive. Product model is **not** in the broadcast. Connect uses QR `model` (HC7 is modern GATT).
 
-const reading = buildSensorBeaconReading(
-  cache.last03.get(macKey),
-  cache.last04.get(macKey)
-);
+```kotlin
+val scanner = TempivoSensorBeaconScanner(context)
+scanner.startScan { device ->
+    Log.d("scan", "${device.serialNumber} rssi=${device.rssi} ${device.summary}")
+}
 ```
 
-## API
+**Android `TempivoSensorBeaconDevice`**
+
+| Field | Meaning |
+|-------|---------|
+| `deviceId` | Android BLE address. Often randomized. Not the sticker serial. |
+| `bluetoothMacAddress` | MAC from the advertisement, with colons. |
+| `serialNumber` | 12 hex chars from advertisement frame `0x03`. Same as QR `sn`. |
+| `rssi` | Signal strength in dBm. |
+| `summary` | Short display line. After scan response: measurement texts joined with ` · `. Before that: serial, or `Adv OK. Wait for scan response (measurements).` |
+| `telemetry` | Decoded frames `0x03` + `0x04`, or null until enough bytes arrive. |
+
+**`telemetry` (Android) / `reading` (iOS and Node)**
+
+| Field | Meaning |
+|-------|---------|
+| `firmware` | `major.minor.patch` from the advertisement, e.g. `7.3.4`. |
+| `batteryOk` | Battery status flag from the advertisement. |
+| `encryptionEnabled` | Advertisement payload encryption flag. |
+| `cellularStatus` | `ble_only`, `cell_ok`, `no_server`, or `net_issue`. |
+| `readingTimestampUnix` | Sample time as unix seconds, or null. |
+| `readingTimestampIso` | Same instant as UTC ISO-8601, or null. |
+| `measurementIntervalSeconds` | Sample interval from the advertisement, in seconds. |
+| `readings` | Decoded scan-response slots (see below). |
+| `readingsCount` | Number of measurement slots. |
+| `summary` | Same short line as on the device object. |
+| `measurementCounter` | Counter from frame `0x03`, or null. |
+
+Node also exposes `serialMac`, `temperatures[]`, `humidity`, and `rawHex`.
+
+**Each `readings[]` / `measurements[]` slot**
+
+| Field | Meaning |
+|-------|---------|
+| `typeHex` | Slot type, e.g. `0x01` temperature, `0x02` humidity. |
+| `raw24` | Undecoded 24-bit payload. |
+| `text` | Display value with unit, e.g. `21.8 °C`. No type name in the string. |
+| `temperatureC` / `humidityPct` | Node only: numeric value when the slot is that type. |
+
+iOS `SensorBeaconDiscovery` has `deviceId`, `rssi`, `serialNumber`, `bluetoothMacAddress`, and `reading` (same telemetry fields).
+
+```swift
+func sensorBeaconScanner(_ scanner: TempivoSensorBeaconScanner, didDiscover discovery: SensorBeaconDiscovery) {
+    print(discovery.serialNumber ?? "", discovery.rssi, discovery.reading?.summary ?? "")
+}
+```
 
-| Export | Purpose |
-|--------|---------|
-| `TEMPVO_SENSOR_MANUFACTURER_ID` | BLE company id `0x026c` |
-| `normalizeManufacturerBytes` | Strip company id prefix when present |
-| `decodeSensorBeaconPayload` | One-shot decode of payload bytes |
-| `ingestManufacturerPayload` | Update frame cache from one advertisement |
-| `buildSensorBeaconReading` | Merge cached `0x03` / `0x04` frames |
-| `SensorBeaconReading` | Parsed device + measurements |
-| `SensorBeaconMeasurement` | One slot in `0x04` scan data |
-| `SensorBeaconFrameCache` | Per-device last `0x03` / `0x04` frames |
+## Errors
 
-Measurement types **0x01–0x22** (temperature, humidity, pressure, IAQ, CO₂, PM, etc.) are decoded to human-readable `text` on each `SensorBeaconMeasurement`.
+Native GATT maps to: `invalidPin`, `invalidQr`, `invalidConfig`, `notConnected`, `unsupportedCommand`, `connectFailed`, `runtimeUnavailable`, `unknown`.
 
-## Tempivo app integration
+## Tests
 
-The Tempivo web app uses the same broadcast format for live debug scans. This package is the supported **partner-facing** npm build of that decoder.
+```bash
+npm run test:unit
+```
 
 ## License
 

package/android/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/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.3.1-all.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

package/android/gradle.properties

@@ -0,0 +1,3 @@
+android.useAndroidX=true
+android.suppressUnsupportedCompileSdk=36
+kotlin.code.style=official

package/android/gradlew

@@ -0,0 +1,251 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH="\\\"\\\""
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

package/android/library/build.gradle

@@ -0,0 +1,30 @@
+plugins {
+    id "com.android.library"
+    id "org.jetbrains.kotlin.android"
+}
+
+android {
+    namespace "com.tempivo.sensor.beacon"
+    compileSdk 36
+
+    defaultConfig {
+        minSdk 26
+        consumerProguardFiles "consumer-rules.pro"
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+}
+
+dependencies {
+    implementation "androidx.core:core-ktx:1.17.0"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2"
+    implementation "pl.efento.mobile:bluetooth:2.3.0"
+}

package/android/library/consumer-rules.pro

@@ -0,0 +1 @@
+# Partner apps keep com.tempivo.sensor.beacon types.

package/android/library/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest />