* Requires {@link android.Manifest.permission#BLUETOOTH} permission.
*
* @return State of the profile connection. One of
* {@link BluetoothProfile#STATE_CONNECTED},
* {@link BluetoothProfile#STATE_CONNECTING},
* {@link BluetoothProfile#STATE_DISCONNECTED},
* {@link BluetoothProfile#STATE_DISCONNECTING}
*/
public int getConnectionState()
{
if(mBluetoothManager == null){
mBluetoothManager = (BluetoothManager) mActivity
.getSystemService(Context.BLUETOOTH_SERVICE);
}
return mBluetoothManager.getConnectionState(device,
BluetoothProfile.GATT);
}
/**
* reads from the RX buffer content based on the
* MAX_DATA_TO_READ_FROM_BUFFER and sends it to the remote device
*/
protected boolean uploadNextDataFromFifoToRemoteDevice()
{
if (gatt == null
|| getConnectionState() == BluetoothProfile.STATE_DISCONNECTED)
{
return false;
}
if (mTxBuffer.read(mTxDest, MAX_DATA_TO_READ_FROM_BUFFER) != 0)
{
byte[] dataToWriteToRemoteBleDevice = mTxDest.toArray();
mTxDest.delete(0, MAX_DATA_TO_READ_FROM_BUFFER);
return sendToModule(dataToWriteToRemoteBleDevice);
}
else
{
onUploaded();
}
return true;
}
/**
* writes the string data passed to the TX buffer and then sends the data to
* the remote device
*
* @param data
* the data to write to the TX buffer and to send to the remote
* device
*/
protected boolean writeToFifoAndUploadDataToRemoteDevice(byte[] data)
{
mTxBuffer.write(data);
return uploadNextDataFromFifoToRemoteDevice();
};
/**
*
* @param dataToBeSend string of data to send
* @return true, if the write operation was initiated successfully
*/
protected boolean sendToModule(byte[] dataToBeSend)
{
if (gatt != null && mCharRx != null && dataToBeSend != null)
{
Log.i(TAG, "char data Just send 1: "+ Arrays.toString(dataToBeSend));
mCharRx.setValue(dataToBeSend);
System.out.println("char data Just send 2:"
+ Arrays.toString(mCharRx.getValue()));
return gatt.writeCharacteristic(mCharRx);
}
return false;
}
@Override
public void onConnectionStateChange(BluetoothGatt gatt, int status,
int newState)
{
super.onConnectionStateChange(gatt, status, newState);
if (status == BluetoothGatt.GATT_SUCCESS)
{
switch (newState)
{
case BluetoothProfile.STATE_CONNECTING:
break;
case BluetoothProfile.STATE_CONNECTED:
mFifoAndVspManagerState = FifoAndVspManagerState.WAITING;
break;
case BluetoothProfile.STATE_DISCONNECTING:
break;
case BluetoothProfile.STATE_DISCONNECTED:
mFifoAndVspManagerState = FifoAndVspManagerState.WAITING;
setToDefault();
flushBuffers();
break;
}
}
else
{
mFifoAndVspManagerState = FifoAndVspManagerState.WAITING;
setToDefault();
flushBuffers();
}
}
@Override
public void onCharacteristicWrite(BluetoothGatt gatt,
BluetoothGattCharacteristic characteristic, int status)
{
super.onCharacteristicWrite(gatt, characteristic, status);
UUID serviceUUID = characteristic.getService().getUuid();
UUID charUUID = characteristic.getUuid();
switch (status)
{
case BluetoothGatt.GATT_SUCCESS:
if (VSP_SERVICE.equals(serviceUUID))
{
if (VSP_CHAR_RX.equals(charUUID))
{
Log.i(TAG, "Data was sent successfully");
// keep count of total bytes send to the remote BLE device
mTxCounter = mTxCounter + characteristic.getValue().length;
onVspSendDataSuccess(gatt, characteristic);
}
}
break;
}
}
@Override
public void onCharacteristicChanged(BluetoothGatt gatt,
BluetoothGattCharacteristic ch)
{
UUID serviceUUID = ch.getService().getUuid();
UUID charUUID = ch.getUuid();
if (VSP_SERVICE.equals(serviceUUID))
{
if (VSP_CHAR_TX.equals(charUUID))
{
Log.i(TAG, "Data was received successfully");
// keep count of total bytes received from the remote BLE device
mRxCounter = mRxCounter + ch.getValue().length;
onVspReceiveData(gatt, ch);
}
else if (VSP_CHAR_MODEM_OUT.equals(charUUID))
{
/*
* getting the buffer space state and then we use it to identify
* if there is space in the remote device or not.
*
* when the buffer old state is 0 and the buffer new state is 1
* then it means that there was a transition from the remote
* device not able to receive data to able to receive data.
*/
boolean isBufferSpaceAvailableOldState = mIsBufferSpaceAvailableNewState;
int isBufferSpaceAvailableNewState = ch.getIntValue(
BluetoothGattCharacteristic.FORMAT_UINT8, 0);
if (isBufferSpaceAvailableNewState == 1)
{
mIsBufferSpaceAvailableNewState = true;
}
else
{
mIsBufferSpaceAvailableNewState = false;
}
Log.i(TAG, "Was the buffer full previously: "
+ isBufferSpaceAvailableOldState);
Log.i(TAG, "Is the buffer full now: "
+ isBufferSpaceAvailableNewState);
onVspIsBufferSpaceAvailable(isBufferSpaceAvailableOldState,
mIsBufferSpaceAvailableNewState);
}
}
}
@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
super.onServicesDiscovered(gatt, status);
findServicesAndCharacteristics();
}
/**
* Finds all the services and characteristics that the remote BLE device
* has. The
* {@link VSPBytePeripheral#onServiceFound(BluetoothGattService)} method
* is called whenever a service is found and the
* {@link VSPBytePeripheral#onCharFound(BluetoothGattCharacteristic)}
* method is called whenever a characteristic is found. Finally the
* {@link VSPBytePeripheral#onCharsFoundCompleted()}
*/
protected void findServicesAndCharacteristics()
{
if (gatt == null)
{
Log.w(TAG, "gatt is null");
return;
}
List Note: if the characteristic supports Notifications and
* Indications then automatically only Notifications will be enabled and
* Indications will be ignored.
If we need to define what to enable then
* one way would be to create separate methods called
* "setCharacteristicNotification" and "setCharacteristicIndication"
*/
protected boolean setCharacteristicNotificationOrIndication(
BluetoothGattCharacteristic characteristic, boolean enable)
{
if (gatt == null)
throw new NullPointerException("gatt object is null!");
boolean isSettingNotificationLocalySuccess = gatt
.setCharacteristicNotification(characteristic, enable);
if (isSettingNotificationLocalySuccess)
{
return writeDescriptorForNotificationOrIndication(characteristic,
enable);
}
else
{
return false;
}
}
/**
* write the Client Characteristic Configuration Descriptor (CCCD) for
* enabling/disabling notifications/indications to a specific
* characteristic.
*
* @param ch
* the characteristic to write the CCCD descriptor to
* @param enabled
* false to disable notifications/indications, true to enable
* them
* @return boolean false if CCCD descriptor was not found or if the
* operation was not initiated successful, otherwise returns true
*/
private boolean writeDescriptorForNotificationOrIndication(
BluetoothGattCharacteristic ch, boolean enabled)
{
// see:
// https://developer.bluetooth.org/gatt/descriptors/Pages/DescriptorViewer.aspx?u=org.bluetooth.descriptor.gatt.client_characteristic_configuration.xml
BluetoothGattDescriptor descriptor = ch
.getDescriptor(DefinedBleUUIDs.Descriptor.CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR);
if (descriptor == null)
return false;
int properties = ch.getProperties();
if ((BluetoothGattCharacteristic.PROPERTY_NOTIFY & properties) != 0)
{
// set notifications, heart rate measurement etc
byte[] val = enabled ? BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE
: BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE;
boolean descrSuccess = descriptor.setValue(val);
Log.i(TAG, "NOTIFY: " + descrSuccess);
}
else if ((BluetoothGattCharacteristic.PROPERTY_INDICATE & properties) != 0)
{
// set notifications, temperature measurement etc
byte[] val = enabled ? BluetoothGattDescriptor.ENABLE_INDICATION_VALUE
: BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE;
boolean descrSuccess = descriptor.setValue(val);
Log.i(TAG, "INDICATE: " + descrSuccess);
}
boolean success = gatt.writeDescriptor(descriptor);
Log.i(TAG, "writeDescriptor success: " + success);
return success;
}
protected void onCharacteristicsQueueCompleted()
{
Log.i(TAG, "QUEUE COMPLETED");
enableModemIn();
}
/**
* Callback that gets called whenever a service is found
*
* @param service
*/
protected void onServiceFound(final BluetoothGattService service)
{
if (VSP_SERVICE.equals(service.getUuid()))
{
mIsValidVspDevice = true;
}
}
/**
* adds the given characteristic to the characteristics queue. Call the
* {@link VSPBytePeripheral#executeCharacteristicsQueue()} method to
* execute the characteristics operation. Currently only read and
* notification/indication operations are supported.
*
* @param characteristic
* the characteristic to add to the queue
*/
protected void addCharToQueue(BluetoothGattCharacteristic characteristic)
{
mCharQueue.add(characteristic);
}
protected void onCharFound(final BluetoothGattCharacteristic characteristic)
{
if (VSP_CHAR_RX.equals(characteristic.getUuid()))
{
mCharRx = characteristic;
}
else if (VSP_CHAR_TX.equals(characteristic.getUuid()))
{
// add to queue as we want to enable notifications
addCharToQueue(characteristic);
}
else if (VSP_CHAR_MODEM_IN.equals(characteristic.getUuid()))
{
mCharModemIn = characteristic;
}
else if (VSP_CHAR_MODEM_OUT.equals(characteristic.getUuid()))
{
// add to queue as we want to enable notifications
addCharToQueue(characteristic);
}
}
/**
* for notifying the remote device that we can't send anymore data
*/
public void enableModemIn()
{
if (mCharModemIn != null)
{
byte[] enable =
{
(byte) 1
};
mCharModemIn.setValue(enable);
gatt.writeCharacteristic(mCharModemIn);
}
}
/**
* Clears all values
*/
private void setToDefault()
{
mIsValidVspDevice = false;
mCharTx = null;
mCharRx = null;
mCharModemOut = null;
mCharModemIn = null;
}
/**
* clears the RX buffer and the TX buffer
*/
protected void flushBuffers()
{
mRxBuffer.flush();
mTxBuffer.flush();
}
/**
* override this method to define what data to sent to the remote BLE device
*/
protected void uploadNextData()
{}
protected void onUploaded()
{
mFifoAndVspManagerState = FifoAndVspManagerState.UPLOADED;
flushBuffers();
}
/**
* used when sending data fails because of a response error from the remote
* device and not because of a disconnection issue. For example if the
* memory of the module has become full it will give a response error that
* it cannot store any more data
*/
protected void onUploadFailed(final String errorCode)
{
mFifoAndVspManagerState = FifoAndVspManagerState.FAILED;
flushBuffers();
}
/**
* callback for notifying if the VSP service was found
*
* @param found
* true if VSP service was found, otherwise false
*/
protected void onVspServiceFound(final boolean found)
{}
/**
* Callback for whenever data was send to the remote device successful
*
* @param gatt
* GATT client
* @param ch
* the RX characteristic with the updated value
*/
public void onVspSendDataSuccess(final BluetoothGatt gatt,
final BluetoothGattCharacteristic ch)
{
sendDataHandler.postDelayed(new Runnable()
{
@Override
public void run()
{
switch (mFifoAndVspManagerState)
{
case UPLOADING:
/*
* what to do after the data was send successfully
*/
if (isBufferSpaceAvailable() == true)
{
uploadNextData();
}
break;
default:
break;
}
}
}, SEND_DATA_TO_REMOTE_DEVICE_DELAY);
}
/**
* Callback for whenever data failed to be send to the remote device
*
* @param gatt GATT client
* @param ch the RX characteristic with the updated value
* @param status error of the failure
*/
public void onVspSendDataFailure(final BluetoothGatt gatt,
final BluetoothGattCharacteristic ch, final int status)
{}
/**
* Callback for when data is received from the remote device
*
* @param gatt GATT client
* @param ch the TX characteristic with the updated value
*/
public void onVspReceiveData(final BluetoothGatt gatt,
final BluetoothGattCharacteristic ch)
{
mRxBuffer.write(ch.getValue());
while (mRxBuffer.read(mRxDest) != 0)
{
/*
* found data
*/
byte[] rxBufferDataRead = mRxDest.toArray();
mRxDest.delete(0, mRxDest.length());
// mSerialManagerUiCallback.onUiReceiveData(rxBufferDataRead);
Log.i(TAG, "Message Recieved: "+ Arrays.toString(rxBufferDataRead));
PluginResult result = new PluginResult(PluginResult.Status.OK, rxBufferDataRead);
result.setKeepCallback(true);
callback.sendPluginResult(result);
}
}
/**
* Callback that notifies the android device if the remote device can
* currently accept data or not
*
* if the new state is false it means it cannot receive any more data as its
* buffer is full, when true it can receive data
*
* @param isBufferSpaceAvailableOldState
* the old state of the buffer
* @param isBufferSpaceAvailableNewState
* the new state of the buffer
*/
public void onVspIsBufferSpaceAvailable(
final boolean isBufferSpaceAvailableOldState,
final boolean isBufferSpaceAvailableNewState)
{
switch (mFifoAndVspManagerState)
{
case UPLOADING:
/*
* callback for what to do when data was send successfully from the
* android device and when the module buffer was full and now it has
* been cleared, which means it now has available space
*/
if (isBufferSpaceAvailableOldState == false
&& isBufferSpaceAvailableNewState == true)
{
uploadNextData();
}
break;
default:
break;
}
}
}