public async Task <bool> WriteAsync(IGattCharacteristic characteristic, byte[] data)
{
lock (_lock)
{
if (_bluetoothGatt == null || State != BluetoothLEDeviceState.Connected)
{
return(false);
}
var gattCharacteristic = ((GattCharacteristic)characteristic).BluetoothGattCharacteristic;
gattCharacteristic.WriteType = GattWriteType.Default;
if (!gattCharacteristic.SetValue(data))
{
return(false);
}
_writeCompletionSource = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
if (!_bluetoothGatt.WriteCharacteristic(gattCharacteristic))
{
_writeCompletionSource = null;
return(false);
}
}
var result = await _writeCompletionSource.Task;
_writeCompletionSource = null;
return(result);
}
public virtual void WriteTXCharacteristic(byte[] value)
{
BluetoothGattCharacteristic rxChar;
var rxService = Gatt.GetService(RX_SERVICE_UUID2);
if (rxService == null)
{
ShowMessage("mBluetoothGatt null" + Gatt);
ShowMessage("Tx service not found!");
BroadcastUpdate(DEVICE_DOES_NOT_SUPPORT_UART);
return;
}
rxChar = rxService.GetCharacteristic(RX_CHAR_UUID2);
if (rxChar == null)
{
ShowMessage("Tx charateristic not found!");
BroadcastUpdate(DEVICE_DOES_NOT_SUPPORT_UART);
return;
}
Debug.WriteLine(TAG, "TxChar = " + RX_CHAR_UUID2.ToString());
rxChar.SetValue(value);
bool status = Gatt.WriteCharacteristic(rxChar);
Debug.WriteLine(TAG, "write TXchar - status=" + status);
}
public void ConfigureGyroscopePeriod()
{
var accelerometerPeriod = BluetoothGatt.GetService(BluetoothSensorAttributes.GyroscopeService).GetCharacteristic(BluetoothSensorAttributes.GyroscopePeriod);
accelerometerPeriod.SetValue(new byte[] { 10 });
BluetoothGatt.WriteCharacteristic(accelerometerPeriod);
}
private bool InternalWrite(byte[] data)
{
_nativeCharacteristic.SetValue(data);
Trace.Message("Write {0}", Id);
return(_gatt.WriteCharacteristic(_nativeCharacteristic));
}
/// <summary>
/// Write byte data to the Bluetooth device.
/// </summary>
/// <param name="data">The array of bytes to write.</param>
/// <returns>True if the write succeeded.</returns>
public bool Write(params byte[] data)
{
if (State != BlueState.Connected)
{
return(false);
}
if (_TX == null)
{
Debug.WriteLineIf(sw.TraceError, $"--> Write no TX characteristic");
return(false);
}
bool res = _TX.SetValue(data);
if (!res)
{
Debug.WriteLineIf(sw.TraceVerbose, "--> TX SetValue failed");
return(false);
}
else
{
res = _gatt.WriteCharacteristic(_TX);
if (!res)
{
Debug.WriteLineIf(sw.TraceVerbose, "--> TX WriteCharacteristic failed");
return(false);
}
}
return(true);
}
/// <summary>
/// Write the specified data to the characteristic
/// </summary>
/// <param name="data">Data.</param>
public void Write(byte[] data, CharacteristicWriteType writeType)
{
if (!CanWrite)
{
throw new InvalidOperationException("Characteristic does not support WRITE");
}
_nativeCharacteristic.SetValue(data);
if (writeType == CharacteristicWriteType.WithResponse)
{
_nativeCharacteristic.WriteType = GattWriteType.Default;
}
else if (writeType == CharacteristicWriteType.WithoutResponse)
{
_nativeCharacteristic.WriteType = GattWriteType.NoResponse;
}
var success = _gatt.WriteCharacteristic(_nativeCharacteristic);
if (!success)
{
WriteComplete?.Invoke(this, new CharacteristicWriteEventArgs(false, this));
//throw new CharacteristicException("Write failed", CharacteristicException.Code.WriteFailed);
}
}
bool write(byte[] data)
{
if (!CanWrite)
{
throw new InvalidOperationException("Characteristic does not support WRITE");
}
if (_gattCallback != null)
{
_gattCallback.CharacteristicValueWritten += OnCharacteristicValueWritten;
}
var c = _nativeCharacteristic;
c.SetValue(data);
Mvx.Trace(".....Write {0}", ID);
//_gatt.WriteCharacteristic(c);
var ret = _gatt.WriteCharacteristic(c);
if (!ret)
{
_gattCallback.CharacteristicValueWritten -= OnCharacteristicValueWritten;
}
return(ret);
}
public void ConfigureAccelerometer(BluetoothGatt gatt)
{
ConfigurationStep = ConfigurationStep.AccelerometerConfigured;
var accelerometer = gatt.GetService(BluetoothSensorAttributes.AccelerometerService).GetCharacteristic(BluetoothSensorAttributes.AccelerometerConfiguration);
accelerometer.SetValue(new byte[] { 1 });
gatt.WriteCharacteristic(accelerometer);
}
public void ConfigureGyroscope(BluetoothGatt gatt)
{
ConfigurationStep = ConfigurationStep.GyroscopeConfigured;
var gyroscope = gatt.GetService(BluetoothSensorAttributes.GyroscopeService)?.GetCharacteristic(BluetoothSensorAttributes.GyroscopeConfiguration);
gyroscope.SetValue(new byte[] { 7 });
gatt.WriteCharacteristic(gyroscope);
}
public void Write(byte[] data)
{
if (!CanWrite)
{
throw new InvalidOperationException("Characteristic does not support WRITE");
}
_nativeCharacteristic.WriteType = GattWriteType.Default;
_nativeCharacteristic.SetValue(data);
if (!_gatt.WriteCharacteristic(_nativeCharacteristic))
{
Thread.Sleep(100);
if (!_gatt.WriteCharacteristic(_nativeCharacteristic))
{
Thread.Sleep(100);
_gatt.WriteCharacteristic(_nativeCharacteristic);
}
}
}
public async Task <bool> WriteAsync(IGattCharacteristic characteristic, byte[] data, CancellationToken token)
{
using (token.Register(() =>
{
lock (_lock)
{
_writeCompletionSource?.TrySetResult(false);
}
}))
{
lock (_lock)
{
if (_bluetoothGatt == null || State != BluetoothLEDeviceState.Connected)
{
return(false);
}
var nativeCharacteristic = ((GattCharacteristic)characteristic).BluetoothGattCharacteristic;
nativeCharacteristic.WriteType = GattWriteType.Default;
if (!nativeCharacteristic.SetValue(data))
{
return(false);
}
_writeCompletionSource = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
if (!_bluetoothGatt.WriteCharacteristic(nativeCharacteristic))
{
_writeCompletionSource = null;
return(false);
}
}
var result = await _writeCompletionSource.Task.ConfigureAwait(false);
lock (_lock)
{
_writeCompletionSource = null;
return(result);
}
}
}
private void PlatformWrite(byte[] data)
{
if (!_characteristic.SetValue(data))
{
RaiseWriteFailed(BLEErrorCode.InternalError);
return;
}
if (!_gatt.WriteCharacteristic(_characteristic))
{
RaiseWriteFailed(BLEErrorCode.InternalError);
}
}
/// <summary>
/// Write the specified data to the characteristic
/// </summary>
/// <param name="data">Data.</param>
public void Write(byte[] data)
{
if (!CanWrite)
{
throw new InvalidOperationException("Characteristic does not support WRITE");
}
_nativeCharacteristic.SetValue(data);
_nativeCharacteristic.WriteType = GattWriteType.NoResponse;
_gatt.WriteCharacteristic(_nativeCharacteristic);
}
public void ConfigureAccelerometerPeriod(BluetoothGatt gatt)
{
ConfigurationStep = ConfigurationStep.AccelerometerPeriod;
var accelerometerPeriod = gatt.GetService(BluetoothSensorAttributes.AccelerometerService).GetCharacteristic(BluetoothSensorAttributes.AccelerometerPeriod);
if (accelerometerPeriod.GetValue() != null)
{
return;
}
accelerometerPeriod.SetValue(new byte[] { AccelerometerPeriod });
gatt.WriteCharacteristic(accelerometerPeriod);
}
// HACK: UNTESTED - this API has only been tested on iOS
public void Write(byte[] data)
{
if (!CanWrite)
{
throw new InvalidOperationException("Characteristic does not support WRITE");
}
var c = _nativeCharacteristic;
c.SetValue(data);
_gatt.WriteCharacteristic(c);
Console.WriteLine(@".....Write");
}
private void WriteTimeSync_ex(BluetoothGatt gatt)
{
try {
if (gatt == null || _customTimeCharacteristic == null)
{
return;
}
SetCustomData_MC(_customTimeCharacteristic);
gatt.WriteCharacteristic(_customTimeCharacteristic);
} catch (Exception e) {
Log.Error("Error", e.Message);
}
}
public void ConfigureGyroscopePeriod(BluetoothGatt gatt)
{
ConfigurationStep = ConfigurationStep.GyroscopePeriod;
var gyroscopePeriod = gatt.GetService(BluetoothSensorAttributes.GyroscopeService).GetCharacteristic(BluetoothSensorAttributes.GyroscopePeriod);
if (gyroscopePeriod.GetValue() != null)
{
return;
}
gyroscopePeriod.SetValue(new byte[] { GyroscopePeriod });
gatt.WriteCharacteristic(gyroscopePeriod);
}
private void GetCustomTimeSync(BluetoothGatt gatt)
{
try {
if (gatt == null || _customTimeCharacteristic == null)
{
return;
}
SetCustomTimeSync(_customTimeCharacteristic, new GregorianCalendar());
gatt.WriteCharacteristic(_customTimeCharacteristic);
} catch (Exception e) {
Log.Error("Error", e.Message);
}
}
private void InternalWrite(byte[] data)
{
if (!NativeCharacteristic.SetValue(data))
{
throw new CharacteristicReadException("Gatt characteristic set value FAILED.");
}
Trace.Message("Write {0}", Id);
if (!_gatt.WriteCharacteristic(NativeCharacteristic))
{
throw new CharacteristicReadException("Gatt write characteristic FAILED.");
}
}
private bool GetSequenceNumber(BluetoothGatt gatt)
{
try {
if (gatt != null && _racpCharacteristic != null)
{
SetOpCode(_racpCharacteristic, 4, 1, new int[0]);
return(gatt.WriteCharacteristic(_racpCharacteristic));
}
} catch (Exception e) {
Log.Error("Error", e.Message);
}
return(false);
}
private bool GetAllRecords(BluetoothGatt gatt)
{
try {
if (gatt != null && _racpCharacteristic != null)
{
SetOpCode(_racpCharacteristic, 1, 1, new int[0]);
return(gatt.WriteCharacteristic(_racpCharacteristic));
}
} catch (Exception e) {
Log.Error("getAllRecords", e.Message);
}
return(false);
}
private void InternalWrite(byte[] data)
{
if (Configuration.IsForceUI)
{
using (var h = new Handler(Looper.MainLooper))
{
h.Post(() =>
{
if (!_nativeCharacteristic.SetValue(data))
{
throw new CharacteristicReadException("Gatt characteristic set value FAILED.");
}
Trace.Message("Write {0}", Id);
if (!_gatt.WriteCharacteristic(_nativeCharacteristic))
{
throw new CharacteristicReadException("Gatt write characteristic FAILED.");
}
});
}
}
else
{
if (!_nativeCharacteristic.SetValue(data))
{
throw new CharacteristicReadException("Gatt characteristic set value FAILED.");
}
Trace.Message("Write {0}", Id);
if (!_gatt.WriteCharacteristic(_nativeCharacteristic))
{
throw new CharacteristicReadException("Gatt write characteristic FAILED.");
}
}
}
private void SetValue()
{
String inputStr = valueInput.Text;
String[] valStr = inputStr.Split(':');
byte[] newValue = new byte[valStr.Length];
for (int i = 0; i < valStr.Length; i++)
{
newValue[i] = Convert.ToByte(valStr[i], 16);
}
characteristic.SetValue(newValue);
gatt.WriteCharacteristic(characteristic);
}
public void ConfigureMovement(BluetoothGatt gatt)
{
try
{
var characteristic = gatt.GetService(BluetoothSensorTagAttributes.MovementService).GetCharacteristic(BluetoothSensorTagAttributes.MovementConfiguration);
characteristic.SetValue(new byte[] { 0x7F, 0x02 });
gatt.WriteCharacteristic(characteristic);
SensorTagConfigurationStep = SensorTagConfigurationStep.Movement;
}
catch (System.Exception ex)
{
string title = this.GetType().Name + " - " + System.Reflection.MethodBase.GetCurrentMethod().Name;
BalizaFacil.App.Instance.UnhandledException(title, ex);
}
}
private bool SetFlag(BluetoothGatt gatt)
{
if (gatt == null || _racpCharacteristic == null)
{
return(false);
}
sbyte[] bArr = { -64, 2, -31, 1, 5, 1, 1, 1, 1, 1, 0 };
_racpCharacteristic.SetValue(new byte[bArr.Length]);
for (var i = 0; i < bArr.Length; i++)
{
_racpCharacteristic.SetValue((byte[])(Array)bArr);
}
return(gatt.WriteCharacteristic(_racpCharacteristic));
}
public void WriteCommand(EVrcRigCommand command)
{
if (gatt == null)
{
return;
}
var ms = new MemoryStream(20);
using (var writer = new BinaryWriter(ms)) {
writer.Write((byte)command);
}
writeCharacteristic.SetValue(ms.ToArray());
gatt.WriteCharacteristic(writeCharacteristic);
}
/// <summary>
///
/// </summary>
public virtual int WriteRXCharacteristic(byte[] value)
{
BluetoothGattService rxService = m_Gatt
.GetService(m_UuidServ);
if (rxService == null)
{
return(-1);
}
BluetoothGattCharacteristic rxChar = rxService
.GetCharacteristic(m_UuidRx);
if (rxChar == null)
{
return(-2);
}
rxChar.SetValue(value);
bool status = m_Gatt.WriteCharacteristic(rxChar);
return((status)?0:-3);
}
public override void OnServicesDiscovered(BluetoothGatt gatt, GattStatus status)
{
if (status != 0)
{
return;
}
if (HasCurrentTimeService(gatt))
{
BluetoothGattCharacteristic timeCharacteristic =
gatt.GetService(UUID.FromString("00001805-0000-1000-8000-00805f9b34fb"))
.GetCharacteristic(
UUID.FromString("00002A2B-0000-1000-8000-00805f9b34fb"));
timeCharacteristic.SetValue(GetCurrentTimeLocal());
gatt.WriteCharacteristic(timeCharacteristic);
}
else
{
ListenToMeasurements(gatt);
}
}
public int Transfer(byte[] data)
{
if (_ServerCh != null && _ServerDevice != null)
{
var sv = _ServerCh.SetValue(data);
if (sv)
{
var wc = _ServerDevice.WriteCharacteristic(_ServerCh);
if (wc)
{
return(data.Length);
}
else
{
return(-2);
}
}
return(-1);
}
return(0);
}
public override void OnServicesDiscovered(BluetoothGatt gatt, GattStatus status)
{
if (status != GattStatus.Success)
{
_MainActivity.AppendLogText("Failed to discover services");
gatt.Disconnect();
return;
}
_MainActivity.AppendLogText("Services Discovered");
var configurationService = gatt.GetService(_ConfigurationService);
if (configurationService == null)
{
_MainActivity.AppendLogText("Unable to find configuration service");
gatt.Disconnect();
return;
}
var configurationKeyCharacteristic = configurationService.GetCharacteristic(_ConfigurationKeyCharacteristic);
if (configurationKeyCharacteristic == null)
{
_MainActivity.AppendLogText("Unable to find characteristic");
gatt.Disconnect();
return;
}
var configKeyBytes = StringToByteArrayFastest(_ConfigurationValue);
configurationKeyCharacteristic.SetValue(configKeyBytes);
if (!gatt.WriteCharacteristic(configurationKeyCharacteristic))
{
_MainActivity.AppendLogText("Failed to write characteristic");
}
else
{
_MainActivity.AppendLogText("Writing characteristic...");
}
}