public void WriteType_set(CharacteristicWriteType writeType, CharacteristicPropertyType currentProperties) { var characteristic = new CharacteristicMock { MockPropterties = currentProperties }; characteristic.WriteType = writeType; Assert.Equal(writeType, characteristic.WriteType); }
/// <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"); } var nsData = NSData.FromArray(data); CBCharacteristicWriteType nativeWriteType = CBCharacteristicWriteType.WithResponse; if (writeType == CharacteristicWriteType.WithResponse) { nativeWriteType = CBCharacteristicWriteType.WithResponse; } else if (writeType == CharacteristicWriteType.WithoutResponse) { nativeWriteType = CBCharacteristicWriteType.WithoutResponse; } _peripheral.WriteValue(nsData, _nativeCharacteristic, nativeWriteType); if (writeType == CharacteristicWriteType.WithoutResponse) { WriteComplete?.Invoke(this, new CharacteristicWriteEventArgs(true, this)); } }
/// <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); } }
protected override async Task <bool> WriteNativeAsync(byte[] data, CharacteristicWriteType writeType) { _nativeCharacteristic.WriteType = writeType.ToNative(); if (writeType == CharacteristicWriteType.WithoutResponse) { return(InternalWrite(data)); } return(await TaskBuilder.FromEvent <bool, EventHandler <CharacteristicWriteCallbackEventArgs>, EventHandler>( execute : () => InternalWrite(data), getCompleteHandler : (complete, reject) => ((sender, args) => { if (args.Characteristic.Uuid == _nativeCharacteristic.Uuid) { complete(args.Exception == null); } }), subscribeComplete : handler => _gattCallback.CharacteristicValueWritten += handler, unsubscribeComplete : handler => _gattCallback.CharacteristicValueWritten -= handler, getRejectHandler : reject => ((sender, args) => { reject(new Exception($"Device '{Service.Device.Id}' disconnected while writing characteristic with {Id}.")); }), subscribeReject : handler => _gattCallback.ConnectionInterrupted += handler, unsubscribeReject : handler => _gattCallback.ConnectionInterrupted -= handler)); }
protected override Task<bool> WriteNativeAsync(byte[] data, CharacteristicWriteType writeType) { Task<bool> task; var nativeWriteType = writeType.ToNative(); if (nativeWriteType == CBCharacteristicWriteType.WithResponse) { task = TaskBuilder.FromEvent<bool, EventHandler<CBCharacteristicEventArgs>>( execute: () => { }, getCompleteHandler: (complete, reject) => (sender, args) => { if (args.Characteristic.UUID != _nativeCharacteristic.UUID) return; complete(args.Error == null); }, subscribeComplete: handler => _parentDevice.WroteCharacteristicValue += handler, unsubscribeComplete: handler => _parentDevice.WroteCharacteristicValue -= handler); } else { task = Task.FromResult(true); } var nsdata = NSData.FromArray(data); _parentDevice.WriteValue(nsdata, _nativeCharacteristic, nativeWriteType); return task; }
protected override Task <bool> WriteNativeAsync(byte[] data, CharacteristicWriteType writeType) { Task <bool> task; var nativeWriteType = writeType.ToNative(); if (nativeWriteType == CBCharacteristicWriteType.WithResponse) { task = TaskBuilder.FromEvent <bool, EventHandler <CBCharacteristicEventArgs> >( execute: () => { }, getCompleteHandler: (complete, reject) => (sender, args) => { if (args.Characteristic.UUID != _nativeCharacteristic.UUID) { return; } complete(args.Error == null); }, subscribeComplete: handler => _parentDevice.WroteCharacteristicValue += handler, unsubscribeComplete: handler => _parentDevice.WroteCharacteristicValue -= handler); } else { task = Task.FromResult(true); } var nsdata = NSData.FromArray(data); _parentDevice.WriteValue(nsdata, _nativeCharacteristic, nativeWriteType); return(task); }
public void WriteType_set_throws_InvalidOperationException(CharacteristicWriteType writeType, CharacteristicPropertyType currentProperties) { var characteristic = new CharacteristicMock { MockPropterties = currentProperties }; Assert.Throws<InvalidOperationException>(() => { characteristic.WriteType = writeType; }); }
protected async Task <bool> WriteNativeAsync(byte[] data, CharacteristicWriteType writeType) { var result = await NativeCharacteristic.WriteValueWithResultAsync( CryptographicBuffer.CreateFromByteArray(data), writeType == CharacteristicWriteType.WithResponse?GattWriteOption.WriteWithResponse : GattWriteOption.WriteWithoutResponse); result.ThrowIfError(); return(true); }
public void WriteType_set_throws_InvalidOperationException(CharacteristicWriteType writeType, CharacteristicPropertyType currentProperties) { CharacteristicMock characteristic = new CharacteristicMock { MockPropterties = currentProperties }; Assert.Throws <InvalidOperationException>(() => { characteristic.WriteType = writeType; }); }
public void WriteType_set(CharacteristicWriteType writeType, CharacteristicPropertyType currentProperties) { var characteristic = new CharacteristicMock { MockPropterties = currentProperties, WriteType = writeType }; Assert.Equal(writeType, characteristic.WriteType); }
public async Task Write_WriteType(CharacteristicWriteType expectedWriteType, CharacteristicWriteType currentWriteType, CharacteristicPropertyType currentProperties) { var characteristic = new CharacteristicMock { MockPropterties = currentProperties, WriteType = currentWriteType }; await characteristic.WriteAsync(new byte[0]); var writtenType = characteristic.WriteHistory.First().WriteType; Assert.Equal(expectedWriteType, writtenType); }
public static GattWriteType ToNative(this CharacteristicWriteType writeType) { switch (writeType) { case CharacteristicWriteType.WithResponse: return(GattWriteType.Default); case CharacteristicWriteType.WithoutResponse: return(GattWriteType.NoResponse); default: throw new NotImplementedException(); } }
protected override Task <bool> WriteNativeAsync(byte[] data, CharacteristicWriteType writeType) { var exception = new Exception($"Device {Service.Device.Id} disconnected while writing characteristic with {Id}."); Task <bool> task; if (writeType.ToNative() == CBCharacteristicWriteType.WithResponse) { task = TaskBuilder.FromEvent <bool, EventHandler <CBCharacteristicEventArgs>, EventHandler <CBPeripheralErrorEventArgs> >( execute: () => { if (_parentDevice.State != CBPeripheralState.Connected) { throw exception; } }, getCompleteHandler: (complete, reject) => (sender, args) => { if (args.Characteristic.UUID != _nativeCharacteristic.UUID) { return; } complete(args.Error == null); }, subscribeComplete: handler => _parentDevice.WroteCharacteristicValue += handler, unsubscribeComplete: handler => _parentDevice.WroteCharacteristicValue -= handler, getRejectHandler: reject => ((sender, args) => { if (args.Peripheral.Identifier == _parentDevice.Identifier) { reject(exception); } }), subscribeReject: handler => _bleCentralManagerDelegate.DisconnectedPeripheral += handler, unsubscribeReject: handler => _bleCentralManagerDelegate.DisconnectedPeripheral -= handler); } else { task = Task.FromResult(true); } var nsdata = NSData.FromArray(data); _parentDevice.WriteValue(nsdata, _nativeCharacteristic, writeType.ToNative()); return(task); }
protected override async Task<bool> WriteNativeAsync(byte[] data, CharacteristicWriteType writeType) { _nativeCharacteristic.WriteType = writeType.ToNative(); return await TaskBuilder.FromEvent<bool, EventHandler<CharacteristicWriteCallbackEventArgs>>( execute: () => InternalWrite(data), getCompleteHandler: (complete, reject) => ((sender, args) => { if (args.Characteristic.Uuid == _nativeCharacteristic.Uuid) { complete(args.Exception == null); } }), subscribeComplete: handler => _gattCallback.CharacteristicValueWritten += handler, unsubscribeComplete: handler => _gattCallback.CharacteristicValueWritten -= handler ); }
protected override async Task <bool> WriteNativeAsync(byte[] data, CharacteristicWriteType writeType) { _nativeCharacteristic.WriteType = writeType.ToNative(); return(await TaskBuilder.FromEvent <bool, EventHandler <CharacteristicWriteCallbackEventArgs> >( execute : () => InternalWrite(data), getCompleteHandler : (complete, reject) => ((sender, args) => { if (args.Characteristic.Uuid == _nativeCharacteristic.Uuid) { complete(args.Exception == null); } }), subscribeComplete : handler => _gattCallback.CharacteristicValueWritten += handler, unsubscribeComplete : handler => _gattCallback.CharacteristicValueWritten -= handler )); }
protected override async Task <Boolean> WriteNativeAsync(Byte[] data, CharacteristicWriteType writeType) { //print errors if error and write with response if (writeType == CharacteristicWriteType.WithResponse) { GattWriteResult result = await this._nativeCharacteristic.WriteValueWithResultAsync( CryptographicBuffer.CreateFromByteArray(data)); if (result.Status == GattCommunicationStatus.Success) { Trace.Message("Write successful"); return(true); } if (result.Status == GattCommunicationStatus.AccessDenied) { Trace.Message("Incorrect permissions to stop updates"); } else if (result.Status == GattCommunicationStatus.ProtocolError && result.ProtocolError != null) { Trace.Message("Write Characteristic returned with error: {0}", this.parseError(result.ProtocolError)); } else if (result.Status == GattCommunicationStatus.ProtocolError) { Trace.Message("Write Characteristic returned with unknown error"); } else if (result.Status == GattCommunicationStatus.Unreachable) { Trace.Message("Characteristic write is unreachable"); } return(false); } GattCommunicationStatus status = await this._nativeCharacteristic.WriteValueAsync(CryptographicBuffer.CreateFromByteArray(data), GattWriteOption.WriteWithoutResponse); if (status == GattCommunicationStatus.Success) { return(true); } return(false); }
protected override async Task <Boolean> WriteNativeAsync(Byte[] data, CharacteristicWriteType writeType) { this._nativeCharacteristic.WriteType = writeType.ToNative(); return(await TaskBuilder .FromEvent <Boolean, EventHandler <CharacteristicWriteCallbackEventArgs>, EventHandler>( () => this.InternalWrite(data), (complete, reject) => (sender, args) => { if (args.Characteristic.Uuid == this._nativeCharacteristic.Uuid) { complete(args.Exception == null); } }, handler => this._gattCallback.CharacteristicValueWritten += handler, handler => this._gattCallback.CharacteristicValueWritten -= handler, reject => (sender, args) => { reject(new Exception( $"Device '{this.Service.Device.Id}' disconnected while writing characteristic with {this.Id}.")); }, handler => this._gattCallback.ConnectionInterrupted += handler, handler => this._gattCallback.ConnectionInterrupted -= handler)); }
protected abstract Task<bool> WriteNativeAsync(byte[] data, CharacteristicWriteType writeType);
public WriteOperation(Byte[] value, CharacteristicWriteType writeType) { this.Value = value; this.WriteType = writeType; }
protected Task <bool> WriteNativeAsync(byte[] data, CharacteristicWriteType writeType) => throw new PlatformNotSupportedException();
protected override Task<bool> WriteNativeAsync(byte[] data, CharacteristicWriteType writeType) { WriteHistory.Add(new WriteOperation(data, writeType)); return Task.FromResult(true); }
public WriteOperation(byte[] value, CharacteristicWriteType writeType) { Value = value; WriteType = writeType; }