Connect BLE device to Android an Send Data (nUART)

Question

I'm trying to connect a BLE device (Adafruit Feather M0 Bluefruit LE) to a Android App. The Feather has a Sensor an sends UART texts on special sensor events.

I want to

• connect to the device (static MAC-address)
• connect to the nordic-UART-service
• receive texts from the Feather
• implement surveillance of the connection

Right now I'm trying to understand how BLE works. I understand it as far as to connect to a device but I don't get it after that point.

1. How do I connect to the service or does it connect to the service automatically?
   2. What do I need to get Data or Notifications of incoming data?

This is the code right now. There are now checks, so it will crash when something doesn't happen as planned. But I'm trying to understand the BLE thing. Also it is not a Service, only an Activity. I wasn't able to test it, as the Smartphone delivers no sooner than the end of the week.

package de.example.bluetoothletest;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothGattCallback;
import android.bluetooth.BluetoothGattCharacteristic;
import android.bluetooth.BluetoothManager;
import android.bluetooth.BluetoothProfile;
import android.content.Context;
import android.content.Intent;
import android.support.v4.content.LocalBroadcastManager;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import java.util.UUID;

public class MainActivity extends AppCompatActivity {

private BluetoothAdapter mBluetoothAdapter;
private BluetoothGatt mBluetoothGatt;
private String deviceaddress=("FC:57:1A:B7:22:AD");
public final static String ACTION_DATA_AVAILABLE = "de.example.BluetoothLETest.ACTION_DATA_AVAILABLE";
public static final UUID RX_SERVICE_UUID = UUID.fromString("6e400001-b5a3-f393-e0a9-e50e24dcca9e");
public static final UUID RX_CHAR_UUID = UUID.fromString("6e400002-b5a3-f393-e0a9-e50e24dcca9e");
public static final UUID TX_CHAR_UUID = UUID.fromString("6e400003-b5a3-f393-e0a9-e50e24dcca9e");
public static String EXTRA_DATA="de.example.BluetoothLETest.EXTRA_DATA";


@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);



    //get the BluetoothAdapter
    final BluetoothManager mbluetoothManager=(BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
    mBluetoothAdapter=mbluetoothManager.getAdapter();

}
public void connect(){
    //connect to the given deviceaddress
    BluetoothDevice device=mBluetoothAdapter.getRemoteDevice(deviceaddress);
    mBluetoothGatt=device.connectGatt(this, false, mGattCallback);
    //now we get callbacks on mGattCallback
}

//get callbacks when something changes
private final BluetoothGattCallback mGattCallback=new BluetoothGattCallback() {
    @Override
    public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
        if (newState== BluetoothProfile.STATE_CONNECTED){
            //device connected
        }
    }

    @Override
    public void onServicesDiscovered(BluetoothGatt gatt, int status) {
        if (status==BluetoothGatt.GATT_SUCCESS){
            //all Services have been discovered
        }
    }

    @Override
    public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
        //we are still connected to the service
        if (status==BluetoothGatt.GATT_SUCCESS){
            //send the characteristic to broadcastupdate
            broadcastupdate(ACTION_DATA_AVAILABLE, characteristic);
        }
    }

    @Override
    public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
        //send the characteristic to broadcastupdate
        broadcastupdate(ACTION_DATA_AVAILABLE, characteristic);
    }
};

//Get the 'real' data out of characteristic
private void broadcastupdate(final String action,final BluetoothGattCharacteristic characteristic){
    final Intent intent= new Intent(action);
    //only  when it is the right characteristic?/service?
    if (TX_CHAR_UUID.equals(characteristic.getUuid())){
        //get the 'real' data from the stream
        intent.putExtra(EXTRA_DATA, characteristic.getValue());
        //send the extracted data via LocalBroadcastManager
        LocalBroadcastManager.getInstance(this).sendBroadcast(intent);

    }

}
}

Does this code work an what does the smartphone receive? How do I connect to a specific Service or is it done automatically as the device only offers one service?

Answer 1

change your connected method to this :

if (newState == BluetoothProfile.STATE_CONNECTED) {
                    intentAction = ACTION_GATT_CONNECTED;
                    broadcastUpdate(intentAction);
                    gatt.discoverServices();
                }

and on serviceDiscoverd

@Override
        public void onServicesDiscovered(BluetoothGatt gatt, int status) {
            super.onServicesDiscovered(gatt, status);
            List<BluetoothGattService> services = gatt.getServices();
            gatt.readCharacteristic(services.get(1).getCharacteristics().get(0));
            String uuid;
            List<BluetoothGattCharacteristic> gattCharacteristics;
            ArrayList<BluetoothGattCharacteristic> charas;
            for (BluetoothGattService gattService : services) {
                gattCharacteristics =
                        gattService.getCharacteristics();
                charas = new ArrayList<>();
                for (BluetoothGattCharacteristic gattCharacteristic : gattCharacteristics) {
                    charas.add(gattCharacteristic);
                    uuid = gattCharacteristic.getUuid().toString();
                    if (uuid.equals("0000fff4-0000-1000-8000-00805f9b34fb")) {
                        final int charaProp = gattCharacteristic.getProperties();
                        if ((charaProp | BluetoothGattCharacteristic.PROPERTY_NOTIFY) > 0) {
                            BluetoothGattCharacteristic mNotifyCharacteristic = gattCharacteristic;
                            setCharacteristicNotification(
                                    gattCharacteristic, true);
                        }
                    }
                }
            }
        }

---

public void setCharacteristicNotification(final BluetoothGattCharacteristic characteristic,
                                              boolean enabled) {
        if (mBluetoothAdapter == null || mGatt == null) {
            return;
        }
        mGatt.setCharacteristicNotification(characteristic, enabled);

        Log.e("uuid service", characteristic.getUuid() + "");
        String uuid = "0000fff2-0000-1000-8000-00805f9b34fb";

        if (uuid.equals(characteristic.getUuid().toString())) {
            Log.e("uuid service2", characteristic.getUuid() + "");
            BluetoothGattDescriptor descriptor = characteristic.getDescriptor(
                    UUID.fromString(SampleGattAttributes.CLIENT_CHARACTERISTIC_CONFIG));
            if (descriptor != null) {
                descriptor.setValue(enabled ? BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE : new byte[]{0x00, 0x00});
                mGatt.writeDescriptor(descriptor);
            }
        }
    }

and now finally you card read characteristics :

@Override
        public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
            super.onCharacteristicRead(gatt, characteristic, status);
            updateStatus(characteristic);
            Log.e("gatt", "readChar");
        }

        @Override
        public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
            super.onCharacteristicWrite(gatt, characteristic, status);
            updateStatus(characteristic);
            Log.e("gatt", "writeChar");
        }

        @Override
        public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
            super.onCharacteristicChanged(gatt, characteristic);
            updateStatus(characteristic);
            Log.e("gatt", "changeChar");
        }