Use only native Android API

Oct 13, 2025 by orovajewels.com 139 views

Introduction

In our previous discussion, we identified issues with the connection between the BLE device and the CCA app. To address these issues, we have outlined a plan of action to improve the CCA BLE communication. This plan involves validating the communication between the tablet with the CCA app and the blue sensor, testing the app for a couple of weeks, integrating the test data into the CCA app, and further exploring the use of an existing app to check advertisement packets for temperature data collection.

1. Validate

The first step in improving the CCA BLE communication is to validate that a robust communication between a tablet with the CCA app and the blue sensor can be achieved. This should be done in isolation to the code we currently have, and without reliance on external packages, purely using native Java Android API.

Requirements for Validation in Isolation

Use only native Android API: We should use only the native Android API to communicate with the BLE device, without relying on external packages that abstract the API.
Run in background as a service: The app should run in the background as a service, including when the tablet screen turns off.
Support multiple sensors: The app should be able to support multiple sensors, even if it's just hard-coding an array of MAC addresses.
Capture advertisement packets: The app should capture advertisement packets for sensors on a schedule, ideally capturing all advertisements for all sensors connected to the device. However, we may need to use a device address filter, which is okay to do one sensor at a time.
Log data to a file: All data communication should be logged to a file for future testing.

Example Code

Here's an example of how we can use the native Android API to communicate with the BLE device:

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothGattCharacteristic;
import android.bluetooth.BluetoothManager;
import android.content.Context;
import android.os.Bundle;
import android.util.Log;

public class BleService extends Service {
    private static final String TAG = "BleService";
    private BluetoothAdapter bluetoothAdapter;
    private BluetoothGatt bluetoothGatt;

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // Initialize the Bluetooth adapter
        BluetoothManager bluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
        bluetoothAdapter = bluetoothManager.getAdapter();

        // Connect to the BLE device
        BluetoothDevice device = bluetoothAdapter.getRemoteDevice("MAC_ADDRESS");
        bluetoothGatt = device.connectGatt(this, false, gattCallback);

        return super.onStartCommand(intent, flags, startId);
    }

    private BluetoothGattCallback gattCallback = new BluetoothGattCallback() {
        @Override
        public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
            super.onConnectionStateChange(gatt, status, newState);
            if (newState == BluetoothGatt.STATE_CONNECTED) {
                Log.d(TAG, "Connected to BLE device");
                gatt.discoverServices();
            } else if (newState == BluetoothGatt.STATE_DISCONNECTED) {
                Log.d(TAG, "Disconnected from BLE device");
            }
        }

        @Override
        public void onServicesDiscovered(BluetoothGatt gatt, int status) {
            super.onServicesDiscovered(gatt, status);
            Log.d(TAG, "Services discovered");
            BluetoothGattService service = gatt.getService(UUID.fromString("UUID"));
            BluetoothGattCharacteristic characteristic = service.getCharacteristic(UUID.fromString("UUID"));
            gatt.readCharacteristic(characteristic);
        }

        @Override
        public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
            super.onCharacteristicRead(gatt, characteristic, status);
            Log.d(TAG, "Characteristic read");
            byte[] value = characteristic.getValue();
            // Process the data
        }
    };
}

2. Test

Once we have validated the communication between the tablet with the CCA app and the blue sensor, we should test the app for a couple of weeks with the following scenarios:

No spikes or data anomalies: We should ensure that there are no spikes or data anomalies in the data collected by the app.
Range comparisons against current CCA: We should compare the data collected by the app with the current CCA data to ensure that they are consistent.
Sensors out of range for a few days and then bringing them in range: We should test the app by taking sensors out of range for a few days and then bringing them in range to ensure that the app can handle this scenario.

3. Integrated

If the results of the validation and testing are positive, we can use the test data to create new integration logic in the CCA app. This integration logic should be done within the Java layer, and it might need to be done if part of the app that is running as a service does not have access to the React Native code and if it can access the SQLite database.

4. Further Thoughts

There is another app that @jmbrunskill did to check advertisement packets for temperature data collection: https://github.com/jmbrunskill/bm-bluetooth-test/commit/dbce39546e1df06284bb3eac2c4c25439c4d9654. We would like to see the connection tests done in isolation, without dependencies and using the Android API directly, not sure if we can use that app at this moment.

Introduction

In our previous article, we outlined a plan of action to improve the CCA BLE communication. This plan involves validating the communication between the tablet with the CCA app and the blue sensor, testing the app for a couple of weeks, integrating the test data into the CCA app, and further exploring the use of an existing app to check advertisement packets for temperature data collection. In this article, we will answer some frequently asked questions related to the plan of action.

Q: What is the purpose of validating the communication between the tablet with the CCA app and the blue sensor?

A: The purpose of validating the communication between the tablet with the CCA app and the blue sensor is to ensure that a robust communication can be achieved. This involves using only native Android API, running in the background as a service, supporting multiple sensors, capturing advertisement packets, and logging data to a file.

Q: Why do we need to use only native Android API?

A: We need to use only native Android API because it provides a direct and efficient way to communicate with the BLE device. Using external packages that abstract the API can introduce additional complexity and potential issues.

Q: What is the benefit of running the app in the background as a service?

A: The benefit of running the app in the background as a service is that it allows the app to continue running even when the tablet screen is turned off. This is particularly useful for applications that require continuous data collection.

Q: How do we capture advertisement packets for sensors?

A: We capture advertisement packets for sensors by using the BluetoothGattCharacteristic.read() method. This method allows us to read the characteristic value of the sensor, which contains the advertisement packet.

Q: What is the purpose of logging data to a file?

A: The purpose of logging data to a file is to provide a record of the data collected by the app. This can be useful for debugging purposes, as well as for analyzing the data collected by the app.

Q: How do we test the app for a couple of weeks?

A: We test the app for a couple of weeks by running it on a tablet with the CCA app and the blue sensor. We then monitor the app's behavior and collect data for a couple of weeks to ensure that it is working correctly.

Q: What scenarios do we test the app with?

A: We test the app with the following scenarios:

No spikes or data anomalies: We ensure that there are no spikes or data anomalies in the data collected by the app.
Range comparisons against current CCA: We compare the data collected by the app with the current CCA data to ensure that they are consistent.
Sensors out of range for a few days and then bringing them in range: We test the app by taking sensors out of range for a few days and then bringing them in range to ensure that the app can handle this scenario.

Q: How do we integrate the test data into the CCA app?

A: We integrate the test data into the CCA app by using the test data to create new integration logic in the CCA app. This integration logic should be done within the Java layer, and it might need to be done if part of the app that is running as a service does not have access to the React Native code and if it can access the SQLite database.

Q: What is the benefit of emulating the Bluetooth devices for testing?

A: The benefit of emulating the Bluetooth devices for testing is that it allows us to test the app's behavior without having to physically connect the Bluetooth devices. This can be particularly useful for testing the app's behavior in different scenarios.

Conclusion

In this article, we have answered some frequently asked questions related to the plan of action to improve the CCA BLE communication. We have discussed the purpose of validating the communication between the tablet with the CCA app and the blue sensor, the benefit of running the app in the background as a service, and the purpose of logging data to a file. We have also discussed the scenarios that we test the app with, and the benefit of emulating the Bluetooth devices for testing.