private void ShowCharacteristicView(BluetoothGattCharacteristic characteristic)
{
var extraString = "Characteristic";
Intent intent = null;
var property = _allowedProperties.FirstOrDefault(p => characteristic.Properties.HasFlag(p));
switch (property)
{
case GattProperty.Read:
intent = new Intent(this, typeof(ReadCharacteristicView)).PutExtra(extraString, characteristic.Uuid);
break;
case GattProperty.Notify:
intent = new Intent(this, typeof(NotifyCharacteristicView)).PutExtra(extraString, characteristic.Uuid);
break;
case GattProperty.Write:
case GattProperty.WriteNoResponse:
case GattProperty.SignedWrite:
intent = new Intent(this, typeof(WriteCharacteristicView)).PutExtra(extraString, characteristic.Uuid);
break;
}
if (intent != null)
{
StartActivity(intent);
}
}
public Characteristic(BluetoothGattCharacteristic nativeCharacteristic, BluetoothGatt gatt,
IGattCallback gattCallback)
{
_nativeCharacteristic = nativeCharacteristic;
_gatt = gatt;
_gattCallback = gattCallback;
}
public override void OnCharacteristicRead(ABluetooth.BluetoothGatt gatt, ABluetooth.BluetoothGattCharacteristic characteristic, ABluetooth.GattStatus status)
{
System.Diagnostics.Debug.WriteLine($"CharacteristicRead {characteristic.Uuid} {status}");
_owner.CharacteristicRead?.Invoke(_owner, new CharacteristicEventArgs {
Characteristic = characteristic, Status = status
});
}
private void GattObserverOnCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, GattStatus status)
{
if (_onRead != null)
{
_onRead(characteristic.GetValue(), status);
}
}
private void SubscribeCharacteristic(BluetoothGattCharacteristic characteristic)
{
_gatt.SetCharacteristicNotification(characteristic, true);
var descriptor = characteristic.GetDescriptor(UUID.FromString("00002902-0000-1000-8000-00805f9b34fb"));
descriptor.SetValue(BluetoothGattDescriptor.EnableNotificationValue.ToArray());
_gatt.WriteDescriptor(descriptor);
}
private void InitializeView()
{
var connectionHandler = BluetoothClient.Instance.ConnectionHandler;
_readingHandler = new DeviceReadingHandler(connectionHandler.GattValue, GattClientObserver.Instance);
_characteristic = GetCharacteristic(connectionHandler.GetServiceList());
var readButton = FindViewById<Button>(Resource.Id.ReadCharacteristicButton);
readButton.Click += ReadButtonOnClick;
}
private void InitalizeView()
{
var connectionHandler = BluetoothClient.Instance.ConnectionHandler;
_writingHandler = new DeviceWritingHandler(connectionHandler.GattValue, GattClientObserver.Instance);
_writingHandler.ReceivedWriteResponce += OnReceivedWriteResponce;
_characteristic = GetCharacteristic(connectionHandler.GetServiceList());
var writeButton = FindViewById<Button>(Resource.Id.WriteCharacteristicButton);
writeButton.Click += WriteButtonOnClick;
}
public override void OnCharacteristicWriteRequest(BluetoothDevice device, int requestId, BluetoothGattCharacteristic characteristic,
bool preparedWrite, bool responseNeeded, int offset, byte[] value)
{
base.OnCharacteristicWriteRequest(device, requestId, characteristic, preparedWrite, responseNeeded, offset, value);
if (CharacteristicWriteRequest != null)
{
CharacteristicWriteRequest(this, new BleEventArgs() { Device = device, Characteristic = characteristic, Value = value, RequestId = requestId, Offset = offset });
}
}
private void InitializeView()
{
var connectionHandler = BluetoothClient.Instance.ConnectionHandler;
_notifyHandler = new DeviceNotifyingHandler(connectionHandler.GattValue, GattClientObserver.Instance);
_characteristic = GetCharacteristic(connectionHandler.GetServiceList());
_notifyHandler.ValueChanged += NotifyOnValueChanged;
_notifyHandler.Subscribe(_characteristic,
result => DialogView.ShowDialog(result ? "Successfuly subscribed" : "Failed to subscribe", this));
}
public override void OnCharacteristicRead (BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, GattStatus status)
{
base.OnCharacteristicRead (gatt, characteristic, status);
Console.WriteLine ("GattCallBack: OnCharacteristicRead: " + characteristic.GetStringValue (0));
this.CharacteristicValueUpdated (this, new CharacteristicReadEventArgs () {
Characteristic = new Characteristic (characteristic, gatt, this) }
);
}
/// <summary>
/// Initializes a new instance of the <see cref="BluetoothLE.Droid.Characteristic"/> class.
/// </summary>
/// <param name="characteristic">Characteristic.</param>
/// <param name="gatt">Gatt.</param>
/// <param name="gattCallback">Gatt callback.</param>
public Characteristic(BluetoothGattCharacteristic characteristic, BluetoothGatt gatt, GattCallback gattCallback)
{
_nativeCharacteristic = characteristic;
_gatt = gatt;
_callback = gattCallback;
if (_callback != null)
{
_callback.CharacteristicValueUpdated += CharacteristicValueUpdated;
}
}
public override void OnCharacteristicChanged (BluetoothGatt gatt, BluetoothGattCharacteristic characteristic)
{
base.OnCharacteristicChanged (gatt, characteristic);
Console.WriteLine ("OnCharacteristicChanged: " + characteristic.GetStringValue (0));
var f = new CharacteristicReadEventArgs () {
Characteristic = new Characteristic (characteristic, gatt, this)};
Debug.WriteLine ("OnCharacteristicChanged" + f);
this.CharacteristicValueUpdated (this, f);
}
public override void OnCharacteristicReadRequest(BluetoothDevice device, int requestId, int offset,
BluetoothGattCharacteristic characteristic)
{
base.OnCharacteristicReadRequest(device, requestId, offset, characteristic);
Console.WriteLine("Read request from {0}", device.Name);
if (CharacteristicReadRequest != null)
{
CharacteristicReadRequest(this, new BleEventArgs() { Device = device, Characteristic = characteristic, RequestId = requestId, Offset = offset });
}
}
private void NotifyOnValueChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic)
{
var hexText = FindViewById<TextView>(Resource.Id.ReceivedNotificationHex);
var stringText = FindViewById<TextView>(Resource.Id.ReceivedNotificationString);
var receivedBytes = characteristic.GetValue();
RunOnUiThread(() =>
{
hexText.SetText(BitConverter.ToString(receivedBytes), TextView.BufferType.Normal);
stringText.SetText(Encoding.ASCII.GetString(receivedBytes), TextView.BufferType.Normal);
});
}
public override void OnCharacteristicRead(bt.BluetoothGatt gatt, bt.BluetoothGattCharacteristic characteristic, [GeneratedEnum] bt.GattStatus status)
{
base.OnCharacteristicRead(gatt, characteristic, status);
this.CharacteristicRead?.Invoke(this, new CharacteristicValueChangedEventArgs(gatt, characteristic, status));
byte[] value = characteristic.GetValue();
var myChar = this.ServicesById[characteristic.Service.Uuid].CharacteristicsById[characteristic.Uuid];
// If the system architecture is little-endian (that is, little end first),
// reverse the byte array.
if (BitConverter.IsLittleEndian)
{
Array.Reverse(value);
}
myChar.GetValueCompletionSource?.SetResult(value);
myChar.GetValueCompletionSource = null;
}
public Characteristic (BluetoothGattCharacteristic nativeCharacteristic, BluetoothGatt gatt, GattCallback gattCallback)
{
this._nativeCharacteristic = nativeCharacteristic;
this._gatt = gatt;
this._gattCallback = gattCallback;
if (this._gattCallback != null) {
// wire up the characteristic value updating on the gattcallback
this._gattCallback.CharacteristicValueUpdated += (object sender, CharacteristicReadEventArgs e) => {
// it may be other characteristics, so we need to test
if(e.Characteristic.ID == this.ID) {
// update our underlying characteristic (this one will have a value)
//TODO: is this necessary? probably the underlying reference is the same.
//this._nativeCharacteristic = e.Characteristic;
this.ValueUpdated (this, e);
}
};
}
}
private void GattCallback_CharacteristicReadEvent(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, GattStatus status)
{
System.Diagnostics.Debug.WriteLine($"�yGattCallback_CharacteristicReadEvent�z:{gatt},{characteristic},{status}");
// �K�v�ɉ����ăX�e�[�^�X�ɂ�菈����
switch (status)
{
case GattStatus.ConnectionCongested:
break;
case GattStatus.Failure:
break;
case GattStatus.InsufficientAuthentication:
break;
case GattStatus.InsufficientEncryption:
break;
case GattStatus.InvalidAttributeLength:
break;
case GattStatus.InvalidOffset:
break;
case GattStatus.ReadNotPermitted:
break;
case GattStatus.RequestNotSupported:
break;
case GattStatus.Success:
System.Diagnostics.Debug.WriteLine($"�ySuccess�z:{gatt},{characteristic},{status}");
var descs = characteristic.Descriptors;
foreach (var item in descs)
{
System.Diagnostics.Debug.WriteLine($"{item.Uuid},{item.Permissions}");
}
break;
case GattStatus.WriteNotPermitted:
break;
default:
break;
}
}
public BleServer(Context ctx)
{
_bluetoothManager = (BluetoothManager)ctx.GetSystemService(Context.BluetoothService);
_bluetoothAdapter = _bluetoothManager.Adapter;
_bluettothServerCallback = new BleGattServerCallback();
_bluetoothServer = _bluetoothManager.OpenGattServer(ctx, _bluettothServerCallback);
var service = new BluetoothGattService(UUID.FromString("ffe0ecd2-3d16-4f8d-90de-e89e7fc396a5"),
GattServiceType.Primary);
_characteristic = new BluetoothGattCharacteristic(UUID.FromString("d8de624e-140f-4a22-8594-e2216b84a5f2"), GattProperty.Read | GattProperty.Notify | GattProperty.Write, GattPermission.Read | GattPermission.Write);
_characteristic.AddDescriptor(new BluetoothGattDescriptor(UUID.FromString("28765900-7498-4bd4-aa9e-46c4a4fb7b07"),
GattDescriptorPermission.Read | GattDescriptorPermission.Write));
service.AddCharacteristic(_characteristic);
_bluetoothServer.AddService(service);
_bluettothServerCallback.CharacteristicReadRequest += _bluettothServerCallback_CharacteristicReadRequest;
_bluettothServerCallback.NotificationSent += _bluettothServerCallback_NotificationSent;
Console.WriteLine("Server created!");
BluetoothLeAdvertiser myBluetoothLeAdvertiser = _bluetoothAdapter.BluetoothLeAdvertiser;
var builder = new AdvertiseSettings.Builder();
builder.SetAdvertiseMode(AdvertiseMode.LowLatency);
builder.SetConnectable(true);
builder.SetTimeout(0);
builder.SetTxPowerLevel(AdvertiseTx.PowerHigh);
AdvertiseData.Builder dataBuilder = new AdvertiseData.Builder();
dataBuilder.SetIncludeDeviceName(true);
//dataBuilder.AddServiceUuid(ParcelUuid.FromString("ffe0ecd2-3d16-4f8d-90de-e89e7fc396a5"));
dataBuilder.SetIncludeTxPowerLevel(true);
myBluetoothLeAdvertiser.StartAdvertising(builder.Build(), dataBuilder.Build(), new BleAdvertiseCallback());
}
public void BroadcastUpdate (String action, BluetoothGattCharacteristic characteristic)
{
Intent intent = new Intent (action);
// This is special handling for the Heart Rate Measurement profile. Data parsing is
// carried out as per profile specifications:
// http://developer.bluetooth.org/gatt/characteristics/Pages/CharacteristicViewer.aspx?u=org.bluetooth.characteristic.heart_rate_measurement.xml
if (UUID_HEART_RATE_MEASUREMENT == (characteristic.Uuid)) {
GattProperty flag = characteristic.Properties;
GattFormat format = (GattFormat) (-1);
if (((int) flag & 0x01) != 0) {
format = GattFormat.Uint16;
Log.Debug (TAG, "Heart rate format UINT16.");
} else {
format = GattFormat.Uint8;
Log.Debug (TAG, "Heart rate format UINT8.");
}
var heartRate = characteristic.GetIntValue (format, 1);
Log.Debug (TAG, String.Format ("Received heart rate: {0}", heartRate));
intent.PutExtra (EXTRA_DATA, heartRate);
} else {
// For all other profiles, writes the data formatted in HEX.
byte[] data = characteristic.GetValue ();
if (data != null && data.Length > 0) {
StringBuilder stringBuilder = new StringBuilder (data.Length);
foreach (byte byteChar in data)
stringBuilder.Append (String.Format ("{0}02X ", byteChar));
intent.PutExtra (EXTRA_DATA, Convert.ToBase64String (data) + "\n" + stringBuilder.ToString());
}
}
SendBroadcast (intent);
}
public CharacteristicReadCallbackEventArgs(BluetoothGattCharacteristic characteristic)
{
Characteristic = characteristic;
}
public override void OnCharacteristicWrite(bt.BluetoothGatt gatt, bt.BluetoothGattCharacteristic characteristic, [GeneratedEnum] bt.GattStatus status)
{
base.OnCharacteristicWrite(gatt, characteristic, status);
this.CharacteristicWrite?.Invoke(this, new CharacteristicValueChangedEventArgs(gatt, characteristic, status));
}
private void OnCharacteristicValueChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic)
{
var handler = ValueChanged;
if (handler != null) handler(gatt, characteristic);
}
protected override void OnCreate (Bundle bundle)
{
base.OnCreate (bundle);
SetContentView (Resource.Layout.gatt_services_characteristics);
mServiceManager = new ServiceManager (this);
Intent intent = Intent;
mDeviceName = intent.GetStringExtra (EXTRAS_DEVICE_NAME);
mDeviceAddress = intent.GetStringExtra (EXTRAS_DEVICE_ADDRESS);
// Sets up UI references.
(FindViewById <TextView> (Resource.Id.device_address)).Text = mDeviceAddress;
mGattServicesList = FindViewById <ExpandableListView> (Resource.Id.gatt_services_list) ;
mGattServicesList.ChildClick += delegate(object sender, ExpandableListView.ChildClickEventArgs e) {
if (mGattCharacteristics != null) {
var groupPosition = mGattCharacteristics [e.GroupPosition];
BluetoothGattCharacteristic characteristic = groupPosition [e.ChildPosition];
var charaProp = characteristic.Properties;
if ((charaProp & GattProperty.Read) > 0) {
// If there is an active notification on a characteristic, clear
// it first so it doesn't update the data field on the user interface.
if (mNotifyCharacteristic != null) {
mBluetoothLeService.SetCharacteristicNotification (
mNotifyCharacteristic, false);
mNotifyCharacteristic = null;
}
mBluetoothLeService.ReadCharacteristic (characteristic);
}
if ((charaProp & GattProperty.Notify) > 0) {
mNotifyCharacteristic = characteristic;
mBluetoothLeService.SetCharacteristicNotification (characteristic, true);
}
}
};
mConnectionState = FindViewById <TextView> (Resource.Id.connection_state);
mDataField = FindViewById <TextView> (Resource.Id.data_value);
ActionBar.Title = mDeviceName;
ActionBar.SetDisplayHomeAsUpEnabled (true);
Intent gattServiceIntent = new Intent(this, typeof (BluetoothLeService));
BindService (gattServiceIntent, mServiceManager, Bind.AutoCreate);
}
public override void OnCharacteristicRead (BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, GattStatus status)
{
if (status == GattStatus.Success) {
service.BroadcastUpdate (BluetoothLeService.ACTION_DATA_AVAILABLE, characteristic);
}
}
/// <summary>
/// Raises the characteristic read event.
/// </summary>
/// <param name="gatt">Gatt.</param>
/// <param name="characteristic">Characteristic.</param>
/// <param name="status">Status.</param>
public override void OnCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, GattStatus status)
{
base.OnCharacteristicRead(gatt, characteristic, status);
if (status != GattStatus.Success)
return;
var iChar = new Characteristic(characteristic, gatt, this);
CharacteristicValueUpdated(this, new CharacteristicReadEventArgs(iChar));
}
/// <Docs>GATT client the characteristic is associated with</Docs>
/// <summary>
/// Callback triggered as a result of a remote characteristic notification.
/// </summary>
/// <para tool="javadoc-to-mdoc">Callback triggered as a result of a remote characteristic notification.</para>
/// <format type="text/html">[Android Documentation]</format>
/// <since version="Added in API level 18"></since>
/// <param name="gatt">Gatt.</param>
/// <param name="characteristic">Characteristic.</param>
public override void OnCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic)
{
base.OnCharacteristicChanged(gatt, characteristic);
var iChar = new Characteristic(characteristic, gatt, this);
CharacteristicValueUpdated(this, new CharacteristicReadEventArgs(iChar));
}
public override void OnCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, GattStatus status)
{
var handler = CharacteristicWritten;
if (handler != null) handler(gatt, characteristic, status);
}
public override void OnCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic)
{
var handler = CharacteristicValueChanged;
if (handler != null) handler(gatt, characteristic);
}
public override void OnCharacteristicChanged(bt.BluetoothGatt gatt, bt.BluetoothGattCharacteristic characteristic)
{
base.OnCharacteristicChanged(gatt, characteristic);
CharacteristicChanged?.Invoke(this, new CharacteristicChangedEventArgs(gatt, characteristic));
}
public CharacteristicChangedEventArgs(bt.BluetoothGatt gatt, bt.BluetoothGattCharacteristic characteristic)
{
this.Gatt = gatt;
this.Characteristic = characteristic;
}
/**
* Request a read on a given {@code BluetoothGattCharacteristic}. The read result is reported
* asynchronously through the {@code BluetoothGattCallback#onCharacteristicRead(android.bluetooth.BluetoothGatt, android.bluetooth.BluetoothGattCharacteristic, int)}
* callback.
*
* @param characteristic The characteristic to read from.
*/
public void ReadCharacteristic (BluetoothGattCharacteristic characteristic)
{
if (mBluetoothAdapter == null || mBluetoothGatt == null) {
Log.Warn (TAG, "BluetoothAdapter not initialized");
return;
}
mBluetoothGatt.ReadCharacteristic (characteristic);
}
public CharacteristicValueChangedEventArgs(bt.BluetoothGatt gatt, bt.BluetoothGattCharacteristic characteristic, bt.GattStatus status)
{
this.Gatt = gatt;
this.Characteristic = characteristic;
this.Status = status;
}
/**
* Enables or disables notification on a give characteristic.
*
* @param characteristic Characteristic to act on.
* @param enabled If true, enable notification. False otherwise.
*/
public void SetCharacteristicNotification (BluetoothGattCharacteristic characteristic, bool enabled)
{
if (mBluetoothAdapter == null || mBluetoothGatt == null) {
Log.Warn (TAG, "BluetoothAdapter not initialized");
return;
}
mBluetoothGatt.SetCharacteristicNotification (characteristic, enabled);
// This is specific to Heart Rate Measurement.
if (UUID_HEART_RATE_MEASUREMENT == characteristic.Uuid) {
BluetoothGattDescriptor descriptor = characteristic.GetDescriptor (
UUID.FromString (SampleGattAttributes.CLIENT_CHARACTERISTIC_CONFIG));
descriptor.SetValue (BluetoothGattDescriptor.EnableNotificationValue.ToArray ());
mBluetoothGatt.WriteDescriptor (descriptor);
}
}
public override void OnCharacteristicChanged(ABluetooth.BluetoothGatt gatt, ABluetooth.BluetoothGattCharacteristic characteristic)
{
System.Diagnostics.Debug.WriteLine($"CharacteristicChanged {characteristic.Uuid}");
_owner.CharacteristicChanged?.Invoke(_owner, new CharacteristicEventArgs {
Characteristic = characteristic
});
}
public override void OnCharacteristicChanged (BluetoothGatt gatt, BluetoothGattCharacteristic characteristic)
{
service.BroadcastUpdate (BluetoothLeService.ACTION_DATA_AVAILABLE, characteristic);
}
public override void OnCharacteristicWrite(ABluetooth.BluetoothGatt gatt, ABluetooth.BluetoothGattCharacteristic characteristic, ABluetooth.GattStatus status)
{
System.Diagnostics.Debug.WriteLine($"CharacteristicWrite {characteristic.Uuid} {status}");
_owner._characteristicWriteHandle.Set();
}
internal GattCharacteristic(GattService service, Android.Bluetooth.BluetoothGattCharacteristic characteristic) : this(service)
{
_characteristic = characteristic;
}
public override void OnCharacteristicChanged(ABluetooth.BluetoothGatt gatt, ABluetooth.BluetoothGattCharacteristic characteristic)
{
System.Diagnostics.Debug.WriteLine($"CharacteristicChanged {characteristic.Uuid}");
_owner.CharacteristicChanged?.Invoke(this, characteristic.Uuid);
}
public override void OnCharacteristicWriteRequest(BluetoothDevice device, int requestId, BluetoothGattCharacteristic characteristic,
bool preparedWrite, bool responseNeeded, int offset, byte[] value)
{
var handler = CharasteristicWriteRequested;
if (handler != null) handler(device, requestId, characteristic, preparedWrite, responseNeeded, offset, value);
}
public void Unsubscribe(BluetoothGattCharacteristic characteristic)
{
_gatt.SetCharacteristicNotification(characteristic, false);
}