private async void writeRemoteCanStop(GattLocalCharacteristic sender, GattWriteRequestedEventArgs args)
{
var deferral = args.GetDeferral();
var request = await args.GetRequestAsync();
if (request == null)
{
Debug.WriteLine("Write of Can Stop had a null request! Make sure the application manifest allows Bluetooth access.");
deferral.Complete();
return;
}
// The "Can Stop" characteristic is a single byte of data - 0 for false, and 1 for true.
var reader = DataReader.FromBuffer(request.Value);
if (reader.UnconsumedBufferLength > 0)
{
var value = reader.ReadByte();
await eventDispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
canStop = value > 0;
Debug.WriteLine("Can Stop is now: {0}", canStop);
StateChanged?.Invoke(this, null);
});
}
if (request.Option == GattWriteOption.WriteWithResponse)
{
request.Respond();
}
deferral.Complete();
}
//---------------------------------------------------------------------
// Event callback for Write
//---------------------------------------------------------------------
protected virtual void Characteristic_WriteRequested(
GattLocalCharacteristic sender,
GattWriteRequestedEventArgs args
)
{
Characteristic_WriteRequested(sender, args, args.GetDeferral());
}
private async void OnWriteMessage(GattLocalCharacteristic sender, GattWriteRequestedEventArgs args)
{
var deferral = args.GetDeferral();
try
{
var req = await args.GetRequestAsync();
var reader = DataReader.FromBuffer(req.Value);
var buf = new byte[reader.UnconsumedBufferLength];
reader.ReadBytes(buf);
var xml = DMessenger.MessageEncoder.Decode(buf);
var msg = new DMessenger.Message(xml);
if (req.Option == GattWriteOption.WriteWithResponse)
{
req.Respond();
}
}
finally
{
deferral.Complete();
}
}
//---------------------------------------------------------------------
// Write request callback to receive the header length of an IPv6
// packet that had its header compressed
//---------------------------------------------------------------------
protected override void Characteristic_WriteRequested(
GattLocalCharacteristic sender,
GattWriteRequestedEventArgs args
)
{
// Receive the Write request into this characteristic's Value buffer
base.Characteristic_WriteRequested(sender, args);
}
//---------------------------------------------------------------------
// Write request callback to receive an IPv6 packet
//---------------------------------------------------------------------
protected override void Characteristic_WriteRequested(
GattLocalCharacteristic sender,
GattWriteRequestedEventArgs args
)
{
// Receive the Write request into this characteristic's Value buffer
base.Characteristic_WriteRequested(sender, args);
// Caller does something with the packet after this
}
private async void CommandCharacteristic_WriteRequested(GattLocalCharacteristic sender,
GattWriteRequestedEventArgs args)
{
var deferral = args.GetDeferral();
var request = await args.GetRequestAsync();
if (request == null)
{
return;
}
if (request.Value.Length != 1 && request.Value.Length != 5)
{
if (request.Option == GattWriteOption.WriteWithResponse)
{
request.RespondWithProtocolError(GattProtocolError.InvalidAttributeValueLength);
}
return;
}
var reader = DataReader.FromBuffer(request.Value);
reader.ByteOrder = ByteOrder.LittleEndian;
var commandCode = (CommandCode)reader.ReadByte();
if (!Enum.IsDefined(typeof(CommandCode), commandCode))
{
if (request.Option == GattWriteOption.WriteWithResponse)
{
request.RespondWithProtocolError(GattProtocolError.InvalidPdu);
}
return;
}
if (commandCode == CommandCode.Play && request.Value.Length == 5)
{
OnCommandReceived(commandCode, reader.ReadInt32());
}
else
{
OnCommandReceived(commandCode);
}
if (request.Option == GattWriteOption.WriteWithResponse)
{
request.Respond();
}
deferral.Complete();
}
private async void writeUserMessage(GattLocalCharacteristic sender, GattWriteRequestedEventArgs args)
{
var deferral = args.GetDeferral();
var request = await args.GetRequestAsync();
if (request == null)
{
Debug.WriteLine("Write of User Message had a null request! Make sure the application manifest allows Bluetooth access.");
deferral.Complete();
return;
}
try
{
// The "User Message" characteristic contains a UTF-8 string.
// It's valid for the app to send a zero-length payload here, which means "no custom message".
var bufferCount = request.Value.Length;
if (bufferCount > 0)
{
var stringValue = Encoding.UTF8.GetString(request.Value.ToArray());
await eventDispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
userMessage = stringValue;
Debug.WriteLine("User Message is now: {0}", userMessage);
StateChanged?.Invoke(this, null);
});
}
else
{
// If we have an empty buffer, we should null out the string.
await eventDispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
userMessage = null;
Debug.WriteLine("User Message is now empty");
StateChanged?.Invoke(this, null);
});
}
}
catch { }
if (request.Option == GattWriteOption.WriteWithResponse)
{
request.Respond();
}
deferral.Complete();
}
private async void BrightnessCharacteristic_WriteRequested(GattLocalCharacteristic sender,
GattWriteRequestedEventArgs args)
{
var deferral = args.GetDeferral();
var request = await args.GetRequestAsync();
if (request == null)
{
return;
}
if (request.Value.Length != 8)
{
if (request.Option == GattWriteOption.WriteWithResponse)
{
request.RespondWithProtocolError(GattProtocolError.InvalidAttributeValueLength);
}
return;
}
var reader = DataReader.FromBuffer(request.Value);
reader.ByteOrder = ByteOrder.LittleEndian;
var brightness = reader.ReadDouble();
if (brightness < 0 || brightness > 1)
{
if (request.Option == GattWriteOption.WriteWithResponse)
{
request.RespondWithProtocolError(GattProtocolError.InvalidPdu);
}
return;
}
OnBrightnessChangeReceived(brightness);
if (request.Option == GattWriteOption.WriteWithResponse)
{
request.Respond();
}
deferral.Complete();
}
private async void CharacteristicWriteRequested(GattLocalCharacteristic glc, GattWriteRequestedEventArgs args)
{
var def = args.GetDeferral();
var req = await args.GetRequestAsync();
var rdr = DataReader.FromBuffer(req.Value);
var str = rdr.ReadString(req.Value.Length);
if (DIGITS.IsMatch(str))
{
SendKeys.SendWait(str + "{ENTER}");
}
if (req.Option == GattWriteOption.WriteWithResponse)
{
req.Respond();
}
def.Complete();
}
/// <summary>
/// handles Reads on the STDOUT characteristic. If the command thread is done, restart command thread.
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private async void WriteCharacteristic_WriteRequested(GattLocalCharacteristic sender, GattWriteRequestedEventArgs args)
{
var deferral = args.GetDeferral();
var request = await args.GetRequestAsync();
var reader = DataReader.FromBuffer(request.Value);
//string data = reader.ReadString(reader.UnconsumedBufferLength);
byte[] data = new byte[reader.UnconsumedBufferLength];
reader.ReadBytes(data);
if (cmd.getCmdRunning() == true)
{
cmd.writeStdin(data);
Indicate();
}
else
{
cmd.startCommand();
Indicate();
}
if (request.Option == GattWriteOption.WriteWithResponse)
{
request.Respond();
}
deferral.Complete();
}
private async void OperatorCharacteristic_WriteRequestedAsync(GattLocalCharacteristic sender, GattWriteRequestedEventArgs args)
{
using (args.GetDeferral())
{
// Get the request information. This requires device access before an app can access the device's request.
GattWriteRequest request = await args.GetRequestAsync();
if (request == null)
{
// No access allowed to the device. Application should indicate this to the user.
return;
}
ProcessWriteCharacteristic(request, CalculatorCharacteristics.Operator);
}
}
// Helper function for async Write callback
protected virtual async void Characteristic_WriteRequested(
GattLocalCharacteristic sender,
GattWriteRequestedEventArgs args,
Deferral deferral
)
{
Debug.WriteLine("base.Characteristic_WriteRequested Entry");
GattWriteRequest request = null;
// Get an event deferral for async operations if we don't have one
if (deferral == null)
{
deferral = args.GetDeferral();
}
//
// Normally, GetRequestAsync() is recommended to run on a UI thread
// because, even with paired devices, the device may prompt the
// user for consent. But, we're running in a background service so
// we won't run this on a UI thread. According to one of the devs
// on the core Bluetooth team, because this is for a "test
// application," consent prompts are not currently part of MS's
// policy and it will be auto-accepted.
//
request = await args.GetRequestAsync();
if (request == null)
{
Debug.WriteLine("Could not retrieve request from the " +
"GattWriteRequestedEventArgs. Request was " +
"null."
);
goto Exit;
}
// Set the value
Value = request.Value;
// Respond with completion notification if requested
if (request.Option == GattWriteOption.WriteWithResponse)
{
Debug.WriteLine("Completing write request with response.");
request.Respond();
}
else
{
Debug.WriteLine("Completing write request without response.");
}
// Debugging print!
//byte[] data;
//CryptographicBuffer.CopyToByteArray(Value, out data);
//if(data == null)
//{
// Debug.WriteLine("Value after write completion was NULL. :(");
//}
//else
//{
// Debug.WriteLine($"Write completed. Received packet from {args.Session.DeviceId.ToString()}, value is now {Utilities.BytesToString(data)}");
//}
Exit:
deferral.Complete();
Debug.WriteLine("base.Characteristic_WriteRequested Exit");
}
private async void OnboardingRequestCharacteristic_WriteRequestedAsync(GattLocalCharacteristic sender, GattWriteRequestedEventArgs args)
{
using (args.GetDeferral())
{
var request = await args.GetRequestAsync();
var reader = DataReader.FromBuffer(request.Value);
//var bytes = new byte[4098];
var result = reader.ReadString(reader.UnconsumedBufferLength);
//var result = Encoding.UTF8.GetString(bytes);
rootPage.NotifyUser($"Onboarding Request : {result}", NotifyType.StatusMessage);
// Complete the request if needed
if (request.Option == GattWriteOption.WriteWithResponse)
{
request.Respond();
}
}
}
private async void Op1Characteristic_WriteRequestedAsync(GattLocalCharacteristic sender, GattWriteRequestedEventArgs args)
{
// BT_Code: Processing a write request.
using (args.GetDeferral())
{
PlayMusic();
}
}
// GattLocalCharacteristic
private async void OnCharacteristicWriteRequested(GattLocalCharacteristic characteristic, GattWriteRequestedEventArgs args)
{
Utils.Info("OnWriteRequested: {0}", args.Session.DeviceId.Id);
using (var derferral = args.GetDeferral())
{
var request = await args.GetRequestAsync().AsTask();
lock (mLockObject)
{
if ((mStatus != Status.Ready) && (mStatus != Status.Advertise))
{
Utils.Error("invalid status: {0}", mStatus.ToString());
request.RespondWithProtocolError(GattProtocolError.RequestNotSupported);
return;
}
var context = mSubscribedCentrals.Where(ctx => ctx.client.Session.DeviceId.Id == args.Session.DeviceId.Id).FirstOrDefault();
if (context == null)
{
Utils.Error("not subscribed");
request.RespondWithProtocolError(GattProtocolError.InsufficientAuthentication);
return;
}
if ((request.Option != GattWriteOption.WriteWithResponse) || (request.Offset != 0) || (request.Value == null))
{
Utils.Error("invalid parameter");
request.RespondWithProtocolError(GattProtocolError.InvalidPdu);
return;
}
request.Respond();
if (context.connectionId == 0) // Negotiation complete
{
Utils.Info("negotiation complete");
context.connectionId = mNextConnectionId++;
mCallback.OnConnect(context.connectionId);
}
else
{
ProcessReceiveBuffer(context, request.Value.AsBytes());
}
}
}
}
/// <summary>
/// Base implementation for the write callback
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private async void Characteristic_WriteRequested(GattLocalCharacteristic sender, GattWriteRequestedEventArgs args)
{
Debug.WriteLine("Characteristic_WriteRequested: Write Requested");
// Grab the event deferral before performing any async operations in the handler.
var deferral = args.GetDeferral();
// In order to get the remote request, access to the device must be provided by the user.
// This can be accomplished by calling BluetoothLEDevice.RequestAccessAsync(), or by getting the request on the UX thread.
//
// Note that subsequent calls to RequestAccessAsync or GetRequestAsync for the same device do not need to be called on the UX thread.
await CoreApplication.MainView.CoreWindow.Dispatcher.RunTaskAsync(
async() =>
{
// Grab the request
var request = await args.GetRequestAsync();
Debug.WriteLine($"Characteristic_WriteRequested - Length {request.Value.Length}, State: {request.State}, Offset: {request.Offset}");
// WriteRequested overriden if needed to set up the Value
// if not - set the Value here
if (!WriteRequested(args.Session, request))
{
// Set the characteristic Value
Value = request.Value;
}
else
{
Debug.WriteLine("Characteristic_WriteRequested: Looks like write completed in derived class");
}
// Complete request (respond with confirmation in case of WRITE REQ) even if the overriden WriteRequested did not change the Value.
// As side effect this will show in nRF Connect that the value has changed even if it hasn't.
if (request.Option == GattWriteOption.WriteWithResponse)
{
Debug.WriteLine("Characteristic_WriteRequested: Completing request with responds");
request.Respond();
}
else
{
Debug.WriteLine("Characteristic_WriteRequested: Completing request without responds");
}
byte[] data;
CryptographicBuffer.CopyToByteArray(Value, out data);
if (data == null)
{
Debug.WriteLine("Characteristic_WriteRequested: Value after write complete was NULL");
}
else
{
Debug.WriteLine($"Characteristic_WriteRequested: New Value: {data.BytesToString()}");
}
deferral.Complete();
});
}
public static async void Op1Characteristic_WriteRequestedAsync(GattLocalCharacteristic sender, GattWriteRequestedEventArgs args)
{
// BT_Code: Processing a write request.
using (args.GetDeferral())
{
ApplicationData.Current.LocalSettings.Values["Op1ReceivedEver"] = "yes";
// Get the request information. This requires device access before an app can access the device's request.
GattWriteRequest request = await args.GetRequestAsync();
if (request == null)
{
// No access allowed to the device. Application should indicate this to the user.
return;
}
ProcessWriteCharacteristic(request, SDKTemplate.Calculator.CalculatorCharacteristics.Operand1);
//UpdateUX();
}
}
/// <summary>
/// Event handler for Alert Notification Control point
/// </summary>
/// <param name="sender">The source of the Write request</param>
/// <param name="args">Details about the request</param>
private void AlertNotificationCtrlPntOnWriteRequested(GattLocalCharacteristic sender, GattWriteRequestedEventArgs args)
{
throw new NotImplementedException();
}
/// <summary>
/// Base implementation for the write callback
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private async void Characteristic_WriteRequested(GattLocalCharacteristic sender, GattWriteRequestedEventArgs args)
{
Debug.WriteLine("Characteristic_WriteRequested: Write Requested");
// Grab the event deferral before performing any async operations in the handler.
var deferral = args.GetDeferral();
// In order to get the remote request, access to the device must be provided by the user.
// This can be accomplished by calling BluetoothLEDevice.RequestAccessAsync(), or by getting the request on the UX thread.
//
// Note that subsequent calls to RequestAccessAsync or GetRequestAsync for the same device do not need to be called on the UX thread.
await CoreApplication.MainView.CoreWindow.Dispatcher.RunTaskAsync(
async() =>
{
// Grab the request
var request = await args.GetRequestAsync();
Debug.WriteLine($"Characteristic_WriteRequested - Length {request.Value.Length}, State: {request.State}, Offset: {request.Offset}");
if (!WriteRequested(args.Session, request))
{
// Set the characteristic Value
Value = request.Value;
// Respond with completed
if (request.Option == GattWriteOption.WriteWithResponse)
{
Debug.WriteLine("Characteristic_WriteRequested: Completing request with responds");
request.Respond();
}
else
{
Debug.WriteLine("Characteristic_WriteRequested: Completing request without responds");
}
}
// everything below this is debug. Should implement this on non-UI thread based on
// https://github.com/Microsoft/Windows-task-snippets/blob/master/tasks/UI-thread-task-await-from-background-thread.md
byte[] data;
CryptographicBuffer.CopyToByteArray(Value, out data);
if (data == null)
{
Debug.WriteLine("Characteristic_WriteRequested: Value after write complete was NULL");
}
else
{
Debug.WriteLine($"Characteristic_WriteRequested: New Value: {data.BytesToString()}");
}
deferral.Complete();
});
}
private async void HidControlPoint_WriteRequested(GattLocalCharacteristic sender, GattWriteRequestedEventArgs args)
{
try
{
var deferral = args.GetDeferral();
var writeRequest = await args.GetRequestAsync();
Debug.WriteLine("Value written to HID Control Point: " + GetStringFromBuffer(writeRequest.Value));
// Control point only supports WriteWithoutResponse.
deferral.Complete();
}
catch (Exception e)
{
Debug.WriteLine("Failed to handle write to Hid Control Point due to: " + e.Message);
}
}
