Direct bluetooth device connection

Please note that ThryveBLE module is in beta; Flutter support will follow.

React Native: only the ThryveGarminCompanion module is available. ThryveBLE (heart rate and glucose monitors) is not supported.

Starting with version 5.3.0, the Thryve SDK supports Garmin Companion

With Thryve, you can connect Garmin Companion devices, blood glucose monitors and heart rate monitors directly via Bluetooth Low Energy (BLE). The Thryve Device module abstracts the complexity of Bluetooth integration by providing:

Effortless connectivity: Automatically handles permissions, device discovery, connections, and communication.
Automated data access: Retrieves health data from connected devices and uploads it to the Thryve data warehouse, ensuring your application always has up-to-date metrics.
Comprehensive device handling: Manages device interactions end-to-end, from connection stability to reliable data acquisition.

This guide explains how to let users connect and disconnect devices and includes UI integration examples. For a best-practice implementation, refer to the Thryve Sample App.

The module is compatible with Blood Glucose Monitors and Heart Rate Monitors that adhere to open Bluetooth device profiles. Devices from manufacturers that do not follow Bluetooth standards may not function properly.

Verified Blood Glucose Monitors

Correct functionality has been verified for the following devices:

Roche ACCU-CHEK Instant
Roche ACCU-CHEK Guide
FORA 6 Connect
Contour Care

Verified Devices with real-time BLE broadcasting capabilities

Correct functionality has been verified for the following devices:

Coros Heart Rate Monitor
Garmin HRM-Dual
Polar H7 Heart Rate Sensor
Polar H9 Heart Rate Sensor
Polar H10 Heart Rate Sensor
Suunto Smart Heart Rate Belt
Whoop 4.0 (requires enabled Heart Rate Broadcast)
Whoop 5.0 (requires enabled Heart Rate Broadcast)
Garmin Companion Devices

Integrate Thryve BLE with your application

To be able to integrate ThryveBLE module you need to:

Integrate the ThryveBLE module for Blood Glucose Monitors and Heart Rate Monitors and/or Integrate the ThryveGarminCompanion modules for Garmin Companion devices Make sure to also add ThryveCore and ThryveCommons modules. Follow either the cocoapods or framework files instructions in the iOS section.
Add Bluetooth Capability In Xcode: Navigate to Target → Signing & Capabilities → add (+) → Bluetooth.
Add Bluetooth Background Mode In Xcode: Navigate to Target → Signing & Capabilities → add (+) Background Modes → "Uses Bluetooth LE accessories" - it is needed if you want streaming to continue in the background.
Add Privacy - Bluetooth Always Usage Description to Info.plist <key>NSBluetoothAlwaysUsageDescription</key>
<string>Bluetooth permission for Thryve</string>

Integrate the thryve_module_ble module for Blood Glucose Monitors and Heart Rate Monitors and/or Integrate the thryve_module_garmin_companion module for Garmin Companion devices. Make sure to also add thryve_core_sdk and thryve_module_commons modules. Follow the instructions in either the Thryve Repository Dependencies or Thryve .aar Libraries in the Android section

Add the following BLUETOOTH permissions to the AndroidManifest.xml

<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_SCAN" android:usesPermissionFlags="neverForLocation" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />

Add the ACCESS_FINE_LOCATION permission to AndroidManifest.xml This is required for all applications targeting Android devices running below Android 12
```
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
```

Configure the `ThryveBLE` and `ThryveGarminCompanion` modules

When initializing Thryve SDK make sure to define the deviceTypes and an optional ThryveDeviceEventListener in the ThryveDeviceConfig .

import ThryveCore
import ThryveCommons

let deviceConfig = ThryveDeviceConfig(
    // Optional: restricts BLE discovery. Defaults to Set(ThryveDeviceType.allCases).
    deviceTypes: [.heartRateMonitor, .glucoseMonitor],
    garminCompanionConfig: ThryveGarminCompanionConfig(
        license: "YOUR_GARMIN_LICENSE",
        // Optional: restricts the real-time types streamed from the Garmin device. Defaults to Set(ThryveGarminCompanionDataType.allCases).
        dataTypes: [.heartRate, .stress, .steps],
        // Optional: selects the active Garmin modes. Defaults to ThryveGarminCompanionMode.allCases.
        modes: [.realTime]
    ),
    // Optional: Receives callbacks for device found/connected/disconnected/data `ThryveDeviceEventListener` protocol
    // Implements any of `onDeviceFound(response: ThryveResponse<ThryveDevice>)`, 
    // `onDeviceConnecting(response: ThryveResponse<ThryveDevice>)`, 
    // `onDeviceConnected(response: ThryveResponse<ThryveDevice>)`, 
    // `onDeviceDisconnected(response: ThryveResponse<ThryveDevice>)`, 
    // `onDeviceReadingReceived(device: ThryveBLEDevice, dataType: any ThryveDataType, response: ThryveResponse<ThryveDeviceReading>)` functions
    eventListener: self 
)

let thryveSDKConfig = ThryveSDKConfig(
    authId: "AUTH_ID",
    authSecret: "AUTH_SECRET",
    endUserAlias: "YOUR_UNIQUE_USER_IDENTIFIER",
    endUserId: nil, 
    locale: "de",
    configs: [deviceConfig],
    observability: ObservabilityConfig(tracingEnabled: true, crashReportingEnabled: true)
)
        
let thryveSDK = await ThryveSDK.getOrCreate(thryveSDKConfig)

// Optionally, when ThryveSDK is initialized from a non-async context (AppDelegate, legacy code, etc.), it is recommended to use the getOrCreate(...) callback to know when the SDK is ready.

ThryveSDK.getOrCreate(thryveSDKConfig) { initResult in
    if initResult.successful {
        Logger.i { "ThryveSDK ready, you can start calling API methods" }
    } else if let error = initResult.errors?.first {
        Logger.e { "ThryveSDK init failed: \(error.errorMessage ?? "Unknown error")" }
    }
}

 val deviceConfig = ThryveDeviceConfig(
        deviceTypes = ThryveDeviceType.entries,
        garminCompanionConfig = ThryveGarminCompanionConfig(
            license = "YOUR_GARMIN_LICENSE",
            modes = listOf(ThryveGarminCompanionMode.REAL_TIME),
            dataTypes = ThryveGarminCompanionDataType.entries.toList(),
        ),
        eventsListener = object : ThryveDeviceEventListener {
            override fun onDeviceFound(response: ThryveResponse<ThryveDevice>) {}
            override fun onDeviceConnecting(response: ThryveResponse<ThryveDevice>) {}
            override fun onDeviceConnected(response: ThryveResponse<ThryveDevice>) {}
            override fun onDeviceDisconnected(response: ThryveResponse<ThryveDevice>) {}
            override fun onDeviceReadingReceived(device: ThryveDevice, dataType: ThryveDataType, response: ThryveResponse<ThryveDeviceReading>) {}
        }
 )

val thryveSDKConfig = ThryveSDKConfig(
    authId = "ASSIGNED_AUTH_ID",
    authSecret = "ASSIGNED_AUTH_SECRET",
    endUserAlias = "XXXXXXXXXXX",
    endUserId = null, 
    locale = "de",
    deviceConfig = deviceConfig
)
                 
val thryveSDK = ThryveSDK.getOrCreate(thryveSDKConfig, context)

val thryveSDK = ThryveSDK.getOrCreate(thryveSDKConfig, context) { thryveResponse ->
       if(thryveResponse.successful){
           //ThyveSDK initialization processes completed successfully
       } else {
           // ThryveSDK initalization process failed. process the ThryveErrors for the specific reason.
           thryveResponse.errors.map { thryveError -> Logger.e(TAG){" getOrCreate ThryveError in onCreate function $thryveError"} }
       }
  }

import {
  ThryveSDK,
  ThryveDeviceType,
  ThryveGarminCompanionMode,
  ThryveGarminCompanionDataType,
  useDeviceEventListener,
} from '@thryve/react-native-sdk';

const thryve = new ThryveSDK();

async function initialiseThryve() {
  const response = await thryve.getOrCreate({
    authId: 'AUTH_ID',
    authSecret: 'AUTH_SECRET',
    endUserAlias: 'YOUR_UNIQUE_USER_IDENTIFIER',
    endUserId: null,
    locale: 'de',
    configs: [], // health-data sources (Apple, Health Connect, ...) go here
    deviceConfig: {
      deviceTypes: [ThryveDeviceType.GARMIN_COMPANION],
      // Required: `getOrCreate` throws without a license.
      garminCompanionConfig: {
        license: 'YOUR_GARMIN_LICENSE',
        // Optional
        modes: [ThryveGarminCompanionMode.REAL_TIME],
        // Optional: restricts the data types streamed from the Garmin device.
        dataTypes: [
          ThryveGarminCompanionDataType.HEART_RATE,
          ThryveGarminCompanionDataType.STRESS,
          ThryveGarminCompanionDataType.STEPS,
        ],
      },
    },
  });

  // `ThryveResponse` in RN has no `successful` flag. Check `errors` instead.
  if (response.errors && response.errors.length > 0) {
    // ThryveSDK init failed. Process the `ThryveError`s for the specific reason.
    response.errors.forEach((error) => console.error('ThryveSDK init failed:', error.message));
    return;
  }

  // ThryveSDK ready, you can start calling API methods.
}

// Optional: receive callbacks for device found/connecting/connected/disconnected/readings.
// Register them with this hook inside a React component. Implement any of them.
function DeviceScreen() {
  useDeviceEventListener({
    onDeviceFound: (response) => {},
    onDeviceConnecting: (response) => {},
    onDeviceConnected: (response) => {},
    onDeviceDisconnected: (response) => {},
    onDeviceReadingReceived: (device, dataType, response) => {},
    onDataUpload: (response) => {},
  });

  // ...
}

Parameter

Description

Mandatory

deviceTypes

Limits the BLE device types the host application supports (e.g. garminCompanion or heartRateMonitor). Only devices matching the ThryveDeviceType will appear in discovery.

garminCompanionConfig

Configuration for ThryveGarminCompanion module

license Garmin Companion specific license issued by Garmin.

dataTypes ThryveGarminCompanionDataType supported by your app.

modes ThryveGarminCompanionMode supported by your app. Only realTime mode is currently supported

eventListener

An object of ThryveDeviceEventListener that will have to implement the following functions to receive events from the Thryve BLE modules.

onDeviceFound(response: ThryveResponse<ThryveDevice>) 
onDeviceConnecting(response: ThryveResponse<ThryveDevice>) 
onDeviceConnected(response: ThryveResponse<ThryveDevice>)
onDeviceDisconnected(response: ThryveResponse<ThryveDevice>) 
onDeviceReadingReceived(device: ThryveDevice, dataType: any ThryveDataType, response: ThryveResponse<ThryveDeviceReading>)

Allow users to connect to devices

To enable Bluetooth connectivity for users, implement the following features:

Display a list of nearby devices available for connection.
Allow users to connect to and disconnect from devices.
Provide connection status and troubleshooting information.

Using ThryveBLE, these functionalities can be achieved quickly with just a few functions to expedite your initial integration.

Start device discovery

To discover nearby BLE devices, initiate startDeviceDiscovery. Handle any found devices using onDeviceFound in the ThryveDeviceEventListener. The discovery will end when stopDeviceDiscovery is called or the discovery process timed out as per configuration.

The Thryve SDK only returns Bluetooth devices that match the configured Bluetooth Device Profiles, automatically filtering out unsupported devices.

Be aware that devices may appear compatible if manufacturers advertise open Bluetooth Device Profiles in device discovery, yet choose proprietary integration methods for connection and data access.

import ThryveCore
import ThryveCommons

class DeviceViewModel: ObservableObject, ThryveDeviceEventListener {

     init() {
        // Registers this object as the event listener. Safe to call before the SDK is ready.
        // Repeat `deviceTypes` - omitting it resets the filter to all types.
        ThryveSDK.get().updateModuleConfig(
            config: ThryveDeviceConfig(
                deviceTypes: [.heartRateMonitor, .glucoseMonitor],
                eventListener: self))
    }

    func startScan() {
        Task {
            // Returns only when the scan window closes (`scanTimeoutSeconds`, 120s by default).
            // Devices are reported incrementally via `onDeviceFound` while scanning.
            let response = await ThryveSDK.get().startDeviceDiscovery()
            guard response.successful else {
                // Process all `[ThryveError]` in `response.errors`
                return
            }

            // Returns a list of `ThryveDevice` found
            let listOfThryveDevices = response.data
        }
    }

    // `onDeviceFound` method is a `ThryveDeviceEventListener` event listener callback.
    // It is automatically triggered by ThryveSDK each time a `ThryveDevice` is found
    // during the scanning session in `ThryveSDK.get().startDeviceDiscovery()`
    func onDeviceFound(response: ThryveResponse<ThryveDevice>) {
        guard let device = response.data else {
            // Process all `[ThryveError]` in `response.errors`
            return
        }
        // Process the `ThryveDevice` found in the `startDeviceDiscovery` process
        // example update UI with the device object
    }

    // Call `stopDeviceDiscovery()` to stop the BLE discovery or scanning process
    func stopScan() {
        Task {
            _ = await ThryveSDK.get().stopDeviceDiscovery()
        }
    }
}

import com.thryve.sdk.ThryveSDK
import com.thryve.sdk.ble

...
fun startScan(activity: ComponentActivity) {
    val response = suspendCancellableCoroutine { continuation ->
        ThryveSDK.get().startDeviceDiscovery(sources = sources, activity = activity) { response ->
            continuation.resume(response)
        }
    }
                
    if (!response.successful) {
      // Process all [ThryveErrors] in response.errors
      return 
    }   
             
   //returns a list of ThryveDevice found
   val listOfThryveDevices = response.data               
}

 //onDeviceFound method is a ThryveDeviceEventListener event listener callback.
 //It is automatically triggered by ThryveSDK each time a ThryveDevice is found 
 //during the scanning session in ThryveSDK.get().startDeviceDiscovery
override fun onDeviceFound(response: ThryveResponse<ThryveDevice>) {
    if (!response.successful) {
       // Process all [ThryveErrors] in response.errors
       return
    } 
    
    val thryveDevice = response.data
    //process the ThryveDevice found in the startDeviceDiscovery process
    //example update UI with the thryveDevice object 
}

//Call stopDeviceDiscovery to stop the device discovery or scanning process
fun stopScan() {
    val response = suspendCancellableCoroutine { continuation ->
        ThryveSDK.get().stopDeviceDiscovery(sources) { response ->
            continuation.resume(response)
        }
    }
                
    if (response.successful) {
      // device discovery process has stopped.
    }else{
      // Process all [ThryveErrors] in response.errors
    } 
}
...

import { Source, useDeviceEventListener } from '@thryve/react-native-sdk';

// `thryve` is the initialised ThryveSDK instance (see initialisation above).

async function startScan() {
  // Start Garmin first: `await thryve.start(Source.GARMIN_COMPANION, [])`.
  // Optional `sources`: [Source.GARMIN_COMPANION]; omit for all.
  // Resolves only when the scan window closes.
  // Devices are reported incrementally via `onDeviceFound` while scanning.
  const response = await thryve.startDeviceDiscovery([Source.GARMIN_COMPANION]);
  if (response.errors && response.errors.length > 0) {
    // Process all `ThryveError`s in `response.errors`
    return;
  }

  // Returns a list of `ThryveDevice` found
  const listOfThryveDevices = response.data;
}

function DeviceScreen() {
  // `onDeviceFound` is a device event callback, registered with the
  // `useDeviceEventListener` hook inside a React component.
  // It is triggered automatically by the SDK each time a `ThryveDevice` is found
  // during the scanning session in `thryve.startDeviceDiscovery()`.
  useDeviceEventListener({
    onDeviceFound: (response) => {
      if (response.errors && response.errors.length > 0) {
        // Process all `ThryveError`s in `response.errors`
        return;
      }

      // Process the `ThryveDevice` found in the `startDeviceDiscovery` process
      // example: update UI with `response.data`
    },
  });

  // ...
}

// Call `stopDeviceDiscovery` to stop the discovery or scanning process
async function stopScan() {
  const response = await thryve.stopDeviceDiscovery([Source.GARMIN_COMPANION]);
  if (response.errors && response.errors.length > 0) {
    // Process all `ThryveError`s in `response.errors`
    return;
  }

  // The device discovery process has stopped.
}

Recommendation:

Manage the scanning process carefully. Avoid continuous scanning or high scanning timeouts when no devices are available, or users opt not to connect a device. Continuous scanning can significantly drain the smartphone's battery, leading to user frustration and potential app uninstallation.

Connect to BLE device

To enable users to connect to a BLE device upon a button click, utilize the connectDevice method from the ThryveBLE. Handle the connection status through the ThryveDeviceEventListener interface, using the onDeviceConnecting and onDeviceConnected callback methods for processing connection events effectively.

Showing Bluetooth Device Pairing Process

Once connected, all available data is automatically retrieved and uploaded to the Thryve backend. For broadcasting devices like heart rate monitors, heart rate data is accessible locally in real-time and is automatically uploaded every 300 readings or every 5 minutes, or on stop/disconnect.

import ThryveCore
import ThryveCommons

// The SDK holds `eventListener` weakly - make sure the app retains this object,
// or events stop arriving silently.
class DeviceViewModel: ObservableObject, ThryveDeviceEventListener {

    func connect(_ device: ThryveDevice) {
        Task {
            let response: ThryveResponse<Bool> = await ThryveSDK.get().connectDevice(device)
            guard response.successful else {
                // Process all `[ThryveError]` in `response.errors`
                return 
            }
            
            // Process the connection status in the response object 
          }
    }
    
    // `onDeviceConnecting` method is a `ThryveDeviceEventListener` event listener callback.
    // It is automatically triggered by ThryveSDK each time a `ThryveDevice` is connecting 
    // during the execution of `ThryveSDK.get().connectDevice()`
    func onDeviceConnecting(response: ThryveResponse<ThryveDevice>) {
        guard response.successful else {
            // Process all `[ThryveError]` in `response.errors`
            return 
        }
        
        // Process `response.data`. example update UI
    }
    
    // `onDeviceConnected` method is a `ThryveDeviceEventListener` event listener callback.
    // It is automatically triggered by ThryveSDK each time a `ThryveDevice` is connected 
    // during the execution of `ThryveSDK.get().connectDevice()`.
    // Data is automatically uploaded when a BLE device is connected.
    func onDeviceConnected(response: ThryveResponse<ThryveDevice>) {
        guard response.successful else {
            // Process all `[ThryveError]` in `response.errors`
            return 
        }
        
        // Process `response.data`. example update UI
    }
}

import com.thryve.sdk.ThryveSDK
import com.thryve.sdk.ble

...
fun connectDevice(activity: ComponentActivity, thryveDevice: ThryveDDevice) {
    val response = suspendCancellableCoroutine { continuation ->
        ThryveSDK.get().connectDevice(thryveDevice, activity) { response ->
            continuation.resume(response)
        }
    }
                
    if (!response.successful) {
      // Process all [ThryveErrors] in response.errors
      return 
    }   
             
   //thryveDevice has connected. update application UI          
}

 //onDeviceConnecting method is a ThryveDeviceEventListener event listener callback.
 //It is automatically triggered by ThryveSDK each time a ThryveDevice is connecting 
 //during the execution of ThryveSDK.get().connectDevice
 override fun onDeviceConnecting(response: ThryveResponse<ThryveDevice>) { response ->
    if (!response.successful) {
       // Process all [ThryveErrors] in response.errors
       return
    } 
    
    //ThryveDevice is connecting.
}

 //onDeviceConnected method is a ThryveDeviceEventListener event listener callback.
 //It is automatically triggered by ThryveSDK each time a ThryveDevice is connected 
 //during the execution of ThryveSDK.get().connectDevice
 //Data is automatically uploaded when a device is connected.
 override fun onDeviceConnected(response: ThryveResponse<ThryveDevice>) {
    if (!response.successful) {
       // Process all [ThryveErrors] in response.errors
       return
    } 
    //ThryveDevice is connected.process response.data. example update UI
}

...

import { ThryveDevice, useDeviceEventListener } from '@thryve/react-native-sdk';

// `thryve` is the initialised ThryveSDK instance (see initialisation above).

async function connect(device: ThryveDevice) {
  const response = await thryve.connectDevice(device);
  if (response.errors && response.errors.length > 0) {
    // Process all `ThryveError`s in `response.errors`
    return;
  }

  // Process the connection status in `response.data`
}

function DeviceScreen() {
  // Callbacks fired while `thryve.connectDevice()` runs.
  useDeviceEventListener({
    onDeviceConnecting: (response) => {
      if (response.errors && response.errors.length > 0) {
        // Process all `ThryveError`s in `response.errors`
        return;
      }

      // Process `response.data`, for example update the UI
    },
    onDeviceConnected: (response) => {
      if (response.errors && response.errors.length > 0) {
        // Process all `ThryveError`s in `response.errors`
        return;
      }

      // Process `response.data`, for example update the UI
    },
  });

  // ...
}

Disconnect BLE device

To enable users to manually disconnect their BLE device, use disconnectDevice. Handle the disconnection status with the ThryveDeviceEventListener's onDeviceDisconnected callback.

import ThryveCore
import ThryveCommons

class DeviceViewModel: ObservableObject, ThryveDeviceEventListener {

    func disconnect(_ device: ThryveDevice) {
        Task {
            let response = await ThryveSDK.get().disconnectDevice(device)
            guard response.successful else {
                // Process all `[ThryveError]` in `response.errors`
                return
            }

            // Process the disconnection boolean result in `response.data`
        }
    }
    
    // `onDeviceDisconnected` method is a `ThryveDeviceEventListener` event listener callback.
    // It is automatically triggered by ThryveSDK when a `ThryveDevice` is disconnected 
    // via `disconnectDevice`/`forgetDevice` call or on an unexpected drop, in which case
    // `response.errors` carries the reason.
    func onDeviceDisconnected(response: ThryveResponse<ThryveDevice>) {
        guard response.successful else {
        // Process all `[ThryveError]` in `response.errors`
            return 
        }
            
        // Process the `ThryveDevice` that was disconnected. `response.data`
    }
}

import com.thryve.sdk.ThryveSDK
import com.thryve.sdk.ble

...
fun onDeviceDisconnected(activity: ComponentActivity, thryveDevice: ThryveDDevice) {
    val response = suspendCancellableCoroutine { continuation ->
        ThryveSDK.get().disconnectDevice(activity, thryveDevice) { response ->
            continuation.resume(response)
        }
    }
                
    if (!response.successful) {
      // Process all [ThryveErrors] in response.errors
      return 
    }   
             
   //thryveDevice has disconnected. update application UI          
}

//onDeviceDisconnected method is a ThryveDeviceEventListener event listener callback.
//It is automatically triggered by ThryveSDK when a ThryveDevice is disconnected
override fun onDeviceDisconnected(response: ThryveResponse<ThryveDevice>) {
    if (!response.successful) {
       // Process all [ThryveErrors] in response.errors
       return
    } 
    //ThryveDevice is disconnected.process response.data. example update UI
}
...

import { ThryveDevice, useDeviceEventListener } from '@thryve/react-native-sdk';

// `thryve` is the initialised ThryveSDK instance (see initialisation above).

async function disconnect(device: ThryveDevice) {
  const response = await thryve.disconnectDevice(device);
  if (response.errors && response.errors.length > 0) {
    // Process all `ThryveError`s in `response.errors`
    return;
  }

  // Process the disconnection boolean result in `response.data`
}

function DeviceScreen() {
  // Called when a `ThryveDevice` is disconnected.
  useDeviceEventListener({
    onDeviceDisconnected: (response) => {
      if (response.errors && response.errors.length > 0) {
        // Process all `ThryveError`s in `response.errors`
        return;
      }
      // Process the `ThryveDevice` that was disconnected: `response.data`
    },
  });

  // ...
}

Show device connection status

We recommend to transparently display users actively connected devices as well as known, previously connected devices and allow them to re-connect those.

import ThryveCore
import ThryveCommons

class DeviceViewModel: ObservableObject, ThryveDeviceEventListener {

    func getActiveDevices() {
        Task {
            // Optional `sources:` `[.ble]` or `[.garminCompanion]`; omit to query all.
            let response = await ThryveSDK.get().getActiveDevices()
            guard response.successful else {
                // Process all `[ThryveError]` in `response.errors`
                return
            }
    
            // Process the active (connected or connecting) `[ThryveDevice]` in `response.data`
        }
    }
    
    func getPreviousDevices() {
        Task {
            // Optional `sources:` `[.ble]` or `[.garminCompanion]`; omit to query all.
            let response = await ThryveSDK.get().getPreviousDevices()
            guard response.successful else {
                // Process all `[ThryveError]` in `response.errors`
                return
            }

            // Process the previously connected `[ThryveDevice]` in `response.data`
        }
    }
}

import com.thryve.sdk.ThryveSDK
import com.thryve.sdk.ble
...

fun getActiveBLEDevices() {
    val response = suspendCancellableCoroutine { continuation ->
        ThryveSDK.get().getActiveDevices { response ->
            continuation.resume(response)
        }
    }
                
    if (!response.successful) {
      // Process all [ThryveErrors] in response.errors
      return 
    }   
    //Process all active or connected [ThryveDevice] in response.data         
}

fun getPreviousDevices() {
    val response = suspendCancellableCoroutine { continuation ->
        ThryveSDK.get().getPreviousDevices { response ->
            continuation.resume(response)
        }
    }
                
    if (!response.successful) {
      // Process all [ThryveErrors] in response.errors
      return 
    }   
    //Process all previous [ThryveDevice] in response.data         
}

...

Get active devices

import { Source } from '@thryve/react-native-sdk';

// `thryve` is the initialised ThryveSDK instance (see initialisation above).
// Start Garmin first: `await thryve.start(Source.GARMIN_COMPANION, [])`.

async function getActiveDevices() {
  // Optional `sources`: [Source.GARMIN_COMPANION]; omit to query all.
  const response = await thryve.getActiveDevices([Source.GARMIN_COMPANION]);
  if (response.errors && response.errors.length > 0) {
    // Process all `ThryveError`s in `response.errors`
    return;
  }

  // Process the active (connected or connecting) `ThryveDevice`s in `response.data`
}

Get previous devices

import { Source } from '@thryve/react-native-sdk';

// `thryve` is the initialised ThryveSDK instance (see initialisation above).
// Start Garmin first: `await thryve.start(Source.GARMIN_COMPANION, [])`.

async function getPreviousDevices() {
  // Optional `sources`: [Source.GARMIN_COMPANION]; omit to query all.
  const response = await thryve.getPreviousDevices([Source.GARMIN_COMPANION]);
  if (response.errors && response.errors.length > 0) {
    // Process all `ThryveError`s in `response.errors`
    return;
  }

  // Process the previously connected `ThryveDevice`s in `response.data`.
  // These survive app restarts and can be passed straight to `connectDevice`.
}

PreviousApple Health, Health Connect & Samsung Health

NextReal-time bluetooth device data

Last updated 11 days ago

Integrate Thryve BLE with your application

Configure the ThryveBLE and ThryveGarminCompanion modules

Allow users to connect to devices

Start device discovery

Connect to BLE device

Disconnect BLE device

Show device connection status

Configure the `ThryveBLE` and `ThryveGarminCompanion` modules