@blunt-ly/ble-advertiser 0.0.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,247 @@
+# BLE Advertiser Module
+
+A cross-platform BLE (Bluetooth Low Energy) advertiser module for React Native using Expo Modules API. This module allows you to advertise service UUIDs over BLE on both Android and iOS platforms, using minimal platform features to support background processing.
+
+## Installation
+
+```bash
+npm install @blunt-ly/ble-advertiser
+```
+
+## API
+
+### Methods
+
+#### `broadcast(uuids: string[]): Promise<string>`
+
+Start BLE advertising with the specified service UUIDs.
+
+```typescript
+import * as BleAdvertiser from '@blunt-ly/ble-advertiser';
+
+const serviceUUIDs = [
+  '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
+  '180D' // 16-bit UUIDs are also supported
+];
+
+try {
+  const result = await BleAdvertiser.broadcast(serviceUUIDs);
+  console.log('Advertising started:', result);
+} catch (error) {
+  console.error('Failed to start advertising:', error);
+}
+```
+
+> [!NOTE]
+> When an iOS app advertises in the background, CoreBluetooth moves its service UUIDs out of the standard advertisement field and into an "overflow area" that is only visible to scanners which already know the UUIDs in advance. To work around this, the module exposes a GATT characteristic that holds the device-specific UUIDs, so a scanner that recognizes a shared "network" UUID in the overflow area can connect via GATT to retrieve them. See [Scanning in iOS background mode](#scanning-in-ios-background-mode) for the consumer-side pattern.
+
+#### `stopBroadcast(): Promise<{stopped: boolean, stoppedAdvertisers?: number}>`
+
+Stop all BLE advertising.
+
+```typescript
+try {
+  const result = await BleAdvertiser.stopBroadcast();
+  console.log('Advertising stopped:', result);
+} catch (error) {
+  console.error('Failed to stop advertising:', error);
+}
+```
+
+#### `isSupported(): Promise<boolean>`
+
+Check if BLE advertising is supported on the current device.
+
+```typescript
+const supported = await BleAdvertiser.isSupported();
+console.log('BLE advertising supported:', supported);
+```
+
+#### `isEnabled(): Promise<boolean>`
+
+Check if Bluetooth is currently enabled.
+
+```typescript
+const enabled = await BleAdvertiser.isEnabled();
+console.log('Bluetooth enabled:', enabled);
+```
+
+### Events
+
+#### `onAdvertisingStarted`
+
+Fired when advertising starts successfully.
+
+```typescript
+import { addAdvertisingStartedListener } from '@blunt-ly/ble-advertiser';
+
+const subscription = addAdvertisingStartedListener((event) => {
+  console.log('Advertising started with UUIDs:', event.uuids);
+});
+
+// Don't forget to remove the listener
+subscription.remove();
+```
+
+#### `onAdvertisingFailed`
+
+Fired when advertising fails to start.
+
+```typescript
+import { addAdvertisingFailedListener } from '@blunt-ly/ble-advertiser';
+
+const subscription = addAdvertisingFailedListener((event) => {
+  console.log('Advertising failed:', event.error);
+  if (event.errorCode) {
+    console.log('Error code:', event.errorCode);
+  }
+});
+```
+
+#### `onAdvertisingStopped`
+
+Fired when advertising is stopped.
+
+```typescript
+import { addAdvertisingStoppedListener } from '@blunt-ly/ble-advertiser';
+
+const subscription = addAdvertisingStoppedListener((event) => {
+  console.log('Advertising stopped');
+  if (event.uuids) {
+    console.log('UUIDs that were being advertised:', event.uuids);
+  }
+});
+```
+
+## Error Handling
+
+The module provides comprehensive error handling with specific error codes and messages:
+
+- `BLUETOOTH_NOT_AVAILABLE` - Bluetooth adapter not available
+- `BLUETOOTH_DISABLED` - Bluetooth is turned off
+- `ADVERTISER_NOT_AVAILABLE` - BLE advertiser not supported
+- `INVALID_UUID` - Invalid UUID format provided
+- `NO_UUIDS` - No service UUIDs provided
+- `ADVERTISING_FAILED` - Platform-specific advertising failure
+
+## Example Usage
+
+```typescript
+import React, { useEffect, useState } from 'react';
+import { View, Button, Text, Alert } from 'react-native';
+import * as BleAdvertiser from '@blunt-ly/ble-advertiser';
+
+export default function BleAdvertiserExample() {
+  const [isAdvertising, setIsAdvertising] = useState(false);
+  const [isSupported, setIsSupported] = useState(false);
+
+  useEffect(() => {
+    // Check if BLE advertising is supported
+    BleAdvertiser.isSupported().then(setIsSupported);
+
+    // Set up event listeners
+    const startedSubscription = BleAdvertiser.addAdvertisingStartedListener((event) => {
+      setIsAdvertising(true);
+      Alert.alert('Advertising Started', `UUIDs: ${event.uuids.join(', ')}`);
+    });
+
+    const failedSubscription = BleAdvertiser.addAdvertisingFailedListener((event) => {
+      setIsAdvertising(false);
+      Alert.alert('Advertising Failed', event.error);
+    });
+
+    const stoppedSubscription = BleAdvertiser.addAdvertisingStoppedListener(() => {
+      setIsAdvertising(false);
+      Alert.alert('Advertising Stopped');
+    });
+
+    return () => {
+      startedSubscription.remove();
+      failedSubscription.remove();
+      stoppedSubscription.remove();
+    };
+  }, []);
+
+  const startAdvertising = async () => {
+    try {
+      const serviceUUIDs = ['6ba7b810-9dad-11d1-80b4-00c04fd430c8'];
+      await BleAdvertiser.broadcast(serviceUUIDs);
+    } catch (error) {
+      Alert.alert('Error', error.message);
+    }
+  };
+
+  const stopAdvertising = async () => {
+    try {
+      await BleAdvertiser.stopBroadcast();
+    } catch (error) {
+      Alert.alert('Error', error.message);
+    }
+  };
+
+  if (!isSupported) {
+    return (
+      <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
+        <Text>BLE Advertising is not supported on this device</Text>
+      </View>
+    );
+  }
+
+  return (
+    <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
+      <Text>BLE Advertising Status: {isAdvertising ? 'Active' : 'Inactive'}</Text>
+      <Button
+        title={isAdvertising ? 'Stop Advertising' : 'Start Advertising'}
+        onPress={isAdvertising ? stopAdvertising : startAdvertising}
+      />
+    </View>
+  );
+}
+```
+
+## Scanning in iOS background mode
+
+When the advertising app is backgrounded on iOS, its device-specific service UUIDs only surface in the scanner's `overflowServiceUUIDs` field — and only if the scanner is already scanning for a known "network" UUID that the advertiser also broadcasts. The pattern is:
+
+1. The advertiser broadcasts a shared `networkId` UUID plus a device-specific UUID.
+2. The scanner filters on `networkId`.
+3. In the foreground both UUIDs are visible in `advertising.serviceUUIDs`.
+4. In the background only `networkId` is visible (via `overflowServiceUUIDs`); the scanner then connects via GATT to read the device-specific UUID from the characteristic exposed by this module.
+
+```typescript
+const NETWORK_ID = '<your-shared-network-uuid>';
+const inFlightConnections = new Set<string>();
+
+await scanner.start(async (peripheral) => {
+  let targetBroadcastId: string | undefined | null;
+
+  // Normal path: both service UUIDs are visible in the advertisement
+  if (peripheral.advertising.serviceUUIDs?.length === 2) {
+    targetBroadcastId = peripheral.advertising.serviceUUIDs.find(
+      (uuid) => uuid.toLowerCase() !== NETWORK_ID.toLowerCase()
+    );
+  }
+
+  // Overflow path: only the known network UUID is visible via the overflow area.
+  // Connect via GATT to read the device-specific broadcast ID.
+  if (!targetBroadcastId) {
+    const overflowUUIDs = peripheral.advertising.overflowServiceUUIDs as string[] | undefined;
+    const hasNetworkInOverflow = overflowUUIDs?.some(
+      (uuid) => uuid.toLowerCase() === NETWORK_ID.toLowerCase()
+    );
+    if (!hasNetworkInOverflow) return;
+
+    if (inFlightConnections.has(peripheral.id)) return;
+    inFlightConnections.add(peripheral.id);
+
+    targetBroadcastId = await readBroadcastIdViaGatt(peripheral.id, NETWORK_ID);
+
+    // Allow re-connection after a cooldown
+    setTimeout(() => inFlightConnections.delete(peripheral.id), 60_000);
+  }
+
+  if (!targetBroadcastId) return;
+
+  // Handle the resolved broadcast ID...
+}, [NETWORK_ID]);
+```

package/android/build.gradle

@@ -0,0 +1,43 @@
+apply plugin: 'com.android.library'
+
+group = 'expo.modules.bleadvertiser'
+version = '0.0.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", 36)
+    defaultConfig {
+      minSdkVersion safeExtGet("minSdkVersion", 24)
+      targetSdkVersion safeExtGet("targetSdkVersion", 36)
+    }
+  }
+}
+
+android {
+  namespace "expo.modules.bleadvertiser"
+  defaultConfig {
+    versionCode 1
+    versionName "0.0.0"
+  }
+  lintOptions {
+    abortOnError false
+  }
+}

package/android/src/main/AndroidManifest.xml

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

package/android/src/main/java/expo/modules/bleadvertiser/BleAdvertiserModule.kt

@@ -0,0 +1,173 @@
+package expo.modules.bleadvertiser
+
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothManager
+import android.bluetooth.le.AdvertiseCallback
+import android.bluetooth.le.AdvertiseData
+import android.bluetooth.le.AdvertiseSettings
+import android.bluetooth.le.BluetoothLeAdvertiser
+import android.content.Context
+import android.os.ParcelUuid
+import android.util.Log
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import java.util.UUID
+
+class BleAdvertiserModule : Module() {
+  private var bluetoothAdapter: BluetoothAdapter? = null
+  private val advertisers = mutableMapOf<String, BluetoothLeAdvertiser>()
+  private val advertiseCallbacks = mutableMapOf<String, AdvertiseCallback>()
+
+  override fun definition() = ModuleDefinition {
+    Name("BleAdvertiser")
+
+    Events("onAdvertisingStarted", "onAdvertisingFailed", "onAdvertisingStopped")
+
+    OnCreate {
+      val bluetoothManager = appContext.reactContext?.getSystemService(Context.BLUETOOTH_SERVICE) as? BluetoothManager
+      bluetoothAdapter = bluetoothManager?.adapter
+    }
+
+    AsyncFunction("broadcast") { uuids: List<String>, promise: Promise ->
+      try {
+        if (bluetoothAdapter == null) {
+          promise.reject("BLUETOOTH_NOT_AVAILABLE", "Bluetooth adapter is not available", null)
+          return@AsyncFunction
+        }
+
+        if (bluetoothAdapter?.isEnabled != true) {
+          promise.reject("BLUETOOTH_DISABLED", "Bluetooth is not enabled", null)
+          return@AsyncFunction
+        }
+
+        val advertiser = bluetoothAdapter?.bluetoothLeAdvertiser
+        if (advertiser == null) {
+          promise.reject("ADVERTISER_NOT_AVAILABLE", "BLE advertiser is not available on this device", null)
+          return@AsyncFunction
+        }
+
+        // Convert string UUIDs to ParcelUuid objects
+        val serviceUuids = mutableListOf<ParcelUuid>()
+        for (uuidString in uuids) {
+          try {
+            val uuid = UUID.fromString(uuidString)
+            serviceUuids.add(ParcelUuid(uuid))
+          } catch (e: IllegalArgumentException) {
+            promise.reject("INVALID_UUID", "Invalid UUID format: $uuidString", e)
+            return@AsyncFunction
+          }
+        }
+
+        if (serviceUuids.isEmpty()) {
+          promise.reject("NO_UUIDS", "At least one service UUID is required", null)
+          return@AsyncFunction
+        }
+
+        // Build advertise settings
+        val settings = AdvertiseSettings.Builder()
+          .setAdvertiseMode(AdvertiseSettings.ADVERTISE_MODE_LOW_LATENCY)
+          .setTxPowerLevel(AdvertiseSettings.ADVERTISE_TX_POWER_MEDIUM)
+          .setConnectable(false)
+          .build()
+
+        // Build advertise data with service UUIDs
+        val dataBuilder = AdvertiseData.Builder()
+          .setIncludeDeviceName(false)
+          .setIncludeTxPowerLevel(true)
+
+        // Add all service UUIDs
+        for (serviceUuid in serviceUuids) {
+          dataBuilder.addServiceUuid(serviceUuid)
+        }
+
+        val advertiseData = dataBuilder.build()
+
+        val callback = object : AdvertiseCallback() {
+          override fun onStartSuccess(settingsInEffect: AdvertiseSettings?) {
+            Log.d("BleAdvertiser", "Advertising started successfully")
+            sendEvent("onAdvertisingStarted", mapOf("uuids" to uuids))
+            promise.resolve("Advertising started successfully")
+          }
+
+          override fun onStartFailure(errorCode: Int) {
+            val errorMessage = when (errorCode) {
+              ADVERTISE_FAILED_FEATURE_UNSUPPORTED -> "Advertising feature is not supported"
+              ADVERTISE_FAILED_TOO_MANY_ADVERTISERS -> "Too many advertisers"
+              ADVERTISE_FAILED_ALREADY_STARTED -> "Advertising already started"
+              ADVERTISE_FAILED_DATA_TOO_LARGE -> "Advertise data too large"
+              ADVERTISE_FAILED_INTERNAL_ERROR -> "Internal error"
+              else -> "Unknown error code: $errorCode"
+            }
+            Log.e("BleAdvertiser", "Advertising failed: $errorMessage")
+            sendEvent("onAdvertisingFailed", mapOf("error" to errorMessage, "errorCode" to errorCode))
+            promise.reject("ADVERTISING_FAILED", errorMessage, null)
+          }
+        }
+
+        // Generate a key for this advertiser instance
+        val key = uuids.sorted().joinToString(",")
+
+        // Stop any existing advertiser with the same UUIDs
+        advertisers[key]?.let { existingAdvertiser ->
+          advertiseCallbacks[key]?.let { existingCallback ->
+            existingAdvertiser.stopAdvertising(existingCallback)
+          }
+        }
+
+        // Store the new advertiser and callback
+        advertisers[key] = advertiser
+        advertiseCallbacks[key] = callback
+
+        // Start advertising
+        advertiser.startAdvertising(settings, advertiseData, callback)
+
+      } catch (e: Exception) {
+        Log.e("BleAdvertiser", "Error starting advertising", e)
+        promise.reject("UNEXPECTED_ERROR", e.message ?: "Unknown error", e)
+      }
+    }
+
+    AsyncFunction("stopBroadcast") { promise: Promise ->
+      try {
+        val stoppedKeys = mutableListOf<String>()
+
+        for ((key, advertiser) in advertisers) {
+          advertiseCallbacks[key]?.let { callback ->
+            advertiser.stopAdvertising(callback)
+            stoppedKeys.add(key)
+          }
+        }
+
+        advertisers.clear()
+        advertiseCallbacks.clear()
+
+        sendEvent("onAdvertisingStopped", mapOf("stoppedCount" to stoppedKeys.size))
+        promise.resolve(mapOf("stoppedAdvertisers" to stoppedKeys.size))
+
+      } catch (e: Exception) {
+        Log.e("BleAdvertiser", "Error stopping advertising", e)
+        promise.reject("STOP_ERROR", e.message ?: "Unknown error", e)
+      }
+    }
+
+    AsyncFunction("isSupported") { promise: Promise ->
+      try {
+        val isSupported = bluetoothAdapter != null &&
+                         bluetoothAdapter?.bluetoothLeAdvertiser != null
+        promise.resolve(isSupported)
+      } catch (e: Exception) {
+        promise.reject("CHECK_SUPPORT_ERROR", e.message ?: "Unknown error", e)
+      }
+    }
+
+    AsyncFunction("isEnabled") { promise: Promise ->
+      try {
+        val isEnabled = bluetoothAdapter?.isEnabled == true
+        promise.resolve(isEnabled)
+      } catch (e: Exception) {
+        promise.reject("CHECK_ENABLED_ERROR", e.message ?: "Unknown error", e)
+      }
+    }
+  }
+}

package/build/BleAdvertiser.types.d.ts

@@ -0,0 +1,18 @@
+export type AdvertisingStartedEvent = {
+    uuids: string[];
+};
+export type AdvertisingFailedEvent = {
+    error: string;
+    errorCode?: number;
+    uuids?: string[];
+};
+export type AdvertisingStoppedEvent = {
+    uuids?: string[];
+    stoppedCount?: number;
+};
+export type BleAdvertiserModuleEvents = {
+    onAdvertisingStarted: (params: AdvertisingStartedEvent) => void;
+    onAdvertisingFailed: (params: AdvertisingFailedEvent) => void;
+    onAdvertisingStopped: (params: AdvertisingStoppedEvent) => void;
+};
+//# sourceMappingURL=BleAdvertiser.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BleAdvertiser.types.d.ts","sourceRoot":"","sources":["../src/BleAdvertiser.types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,uBAAuB,GAAG;IACpC,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,oBAAoB,EAAE,CAAC,MAAM,EAAE,uBAAuB,KAAK,IAAI,CAAC;IAChE,mBAAmB,EAAE,CAAC,MAAM,EAAE,sBAAsB,KAAK,IAAI,CAAC;IAC9D,oBAAoB,EAAE,CAAC,MAAM,EAAE,uBAAuB,KAAK,IAAI,CAAC;CACjE,CAAC"}

package/build/BleAdvertiser.types.js

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

package/build/BleAdvertiser.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BleAdvertiser.types.js","sourceRoot":"","sources":["../src/BleAdvertiser.types.ts"],"names":[],"mappings":"","sourcesContent":["export type AdvertisingStartedEvent = {\n  uuids: string[];\n};\n\nexport type AdvertisingFailedEvent = {\n  error: string;\n  errorCode?: number;\n  uuids?: string[];\n};\n\nexport type AdvertisingStoppedEvent = {\n  uuids?: string[];\n  stoppedCount?: number;\n};\n\nexport type BleAdvertiserModuleEvents = {\n  onAdvertisingStarted: (params: AdvertisingStartedEvent) => void;\n  onAdvertisingFailed: (params: AdvertisingFailedEvent) => void;\n  onAdvertisingStopped: (params: AdvertisingStoppedEvent) => void;\n};\n"]}

package/build/BleAdvertiserModule.d.ts

@@ -0,0 +1,31 @@
+import { NativeModule } from 'expo';
+import { BleAdvertiserModuleEvents } from './BleAdvertiser.types';
+declare class BleAdvertiserModule extends NativeModule<BleAdvertiserModuleEvents> {
+    /**
+     * Start BLE advertising with the specified service UUIDs
+     * @param uuids Array of service UUID strings to advertise
+     * @returns Promise that resolves when advertising starts successfully
+     */
+    broadcast(uuids: string[]): Promise<string>;
+    /**
+     * Stop all BLE advertising
+     * @returns Promise that resolves with information about stopped advertisers
+     */
+    stopBroadcast(): Promise<{
+        stopped: boolean;
+        stoppedAdvertisers?: number;
+    }>;
+    /**
+     * Check if BLE advertising is supported on this device
+     * @returns Promise that resolves to true if supported, false otherwise
+     */
+    isSupported(): Promise<boolean>;
+    /**
+     * Check if Bluetooth is currently enabled
+     * @returns Promise that resolves to true if enabled, false otherwise
+     */
+    isEnabled(): Promise<boolean>;
+}
+declare const _default: BleAdvertiserModule;
+export default _default;
+//# sourceMappingURL=BleAdvertiserModule.d.ts.map

package/build/BleAdvertiserModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BleAdvertiserModule.d.ts","sourceRoot":"","sources":["../src/BleAdvertiserModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAuB,MAAM,MAAM,CAAC;AAEzD,OAAO,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAElE,OAAO,OAAO,mBAAoB,SAAQ,YAAY,CAAC,yBAAyB,CAAC;IAC/E;;;;OAIG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAE3C;;;OAGG;IACH,aAAa,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,kBAAkB,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAE3E;;;OAGG;IACH,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAE/B;;;OAGG;IACH,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;CAC9B;;AAGD,wBAAyE"}

package/build/BleAdvertiserModule.js

@@ -0,0 +1,4 @@
+import { requireNativeModule } from 'expo';
+// This call loads the native module object from the JSI.
+export default requireNativeModule('BleAdvertiser');
+//# sourceMappingURL=BleAdvertiserModule.js.map

package/build/BleAdvertiserModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BleAdvertiserModule.js","sourceRoot":"","sources":["../src/BleAdvertiserModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,mBAAmB,EAAE,MAAM,MAAM,CAAC;AA+BzD,yDAAyD;AACzD,eAAe,mBAAmB,CAAsB,eAAe,CAAC,CAAC","sourcesContent":["import { NativeModule, requireNativeModule } from 'expo';\n\nimport { BleAdvertiserModuleEvents } from './BleAdvertiser.types';\n\ndeclare class BleAdvertiserModule extends NativeModule<BleAdvertiserModuleEvents> {\n  /**\n   * Start BLE advertising with the specified service UUIDs\n   * @param uuids Array of service UUID strings to advertise\n   * @returns Promise that resolves when advertising starts successfully\n   */\n  broadcast(uuids: string[]): Promise<string>;\n\n  /**\n   * Stop all BLE advertising\n   * @returns Promise that resolves with information about stopped advertisers\n   */\n  stopBroadcast(): Promise<{ stopped: boolean; stoppedAdvertisers?: number }>;\n\n  /**\n   * Check if BLE advertising is supported on this device\n   * @returns Promise that resolves to true if supported, false otherwise\n   */\n  isSupported(): Promise<boolean>;\n\n  /**\n   * Check if Bluetooth is currently enabled\n   * @returns Promise that resolves to true if enabled, false otherwise\n   */\n  isEnabled(): Promise<boolean>;\n}\n\n// This call loads the native module object from the JSI.\nexport default requireNativeModule<BleAdvertiserModule>('BleAdvertiser');\n"]}

package/build/index.d.ts

@@ -0,0 +1,46 @@
+import { EventSubscription } from 'expo-modules-core';
+import { AdvertisingStartedEvent, AdvertisingFailedEvent, AdvertisingStoppedEvent } from './BleAdvertiser.types';
+/**
+ * Start BLE advertising with the specified service UUIDs
+ * @param uuids Array of service UUID strings to advertise
+ * @returns Promise that resolves when advertising starts successfully
+ */
+export declare function broadcast(uuids: string[]): Promise<string>;
+/**
+ * Stop all BLE advertising
+ * @returns Promise that resolves with information about stopped advertisers
+ */
+export declare function stopBroadcast(): Promise<{
+    stopped: boolean;
+    stoppedAdvertisers?: number;
+}>;
+/**
+ * Check if BLE advertising is supported on this device
+ * @returns Promise that resolves to true if supported, false otherwise
+ */
+export declare function isSupported(): Promise<boolean>;
+/**
+ * Check if Bluetooth is currently enabled
+ * @returns Promise that resolves to true if enabled, false otherwise
+ */
+export declare function isEnabled(): Promise<boolean>;
+/**
+ * Add listener for advertising started events
+ * @param listener Function to call when advertising starts
+ * @returns EventSubscription that can be used to remove the listener
+ */
+export declare function addAdvertisingStartedListener(listener: (event: AdvertisingStartedEvent) => void): EventSubscription;
+/**
+ * Add listener for advertising failed events
+ * @param listener Function to call when advertising fails
+ * @returns EventSubscription that can be used to remove the listener
+ */
+export declare function addAdvertisingFailedListener(listener: (event: AdvertisingFailedEvent) => void): EventSubscription;
+/**
+ * Add listener for advertising stopped events
+ * @param listener Function to call when advertising stops
+ * @returns EventSubscription that can be used to remove the listener
+ */
+export declare function addAdvertisingStoppedListener(listener: (event: AdvertisingStoppedEvent) => void): EventSubscription;
+export * from './BleAdvertiser.types';
+//# 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,EACL,uBAAuB,EACvB,sBAAsB,EACtB,uBAAuB,EACxB,MAAM,uBAAuB,CAAC;AAe/B;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAE1D;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAE1F;AAED;;;GAGG;AACH,wBAAgB,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC,CAE9C;AAED;;;GAGG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC,CAE5C;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,CAAC,KAAK,EAAE,uBAAuB,KAAK,IAAI,GACjD,iBAAiB,CAEnB;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,IAAI,GAChD,iBAAiB,CAEnB;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,CAAC,KAAK,EAAE,uBAAuB,KAAK,IAAI,GACjD,iBAAiB,CAEnB;AAGD,cAAc,uBAAuB,CAAC"}

package/build/index.js

@@ -0,0 +1,70 @@
+import { Platform } from 'react-native';
+import BleAdvertiserModule from './BleAdvertiserModule';
+import { expand16BitUuid } from './utils';
+// HACK: Android's BluetoothLeAdvertiser only accepts 128-bit service UUIDs, while
+// CoreBluetooth on iOS accepts the 16-bit short form directly. Expand any
+// 16-bit input before handing it to the Android native module.
+function normalizeUuidsForPlatform(uuids) {
+    if (Platform.OS !== 'android')
+        return uuids;
+    return uuids.map((uuid) => {
+        const hex = uuid.replace(/[^0-9a-fA-F]/g, '');
+        return hex.length === 4 ? expand16BitUuid(uuid) : uuid;
+    });
+}
+/**
+ * Start BLE advertising with the specified service UUIDs
+ * @param uuids Array of service UUID strings to advertise
+ * @returns Promise that resolves when advertising starts successfully
+ */
+export function broadcast(uuids) {
+    return BleAdvertiserModule.broadcast(normalizeUuidsForPlatform(uuids));
+}
+/**
+ * Stop all BLE advertising
+ * @returns Promise that resolves with information about stopped advertisers
+ */
+export function stopBroadcast() {
+    return BleAdvertiserModule.stopBroadcast();
+}
+/**
+ * Check if BLE advertising is supported on this device
+ * @returns Promise that resolves to true if supported, false otherwise
+ */
+export function isSupported() {
+    return BleAdvertiserModule.isSupported();
+}
+/**
+ * Check if Bluetooth is currently enabled
+ * @returns Promise that resolves to true if enabled, false otherwise
+ */
+export function isEnabled() {
+    return BleAdvertiserModule.isEnabled();
+}
+/**
+ * Add listener for advertising started events
+ * @param listener Function to call when advertising starts
+ * @returns EventSubscription that can be used to remove the listener
+ */
+export function addAdvertisingStartedListener(listener) {
+    return BleAdvertiserModule.addListener('onAdvertisingStarted', listener);
+}
+/**
+ * Add listener for advertising failed events
+ * @param listener Function to call when advertising fails
+ * @returns EventSubscription that can be used to remove the listener
+ */
+export function addAdvertisingFailedListener(listener) {
+    return BleAdvertiserModule.addListener('onAdvertisingFailed', listener);
+}
+/**
+ * Add listener for advertising stopped events
+ * @param listener Function to call when advertising stops
+ * @returns EventSubscription that can be used to remove the listener
+ */
+export function addAdvertisingStoppedListener(listener) {
+    return BleAdvertiserModule.addListener('onAdvertisingStopped', listener);
+}
+// Export the types for consumers
+export * from './BleAdvertiser.types';
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAOxC,OAAO,mBAAmB,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE1C,kFAAkF;AAClF,0EAA0E;AAC1E,+DAA+D;AAC/D,SAAS,yBAAyB,CAAC,KAAe;IAChD,IAAI,QAAQ,CAAC,EAAE,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC;IAC5C,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;QACxB,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC;QAC9C,OAAO,GAAG,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACzD,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,SAAS,CAAC,KAAe;IACvC,OAAO,mBAAmB,CAAC,SAAS,CAAC,yBAAyB,CAAC,KAAK,CAAC,CAAC,CAAC;AACzE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa;IAC3B,OAAO,mBAAmB,CAAC,aAAa,EAAE,CAAC;AAC7C,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,WAAW;IACzB,OAAO,mBAAmB,CAAC,WAAW,EAAE,CAAC;AAC3C,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,SAAS;IACvB,OAAO,mBAAmB,CAAC,SAAS,EAAE,CAAC;AACzC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,6BAA6B,CAC3C,QAAkD;IAElD,OAAO,mBAAmB,CAAC,WAAW,CAAC,sBAAsB,EAAE,QAAQ,CAAC,CAAC;AAC3E,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,4BAA4B,CAC1C,QAAiD;IAEjD,OAAO,mBAAmB,CAAC,WAAW,CAAC,qBAAqB,EAAE,QAAQ,CAAC,CAAC;AAC1E,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,6BAA6B,CAC3C,QAAkD;IAElD,OAAO,mBAAmB,CAAC,WAAW,CAAC,sBAAsB,EAAE,QAAQ,CAAC,CAAC;AAC3E,CAAC;AAED,iCAAiC;AACjC,cAAc,uBAAuB,CAAC","sourcesContent":["import { EventSubscription } from 'expo-modules-core';\nimport { Platform } from 'react-native';\n\nimport {\n  AdvertisingStartedEvent,\n  AdvertisingFailedEvent,\n  AdvertisingStoppedEvent,\n} from './BleAdvertiser.types';\nimport BleAdvertiserModule from './BleAdvertiserModule';\nimport { expand16BitUuid } from './utils';\n\n// HACK: Android's BluetoothLeAdvertiser only accepts 128-bit service UUIDs, while\n// CoreBluetooth on iOS accepts the 16-bit short form directly. Expand any\n// 16-bit input before handing it to the Android native module.\nfunction normalizeUuidsForPlatform(uuids: string[]): string[] {\n  if (Platform.OS !== 'android') return uuids;\n  return uuids.map((uuid) => {\n    const hex = uuid.replace(/[^0-9a-fA-F]/g, '');\n    return hex.length === 4 ? expand16BitUuid(uuid) : uuid;\n  });\n}\n\n/**\n * Start BLE advertising with the specified service UUIDs\n * @param uuids Array of service UUID strings to advertise\n * @returns Promise that resolves when advertising starts successfully\n */\nexport function broadcast(uuids: string[]): Promise<string> {\n  return BleAdvertiserModule.broadcast(normalizeUuidsForPlatform(uuids));\n}\n\n/**\n * Stop all BLE advertising\n * @returns Promise that resolves with information about stopped advertisers\n */\nexport function stopBroadcast(): Promise<{ stopped: boolean; stoppedAdvertisers?: number }> {\n  return BleAdvertiserModule.stopBroadcast();\n}\n\n/**\n * Check if BLE advertising is supported on this device\n * @returns Promise that resolves to true if supported, false otherwise\n */\nexport function isSupported(): Promise<boolean> {\n  return BleAdvertiserModule.isSupported();\n}\n\n/**\n * Check if Bluetooth is currently enabled\n * @returns Promise that resolves to true if enabled, false otherwise\n */\nexport function isEnabled(): Promise<boolean> {\n  return BleAdvertiserModule.isEnabled();\n}\n\n/**\n * Add listener for advertising started events\n * @param listener Function to call when advertising starts\n * @returns EventSubscription that can be used to remove the listener\n */\nexport function addAdvertisingStartedListener(\n  listener: (event: AdvertisingStartedEvent) => void\n): EventSubscription {\n  return BleAdvertiserModule.addListener('onAdvertisingStarted', listener);\n}\n\n/**\n * Add listener for advertising failed events\n * @param listener Function to call when advertising fails\n * @returns EventSubscription that can be used to remove the listener\n */\nexport function addAdvertisingFailedListener(\n  listener: (event: AdvertisingFailedEvent) => void\n): EventSubscription {\n  return BleAdvertiserModule.addListener('onAdvertisingFailed', listener);\n}\n\n/**\n * Add listener for advertising stopped events\n * @param listener Function to call when advertising stops\n * @returns EventSubscription that can be used to remove the listener\n */\nexport function addAdvertisingStoppedListener(\n  listener: (event: AdvertisingStoppedEvent) => void\n): EventSubscription {\n  return BleAdvertiserModule.addListener('onAdvertisingStopped', listener);\n}\n\n// Export the types for consumers\nexport * from './BleAdvertiser.types';\n"]}

package/build/utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Expands a 16-bit UUID to the full 128-bit Bluetooth UUID format.
+ *
+ * @param shortUuid 16-bit UUID string (with or without dashes)
+ * @returns Expanded 128-bit UUID string
+ * @throws Error if the input is not a valid 16-bit UUID
+ */
+export declare function expand16BitUuid(shortUuid: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/build/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAazD"}

package/build/utils.js

@@ -0,0 +1,19 @@
+/**
+ * Expands a 16-bit UUID to the full 128-bit Bluetooth UUID format.
+ *
+ * @param shortUuid 16-bit UUID string (with or without dashes)
+ * @returns Expanded 128-bit UUID string
+ * @throws Error if the input is not a valid 16-bit UUID
+ */
+export function expand16BitUuid(shortUuid) {
+    // Clean and validate input
+    const cleaned = shortUuid.replace(/[^0-9a-fA-F]/g, '');
+    if (!/^[0-9a-fA-F]{4}$/i.test(cleaned)) {
+        throw new Error(`Invalid 16-bit UUID: ${shortUuid}`);
+    }
+    // Pad to 4 chars and convert to lowercase
+    const paddedUuid = cleaned.padStart(4, '0').toLowerCase();
+    // Bluetooth Base UUID: 00000000-0000-1000-8000-00805F9B34FB
+    return `0000${paddedUuid}-0000-1000-8000-00805f9b34fb`;
+}
+//# sourceMappingURL=utils.js.map

package/build/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAAC,SAAiB;IAC/C,2BAA2B;IAC3B,MAAM,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC;IAEvD,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;QACvC,MAAM,IAAI,KAAK,CAAC,wBAAwB,SAAS,EAAE,CAAC,CAAC;IACvD,CAAC;IAED,0CAA0C;IAC1C,MAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;IAE1D,4DAA4D;IAC5D,OAAO,OAAO,UAAU,8BAA8B,CAAC;AACzD,CAAC","sourcesContent":["/**\n * Expands a 16-bit UUID to the full 128-bit Bluetooth UUID format.\n *\n * @param shortUuid 16-bit UUID string (with or without dashes)\n * @returns Expanded 128-bit UUID string\n * @throws Error if the input is not a valid 16-bit UUID\n */\nexport function expand16BitUuid(shortUuid: string): string {\n  // Clean and validate input\n  const cleaned = shortUuid.replace(/[^0-9a-fA-F]/g, '');\n\n  if (!/^[0-9a-fA-F]{4}$/i.test(cleaned)) {\n    throw new Error(`Invalid 16-bit UUID: ${shortUuid}`);\n  }\n\n  // Pad to 4 chars and convert to lowercase\n  const paddedUuid = cleaned.padStart(4, '0').toLowerCase();\n\n  // Bluetooth Base UUID: 00000000-0000-1000-8000-00805F9B34FB\n  return `0000${paddedUuid}-0000-1000-8000-00805f9b34fb`;\n}\n"]}

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["apple", "android"],
+  "apple": {
+    "modules": ["BleAdvertiserModule"]
+  },
+  "android": {
+    "modules": ["expo.modules.bleadvertiser.BleAdvertiserModule"]
+  }
+}

package/ios/BleAdvertiser.podspec

@@ -0,0 +1,22 @@
+Pod::Spec.new do |s|
+  s.name           = 'BleAdvertiser'
+  s.version        = '0.0.0'
+  s.summary        = 'Minimal BLE advertiser for React-Native, optimized for background processing.'
+  s.author         = 'The Blunt.ly Authors'
+  s.homepage       = 'https://github.com/Blunt-ly/ble-advertiser'
+  s.platforms      = {
+    :ios => '15.1',
+    :tvos => '15.1'
+  }
+  s.source         = { git: '' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+  }
+
+  s.source_files = "**/*.{h,m,mm,swift,hpp,cpp}"
+end

package/ios/BleAdvertiserModule.swift

@@ -0,0 +1,246 @@
+import ExpoModulesCore
+import CoreBluetooth
+
+// The GATT characteristic UUID reuses the network UUID (first element passed to broadcast()).
+// CoreBluetooth distinguishes services and characteristics by their role in the GATT hierarchy.
+
+private class BlePeripheralManagerDelegate: NSObject, CBPeripheralManagerDelegate {
+  weak var module: BleAdvertiserModule?
+
+  init(module: BleAdvertiserModule) {
+    self.module = module
+    super.init()
+  }
+
+  func peripheralManagerDidUpdateState(_ peripheral: CBPeripheralManager) {
+    module?.handlePeripheralManagerDidUpdateState(peripheral)
+  }
+
+  func peripheralManagerDidStartAdvertising(_ peripheral: CBPeripheralManager, error: Error?) {
+    module?.handlePeripheralManagerDidStartAdvertising(peripheral, error: error)
+  }
+
+  func peripheralManager(_ peripheral: CBPeripheralManager, didAdd service: CBService, error: Error?) {
+    module?.handlePeripheralManagerDidAddService(peripheral, service: service, error: error)
+  }
+
+  func peripheralManager(_ peripheral: CBPeripheralManager, didReceiveRead request: CBATTRequest) {
+    module?.handlePeripheralManagerDidReceiveRead(peripheral, request: request)
+  }
+}
+
+public class BleAdvertiserModule: Module {
+  private var peripheralManager: CBPeripheralManager?
+  private var delegate: BlePeripheralManagerDelegate?
+  private var isAdvertising = false
+  private var currentAdvertisingUUIDs: [String] = []
+  private var gattService: CBMutableService?
+  private var broadcastIdCharacteristic: CBMutableCharacteristic?
+  private var currentBroadcastId: String?
+
+  public func definition() -> ModuleDefinition {
+    Name("BleAdvertiser")
+
+    Events("onAdvertisingStarted", "onAdvertisingFailed", "onAdvertisingStopped")
+
+    OnCreate {
+      self.delegate = BlePeripheralManagerDelegate(module: self)
+      self.peripheralManager = CBPeripheralManager(delegate: self.delegate, queue: nil)
+    }
+
+    AsyncFunction("broadcast") { (uuids: [String], promise: Promise) in
+      guard let peripheralManager = self.peripheralManager else {
+        promise.reject("PERIPHERAL_MANAGER_NOT_AVAILABLE", "Peripheral manager is not available")
+        return
+      }
+
+      guard peripheralManager.state == .poweredOn else {
+        let stateDescription = self.bluetoothStateDescription(peripheralManager.state)
+        promise.reject("BLUETOOTH_NOT_READY", "Bluetooth state: \(stateDescription)")
+        return
+      }
+
+      guard !uuids.isEmpty else {
+        promise.reject("NO_UUIDS", "At least one service UUID is required")
+        return
+      }
+
+      // Stop any existing advertising and remove existing GATT services
+      if self.isAdvertising {
+        peripheralManager.stopAdvertising()
+        self.isAdvertising = false
+      }
+      if self.gattService != nil {
+        peripheralManager.removeAllServices()
+        self.gattService = nil
+      }
+
+      // Convert string UUIDs to CBUUID objects
+      var serviceUUIDs: [CBUUID] = []
+      for uuidString in uuids {
+        let cbuuid = CBUUID(string: uuidString)
+        serviceUUIDs.append(cbuuid)
+      }
+
+      self.currentAdvertisingUUIDs = uuids
+
+      // Identify the network UUID (first) and broadcast ID (second) from the uuids array.
+      // Register a GATT service under the network UUID with a readable characteristic
+      // that returns the broadcast ID. This allows centrals that discover us via the
+      // overflow area (where only the known network UUID is visible) to connect and
+      // retrieve our device-specific broadcast ID through GATT.
+      if uuids.count >= 2 {
+        let networkUUID = CBUUID(string: uuids[0])
+        self.currentBroadcastId = uuids[1]
+
+        self.broadcastIdCharacteristic = CBMutableCharacteristic(
+          type: networkUUID,
+          properties: [.read],
+          value: nil,  // nil = dynamic, served via didReceiveRead delegate
+          permissions: [.readable]
+        )
+
+        let service = CBMutableService(type: networkUUID, primary: true)
+        service.characteristics = [self.broadcastIdCharacteristic!]
+        self.gattService = service
+
+        // Adding the service triggers didAdd delegate; advertising starts after that
+        self.broadcastPromise = promise
+        peripheralManager.add(service)
+      } else {
+        // Single UUID — no GATT service needed, just advertise directly
+        let advertisementData: [String: Any] = [CBAdvertisementDataServiceUUIDsKey: serviceUUIDs]
+        peripheralManager.startAdvertising(advertisementData)
+        self.broadcastPromise = promise
+      }
+    }
+
+    AsyncFunction("stopBroadcast") { (promise: Promise) in
+      guard let peripheralManager = self.peripheralManager else {
+        promise.reject("PERIPHERAL_MANAGER_NOT_AVAILABLE", "Peripheral manager is not available")
+        return
+      }
+
+      if self.isAdvertising {
+        peripheralManager.stopAdvertising()
+        self.isAdvertising = false
+        self.sendEvent("onAdvertisingStopped", ["uuids": self.currentAdvertisingUUIDs])
+        self.currentAdvertisingUUIDs = []
+      }
+
+      if self.gattService != nil {
+        peripheralManager.removeAllServices()
+        self.gattService = nil
+        self.broadcastIdCharacteristic = nil
+        self.currentBroadcastId = nil
+      }
+
+      promise.resolve(["stopped": self.isAdvertising == false])
+    }
+
+    AsyncFunction("isSupported") { (promise: Promise) in
+      let isSupported = CBPeripheralManager.authorization == .allowedAlways ||
+                       CBPeripheralManager.authorization == .notDetermined
+      promise.resolve(isSupported)
+    }
+
+    AsyncFunction("isEnabled") { (promise: Promise) in
+      guard let peripheralManager = self.peripheralManager else {
+        promise.resolve(false)
+        return
+      }
+
+      let isEnabled = peripheralManager.state == .poweredOn
+      promise.resolve(isEnabled)
+    }
+  }
+
+  private var broadcastPromise: Promise?
+
+  // MARK: - Delegate Handler Methods
+
+  func handlePeripheralManagerDidUpdateState(_ peripheral: CBPeripheralManager) {
+    let stateDescription = bluetoothStateDescription(peripheral.state)
+    print("BleAdvertiser: Peripheral manager state changed to \(stateDescription)")
+  }
+
+  func handlePeripheralManagerDidAddService(_ peripheral: CBPeripheralManager, service: CBService, error: Error?) {
+    if let error = error {
+      print("BleAdvertiser: Failed to add GATT service: \(error.localizedDescription)")
+      self.broadcastPromise?.reject("GATT_SERVICE_FAILED", error.localizedDescription)
+      self.broadcastPromise = nil
+      return
+    }
+
+    print("BleAdvertiser: GATT service added, starting advertisement")
+
+    var serviceUUIDs: [CBUUID] = []
+    for uuidString in self.currentAdvertisingUUIDs {
+      serviceUUIDs.append(CBUUID(string: uuidString))
+    }
+
+    let advertisementData: [String: Any] = [CBAdvertisementDataServiceUUIDsKey: serviceUUIDs]
+    peripheral.startAdvertising(advertisementData)
+  }
+
+  func handlePeripheralManagerDidReceiveRead(_ peripheral: CBPeripheralManager, request: CBATTRequest) {
+    guard request.characteristic.uuid == self.broadcastIdCharacteristic?.uuid else {
+      peripheral.respond(to: request, withResult: .attributeNotFound)
+      return
+    }
+
+    guard let broadcastId = self.currentBroadcastId,
+          let data = broadcastId.data(using: .utf8) else {
+      peripheral.respond(to: request, withResult: .unlikelyError)
+      return
+    }
+
+    guard request.offset <= data.count else {
+      peripheral.respond(to: request, withResult: .invalidOffset)
+      return
+    }
+
+    request.value = data.subdata(in: request.offset..<data.count)
+    peripheral.respond(to: request, withResult: .success)
+    print("BleAdvertiser: Responded to GATT read request with broadcastId: \(broadcastId)")
+  }
+
+  func handlePeripheralManagerDidStartAdvertising(_ peripheral: CBPeripheralManager, error: Error?) {
+    if let error = error {
+      print("BleAdvertiser: Failed to start advertising: \(error.localizedDescription)")
+      self.isAdvertising = false
+      self.sendEvent("onAdvertisingFailed", [
+        "error": error.localizedDescription,
+        "uuids": self.currentAdvertisingUUIDs
+      ])
+      self.broadcastPromise?.reject("ADVERTISING_FAILED", error.localizedDescription)
+    } else {
+      print("BleAdvertiser: Successfully started advertising")
+      self.isAdvertising = true
+      self.sendEvent("onAdvertisingStarted", ["uuids": self.currentAdvertisingUUIDs])
+      self.broadcastPromise?.resolve("Advertising started successfully")
+    }
+    self.broadcastPromise = nil
+  }
+
+  // MARK: - Helper Methods
+
+  private func bluetoothStateDescription(_ state: CBManagerState) -> String {
+    switch state {
+    case .unknown:
+      return "unknown"
+    case .resetting:
+      return "resetting"
+    case .unsupported:
+      return "unsupported"
+    case .unauthorized:
+      return "unauthorized"
+    case .poweredOff:
+      return "powered off"
+    case .poweredOn:
+      return "powered on"
+    @unknown default:
+      return "unknown state"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@blunt-ly/ble-advertiser",
+  "version": "0.0.0",
+  "description": "Minimal BLE advertiser for React-Native, optimized for background processing.",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "node internal/module_scripts/build.js",
+    "clean": "node internal/module_scripts/clean.js",
+    "lint": "eslint src/",
+    "prepare": "node internal/module_scripts/prepare.js",
+    "open:ios": "node internal/module_scripts/open-ios.js",
+    "open:android": "node internal/module_scripts/open-android.js"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "bluetooth",
+    "ble",
+    "advertiser",
+    "ble-advertiser"
+  ],
+  "repository": "https://github.com/Blunt-ly/ble-advertiser",
+  "bugs": {
+    "url": "https://github.com/Blunt-ly/ble-advertiser/issues"
+  },
+  "author": "The Blunt.ly Authors",
+  "license": "MIT",
+  "homepage": "https://github.com/Blunt-ly/ble-advertiser#readme",
+  "files": [
+    "build",
+    "src",
+    "android",
+    "ios",
+    "expo-module.config.json",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {},
+  "devDependencies": {
+    "@types/react": "~19.1.1",
+    "eslint": "~9.39.4",
+    "eslint-config-universe": "^15.0.3",
+    "expo": "^56.0.3",
+    "react-native": "0.82.1",
+    "typescript": "^5.9.2"
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*"
+  }
+}

package/src/BleAdvertiser.types.ts

@@ -0,0 +1,20 @@
+export type AdvertisingStartedEvent = {
+  uuids: string[];
+};
+
+export type AdvertisingFailedEvent = {
+  error: string;
+  errorCode?: number;
+  uuids?: string[];
+};
+
+export type AdvertisingStoppedEvent = {
+  uuids?: string[];
+  stoppedCount?: number;
+};
+
+export type BleAdvertiserModuleEvents = {
+  onAdvertisingStarted: (params: AdvertisingStartedEvent) => void;
+  onAdvertisingFailed: (params: AdvertisingFailedEvent) => void;
+  onAdvertisingStopped: (params: AdvertisingStoppedEvent) => void;
+};

package/src/BleAdvertiserModule.ts

@@ -0,0 +1,33 @@
+import { NativeModule, requireNativeModule } from 'expo';
+
+import { BleAdvertiserModuleEvents } from './BleAdvertiser.types';
+
+declare class BleAdvertiserModule extends NativeModule<BleAdvertiserModuleEvents> {
+  /**
+   * Start BLE advertising with the specified service UUIDs
+   * @param uuids Array of service UUID strings to advertise
+   * @returns Promise that resolves when advertising starts successfully
+   */
+  broadcast(uuids: string[]): Promise<string>;
+
+  /**
+   * Stop all BLE advertising
+   * @returns Promise that resolves with information about stopped advertisers
+   */
+  stopBroadcast(): Promise<{ stopped: boolean; stoppedAdvertisers?: number }>;
+
+  /**
+   * Check if BLE advertising is supported on this device
+   * @returns Promise that resolves to true if supported, false otherwise
+   */
+  isSupported(): Promise<boolean>;
+
+  /**
+   * Check if Bluetooth is currently enabled
+   * @returns Promise that resolves to true if enabled, false otherwise
+   */
+  isEnabled(): Promise<boolean>;
+}
+
+// This call loads the native module object from the JSI.
+export default requireNativeModule<BleAdvertiserModule>('BleAdvertiser');

package/src/index.ts

@@ -0,0 +1,90 @@
+import { EventSubscription } from 'expo-modules-core';
+import { Platform } from 'react-native';
+
+import {
+  AdvertisingStartedEvent,
+  AdvertisingFailedEvent,
+  AdvertisingStoppedEvent,
+} from './BleAdvertiser.types';
+import BleAdvertiserModule from './BleAdvertiserModule';
+import { expand16BitUuid } from './utils';
+
+// HACK: Android's BluetoothLeAdvertiser only accepts 128-bit service UUIDs, while
+// CoreBluetooth on iOS accepts the 16-bit short form directly. Expand any
+// 16-bit input before handing it to the Android native module.
+function normalizeUuidsForPlatform(uuids: string[]): string[] {
+  if (Platform.OS !== 'android') return uuids;
+  return uuids.map((uuid) => {
+    const hex = uuid.replace(/[^0-9a-fA-F]/g, '');
+    return hex.length === 4 ? expand16BitUuid(uuid) : uuid;
+  });
+}
+
+/**
+ * Start BLE advertising with the specified service UUIDs
+ * @param uuids Array of service UUID strings to advertise
+ * @returns Promise that resolves when advertising starts successfully
+ */
+export function broadcast(uuids: string[]): Promise<string> {
+  return BleAdvertiserModule.broadcast(normalizeUuidsForPlatform(uuids));
+}
+
+/**
+ * Stop all BLE advertising
+ * @returns Promise that resolves with information about stopped advertisers
+ */
+export function stopBroadcast(): Promise<{ stopped: boolean; stoppedAdvertisers?: number }> {
+  return BleAdvertiserModule.stopBroadcast();
+}
+
+/**
+ * Check if BLE advertising is supported on this device
+ * @returns Promise that resolves to true if supported, false otherwise
+ */
+export function isSupported(): Promise<boolean> {
+  return BleAdvertiserModule.isSupported();
+}
+
+/**
+ * Check if Bluetooth is currently enabled
+ * @returns Promise that resolves to true if enabled, false otherwise
+ */
+export function isEnabled(): Promise<boolean> {
+  return BleAdvertiserModule.isEnabled();
+}
+
+/**
+ * Add listener for advertising started events
+ * @param listener Function to call when advertising starts
+ * @returns EventSubscription that can be used to remove the listener
+ */
+export function addAdvertisingStartedListener(
+  listener: (event: AdvertisingStartedEvent) => void
+): EventSubscription {
+  return BleAdvertiserModule.addListener('onAdvertisingStarted', listener);
+}
+
+/**
+ * Add listener for advertising failed events
+ * @param listener Function to call when advertising fails
+ * @returns EventSubscription that can be used to remove the listener
+ */
+export function addAdvertisingFailedListener(
+  listener: (event: AdvertisingFailedEvent) => void
+): EventSubscription {
+  return BleAdvertiserModule.addListener('onAdvertisingFailed', listener);
+}
+
+/**
+ * Add listener for advertising stopped events
+ * @param listener Function to call when advertising stops
+ * @returns EventSubscription that can be used to remove the listener
+ */
+export function addAdvertisingStoppedListener(
+  listener: (event: AdvertisingStoppedEvent) => void
+): EventSubscription {
+  return BleAdvertiserModule.addListener('onAdvertisingStopped', listener);
+}
+
+// Export the types for consumers
+export * from './BleAdvertiser.types';

package/src/utils.ts

@@ -0,0 +1,21 @@
+/**
+ * Expands a 16-bit UUID to the full 128-bit Bluetooth UUID format.
+ *
+ * @param shortUuid 16-bit UUID string (with or without dashes)
+ * @returns Expanded 128-bit UUID string
+ * @throws Error if the input is not a valid 16-bit UUID
+ */
+export function expand16BitUuid(shortUuid: string): string {
+  // Clean and validate input
+  const cleaned = shortUuid.replace(/[^0-9a-fA-F]/g, '');
+
+  if (!/^[0-9a-fA-F]{4}$/i.test(cleaned)) {
+    throw new Error(`Invalid 16-bit UUID: ${shortUuid}`);
+  }
+
+  // Pad to 4 chars and convert to lowercase
+  const paddedUuid = cleaned.padStart(4, '0').toLowerCase();
+
+  // Bluetooth Base UUID: 00000000-0000-1000-8000-00805F9B34FB
+  return `0000${paddedUuid}-0000-1000-8000-00805f9b34fb`;
+}