Direct bluetooth device connection

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

With Thryve, you can connect blood glucose monitors and heart rate monitors directly via Bluetooth Low Energy (BLE). The ThryveBLE 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 Heart Rate Monitors

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)

Integrate Thryve BLE with your application

To be able to integrate ThryveBLE module you need to:

iOS

1. Integrate the ThryveBLE module Make sure to also add ThryveCore and ThryveCommons modules. Follow either the cocoapods or framework files instructions in the iOS section.

2. Add Bluetooth Capability In Xcode: Navigate to Target → Signing & Capabilities → add (+) → Bluetooth.

   

3. Add Privacy - Bluetooth Always Usage Description to Info.plist <key>NSBluetoothAlwaysUsageDescription</key>

   <string>Bluetooth permission for Thryve</string>

Android

Configure the ThryveBLE module

When initializing Thryve SDK make sure to define the deviceTypes and an optional ThryveBLEEventListener in the ThryveBLEConfig .

iOS

import ThryveCore
import ThryveCommons
import ThryveObservability
import ThryveBLE

let bleConfig = ThryveBLEConfig(
    //set the BLE device types. It defaults to all ThryveBLEDeviceTypes
    deviceTypes: Set<ThryveBLEDeviceType> = Set(ThryveBLEDeviceType.allCases),
    eventsListener: self // Optional: Receives callbacks for device found/connected/disconnected/data `ThryveBLEEventListener` protocol and implements `onDeviceFound(response: ThryveResponse<ThryveBLEDevice>)`, `onDeviceConnecting(response: ThryveResponse<ThryveBLEDevice>)`, `onDeviceConnected(response: ThryveResponse<ThryveBLEDevice>)`, onDeviceDisconnected(response: ThryveResponse<ThryveBLEDevice>) and, `onHeartRateDataReceived(device: ThryveBLEDevice, response: ThryveResponse<ThryveBLEHeartRateMeasurement>)` functions
)

let thryveSDKConfig = ThryveSDKConfig(
    authId: "AUTH_ID",
    authSecret: "AUTH_SECRET",
    endUserAlias: "YOUR_UNIQUE_USER_IDENTIFIER",
    endUserId: nil, 
    locale: "de",
    configs: [bleConfig],
    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")")
    }
} 

Android

Parameter	Description	Mandatory
deviceTypes	Limits the BLE device types the host application supports (e.g. heart rate monitor). Only devices matching the ThryveBLEDeviceType will appear in discovery.	no
eventsListener	An object of ThryveBLEEventListener that will have to implement the following functions to receive events from the ThryveBLE module. onDeviceFound(response: ThryveResponse<ThryveBLEDevice>) onDeviceConnecting(response: ThryveResponse<ThryveBLEDevice>) onDeviceConnected(response: ThryveResponse<ThryveBLEDevice>) onDeviceDisconnected(response: ThryveResponse<ThryveBLEDevice>) onHeartRateDataReceived(device: ThryveBLEDevice, response: ThryveResponse<ThryveBLEHeartRateMeasurement>)	no

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 ThryveBLEEventListener. 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.

iOS

import ThryveCore
import ThryveCommons
import ThryveBLE

class BLEViewModel: ObservableObject, ThryveBLEEventListener {
---
    func startScan() {
        Task { @MainActor in
               let response = await ThryveSDK.get().startDeviceDiscovery()
                guard response.successful else {
                  // Process all [ThryveErrors] in response.errors
                  return 
                }
                
                //returns a list of ThryveBLEDevice found
                let listOfThryveBLEDevices = response.data  
          }
    }
    
    //onDeviceFound method is a ThryveBLEEventListener event listener callback.
    //It is automatically triggered by ThryveSDK each time a ThryveBLEDevice is found 
    //during the scanning session in ThryveSDK.get().startDeviceDiscovery()
    func onDeviceFound(response: ThryveResponse<ThryveBLEDevice>) {
            Task { @MainActor in
                guard let bleDevice = response.data else {
                    // Process all [ThryveErrors] in response.errors
                    return
                }
                //process the ThryveBLEDevice found in the startDeviceDiscovery process
                //example update UI with the bleDevice object 
            }
    }
    
    //Call stopDeviceDiscovery to stop the BLE discovery or scanning process
    func stopScan() {
      Task { @MainActor in
          let response = await ThryveSDK.get().stopDeviceDiscovery()
        }
    }
---
}

Android

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 ThryveBLEEventListener interface, using the onDeviceConnecting and onDeviceConnected callback methods for processing connection events effectively.

Pairing process with Roche ACCU-CHEK Guide

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 5 minutes, as long as the connection remains active.

iOS

import ThryveCore
import ThryveCommons
import ThryveBLE

class BLEViewModel: ObservableObject, ThryveBLEEventListener {
---
    func connectDevice() {
        Task { @MainActor in
               let response: ThryveResponse<Bool> = await ThryveSDK.get().connectDevice(device.id)
                guard response.successful else {
                  // Process all [ThryveErrors] in response.errors
                  return 
                }
                
                //process the connection status in the response object 
          }
    }
    
    //onDeviceConnecting method is a ThryveBLEEventListener event listener callback.
    //It is automatically triggered by ThryveSDK each time a ThryveBLEDevice is connecting 
    //during the execution of ThryveSDK.get().connectDevice
    func onDeviceConnecting(response: ThryveResponse<ThryveBLEDevice>) {
            guard response.successful else {
                  // Process all [ThryveErrors] in response.errors
                  return 
                }
                
                //process response.data. example update UI
    }
    
    //onDeviceConnected method is a ThryveBLEEventListener event listener callback.
    //It is automatically triggered by ThryveSDK each time a ThryveBLEDevice is connected 
    //during the execution of ThryveSDK.get().connectDevice
    //Data is automatically uploaded when a BLE device is connected.
    func onDeviceConnected(response: ThryveResponse<ThryveBLEDevice>) {
            guard response.successful else {
                  // Process all [ThryveErrors] in response.errors
                  return 
                }
                
                //process response.data. example update UI
    }
---
}

Android

Disconnect BLE device

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

iOS

import ThryveCore
import ThryveCommons
import ThryveBLE

class BLEViewModel: ObservableObject, ThryveBLEEventListener {
---
    func disconnectDevice(device: ThryveBLEDevice) {
        Task { @MainActor in
               let response = await ThryveSDK.get().disconnectDevice(device.id)
                guard response.successful else {
                  // Process all [ThryveErrors] in response.errors
                  return 
                }
                
                //process the disconnection boolean result in response.data
          }
    }
    
    //onDeviceDisconnected method is a ThryveBLEEventListener event listener callback.
    //It is automatically triggered by ThryveSDK when a ThryveBLEDevice is disconnected 
    func onDeviceDisconnected(response: ThryveResponse<ThryveBLEDevice>) {
            Task { @MainActor in
                guard response.successful else {
                  // Process all [ThryveErrors] in response.errors
                  return 
                }
                //process the ThryveBLEDevice that was disconnected. response.data
            }
    }
---
}

Android

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.

iOS

import ThryveCore
import ThryveCommons
import ThryveBLE

class BLEViewModel: ObservableObject, ThryveBLEEventListener {
---
    func getActiveBLEDevices() {
        Task { @MainActor in
               let activedDevices = await ThryveSDK.get().getActiveDevices() 
                //Process all active or connected [ThryveBLEDevice] in activeDevices
          }
    }
    
    func getPreviousBLEDevices() {
        Task { @MainActor in
               let previousDevices = await ThryveSDK.get().getPreviousDevices()
                //Process all previous [ThryveBLEDevice] in previousDevices
          }
    }
---
}

Android