mirror of
https://dev.azure.com/TeilRad/sharee.bike%20App/_git/Code
synced 2024-05-02 08:36:36 +02:00
1257 lines
47 KiB
C#
1257 lines
47 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Threading;
|
||
using System.Threading.Tasks;
|
||
using Plugin.BLE.Abstractions;
|
||
using Plugin.BLE.Abstractions.Contracts;
|
||
using Plugin.BLE.Abstractions.Exceptions;
|
||
using Polly;
|
||
using Polly.Retry;
|
||
using Serilog;
|
||
using TINK.Model.Connector;
|
||
using TINK.Model.Device;
|
||
using TINK.Services.BluetoothLock.Crypto;
|
||
using TINK.Services.BluetoothLock.Exception;
|
||
using TINK.Services.BluetoothLock.Tdo;
|
||
using Xamarin.Essentials;
|
||
|
||
namespace TINK.Services.BluetoothLock.BLE
|
||
{
|
||
/// <summary> Manages a single lock.</summary>
|
||
public abstract class LockItBase : ILockService
|
||
{
|
||
/// <summary> Lenght of seed in bytes.</summary>
|
||
private const int SEEDLENGTH = 16;
|
||
|
||
/// <summary> Timeout for open/ close operations.</summary>
|
||
protected const int OPEN_CLOSE_TIMEOUT_MS = 30000;
|
||
|
||
/// <summary> Timeout for get service operations.</summary>
|
||
private const int GETSERVICE_TIMEOUT_MS = 3000;
|
||
|
||
/// <summary> Timeout for read operations.</summary>
|
||
private const int READ_TIMEOUT_MS = 3000;
|
||
|
||
protected LockItBase(IDevice device, IAdapter adapter, ICipher cipher)
|
||
{
|
||
Device = device ?? throw new ArgumentException(nameof(device));
|
||
Cipher = cipher ?? throw new ArgumentException(nameof(cipher));
|
||
Adapter = adapter ?? throw new ArgumentException(nameof(adapter));
|
||
|
||
_retryPollicy = Policy<byte[]>
|
||
.Handle<CharacteristicReadException>()
|
||
.WaitAndRetryAsync(2, index => TimeSpan.FromMilliseconds(100));
|
||
|
||
GetGuid();
|
||
GetName();
|
||
|
||
if (InvalidatedSeed.ContainsKey(Guid))
|
||
{
|
||
// Lock was already connected. No need to add entry.
|
||
return;
|
||
}
|
||
|
||
InvalidatedSeed.Add(Guid, new List<string>());
|
||
}
|
||
|
||
private static readonly Dictionary<Guid, List<string>> InvalidatedSeed = new Dictionary<Guid, List<string>>();
|
||
|
||
/// <summary> Count of write- actions to activate lock characteristic..</summary>
|
||
protected int ActivateLockWriteCounter { get; private set; }
|
||
|
||
protected ICipher Cipher { get; }
|
||
|
||
protected IAdapter Adapter { get; }
|
||
|
||
protected IDevice Device { get; }
|
||
|
||
private IService LockControl { get; set; }
|
||
|
||
private IService BatteryControl { get; set; }
|
||
|
||
private ICharacteristic ActivateLockCharacteristic { get; set; }
|
||
|
||
private ICharacteristic AlarmCharacteristic { get; set; }
|
||
|
||
private ICharacteristic AlarmSettingsCharacteristic { get; set; }
|
||
|
||
private ICharacteristic AuthCharacteristic { get; set; }
|
||
|
||
private ICharacteristic StateCharacteristic { get; set; }
|
||
|
||
private ICharacteristic SoundCharacteristic { get; set; }
|
||
|
||
private ICharacteristic BatteryCharacteristic { get; set; }
|
||
|
||
private ICharacteristic FirmwareVersionCharacteristic { get; set; }
|
||
|
||
private readonly AsyncRetryPolicy<byte[]> _retryPollicy;
|
||
|
||
/// <summary> Gets the lock control service.</summary>
|
||
private async Task<IService> GetLockControlService()
|
||
{
|
||
if (LockControl != null) return LockControl;
|
||
|
||
LockControl = null;
|
||
|
||
Log.ForContext<LockItBase>().Debug("Request to get lock control service.");
|
||
|
||
var cts = new CancellationTokenSource();
|
||
cts.CancelAfter(GETSERVICE_TIMEOUT_MS);
|
||
try
|
||
{
|
||
LockControl = await Device.GetServiceAsync(new Guid("0000f00d-1212-efde-1523-785fef13d123"), cts.Token);
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Getting lock control service failed. {Exception}", exception);
|
||
throw new System.Exception($"Can not get lock control service. {exception.Message}", exception);
|
||
}
|
||
finally
|
||
{
|
||
cts.Dispose();
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug("Getting lock control service succeeded.");
|
||
return LockControl;
|
||
}
|
||
|
||
/// <summary> Gets battery service.</summary>
|
||
private async Task<IService> GetBatteryService()
|
||
{
|
||
if (BatteryControl != null) return BatteryControl;
|
||
|
||
BatteryControl = null;
|
||
|
||
Log.ForContext<LockItBase>().Debug("Request to get battery control service.");
|
||
|
||
var cts = new CancellationTokenSource();
|
||
cts.CancelAfter(GETSERVICE_TIMEOUT_MS);
|
||
try
|
||
{
|
||
BatteryControl = await Device.GetServiceAsync(new Guid("0000180F-0000-1000-8000-00805f9b34fb"), cts.Token);
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Getting battery service failed. {Exception}", exception);
|
||
throw new System.Exception($"Can not get battery service. {exception.Message}", exception);
|
||
}
|
||
finally
|
||
{
|
||
cts.Dispose();
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug("Getting battery service succeeded.");
|
||
return BatteryControl;
|
||
}
|
||
|
||
/// <summary> Gets the state characteristic.</summary>
|
||
private async Task<ICharacteristic> GetActivateLockCharacteristicAsync()
|
||
{
|
||
if (ActivateLockCharacteristic != null) return ActivateLockCharacteristic;
|
||
|
||
ActivateLockCharacteristic = null;
|
||
|
||
Log.ForContext<LockItBase>().Debug("Request to get activate lock characteristic.");
|
||
|
||
try
|
||
{
|
||
ActivateLockCharacteristic = await (await GetLockControlService())?.GetCharacteristicAsync(new Guid("0000beee-1212-efde-1523-785fef13d123"));
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Getting activate lock charcteristic failed. {Exception}", exception);
|
||
throw new System.Exception($"Can not get activate characteristic. {exception.Message}", exception);
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug("Activate lock characteristic retrieved successfully.");
|
||
|
||
return ActivateLockCharacteristic;
|
||
}
|
||
|
||
/// <summary> Gets the alarm characteristic.</summary>
|
||
private async Task<ICharacteristic> GetAlarmCharacteristicAsync()
|
||
{
|
||
if (AlarmCharacteristic != null) return AlarmCharacteristic;
|
||
|
||
AlarmCharacteristic = null;
|
||
|
||
Log.ForContext<LockItBase>().Debug("Request to get alarm characteristic.");
|
||
|
||
try
|
||
{
|
||
AlarmCharacteristic = await (await GetLockControlService())?.GetCharacteristicAsync(new Guid("0000BFFF-1212-efde-1523-785fef13d123"));
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Getting alarm-charcteristic failed. {Exception}", exception);
|
||
throw new System.Exception($"Can not get alarm characteristic. {exception.Message}", exception);
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug("Get alarm characteristic retrieved successfully.");
|
||
return AlarmCharacteristic;
|
||
}
|
||
|
||
/// <summary> Gets the alarm settings characteristic.</summary>
|
||
private async Task<ICharacteristic> GetAlarmSettingsCharacteristicAsync()
|
||
{
|
||
if (AlarmSettingsCharacteristic != null) return AlarmSettingsCharacteristic;
|
||
|
||
AlarmSettingsCharacteristic = null;
|
||
|
||
Log.ForContext<LockItBase>().Debug("Request to get alarm settings characteristic.");
|
||
|
||
try
|
||
{
|
||
AlarmSettingsCharacteristic = await (await GetLockControlService())?.GetCharacteristicAsync(new Guid("0000BFFE-1212-efde-1523-785fef13d123"));
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Getting alarm settings charcteristic failed. {Exception}", exception);
|
||
throw new System.Exception($"Can not get alarm settings characteristic. {exception.Message}", exception);
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug("Get alarm settings characteristic retrieved successfully.");
|
||
return AlarmSettingsCharacteristic;
|
||
}
|
||
|
||
/// <summary> Gets the auth characteristic.</summary>
|
||
private async Task<ICharacteristic> GetAuthCharacteristicAsync()
|
||
{
|
||
if (AuthCharacteristic != null) return AuthCharacteristic;
|
||
|
||
AuthCharacteristic = null;
|
||
|
||
Log.ForContext<LockItBase>().Debug("Request to get auth characteristic.");
|
||
try
|
||
{
|
||
AuthCharacteristic = await (await GetLockControlService())?.GetCharacteristicAsync(new Guid("0000baab-1212-efde-1523-785fef13d123"));
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Getting auth-charcteristic failed. {Exception}", exception);
|
||
throw new System.Exception(string.Format("Can not get auth characteristic. {0}", exception.Message), exception);
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug("Get auth characteristic retrieved successfully.");
|
||
return AuthCharacteristic;
|
||
}
|
||
|
||
/// <summary> Gets the state characteristic.</summary>
|
||
protected async Task<ICharacteristic> GetStateCharacteristicAsync()
|
||
{
|
||
if (StateCharacteristic != null) return StateCharacteristic;
|
||
|
||
StateCharacteristic = null;
|
||
|
||
Log.ForContext<LockItBase>().Debug("Request to get lock state characteristic.");
|
||
try
|
||
{
|
||
StateCharacteristic = await (await GetLockControlService())?.GetCharacteristicAsync(new Guid("0000baaa-1212-efde-1523-785fef13d123"));
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Getting state charcteristic failed. {Exception}", exception);
|
||
throw new System.Exception(string.Format("Can not get state characteristic. {0}", exception.Message), exception);
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug("Get state characteristic retrieved successfully.");
|
||
return StateCharacteristic;
|
||
}
|
||
|
||
/// <summary> Gets the sound characteristic.</summary>
|
||
private async Task<ICharacteristic> GetSoundCharacteristicAsync()
|
||
{
|
||
if (SoundCharacteristic != null) return SoundCharacteristic;
|
||
|
||
SoundCharacteristic = null;
|
||
|
||
Log.ForContext<LockItBase>().Debug("Request to get sound characteristic.");
|
||
try
|
||
{
|
||
SoundCharacteristic = await (await GetLockControlService())?.GetCharacteristicAsync(new Guid("0000BAAE-1212-efde-1523-785fef13d123"));
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Getting sound charcteristic failed. {Exception}", exception);
|
||
throw new System.Exception($"Can not get sound characteristic. {exception.Message}", exception);
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug("Get sound characteristic retrieved successfully.");
|
||
return SoundCharacteristic;
|
||
}
|
||
|
||
/// <summary> Gets the battery characteristic.</summary>
|
||
protected async Task<ICharacteristic> GetBatteryCharacteristicAsync()
|
||
{
|
||
if (BatteryCharacteristic != null) return BatteryCharacteristic;
|
||
|
||
BatteryCharacteristic = null;
|
||
|
||
Log.ForContext<LockItBase>().Debug("Request to get battery characteristic.");
|
||
try
|
||
{
|
||
BatteryCharacteristic = await (await GetBatteryService())?.GetCharacteristicAsync(new Guid("00002a19-0000-1000-8000-00805f9b34fb"));
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Getting battery charcteristic failed. {Exception}", exception);
|
||
throw new System.Exception($"Can not get battery characteristic. {exception.Message}", exception);
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug("Get battery characteristic retrieved successfully.");
|
||
return BatteryCharacteristic;
|
||
}
|
||
|
||
/// <summary> Gets the versions info characteristic.</summary>
|
||
protected async Task<ICharacteristic> GetVersionsCharacteristicAsync()
|
||
{
|
||
if (FirmwareVersionCharacteristic != null) return FirmwareVersionCharacteristic ;
|
||
|
||
FirmwareVersionCharacteristic = null;
|
||
|
||
Log.ForContext<LockItBase>().Debug("Request to get versions info characteristic.");
|
||
try
|
||
{
|
||
FirmwareVersionCharacteristic = await (await GetLockControlService())?.GetCharacteristicAsync(new Guid("0000baad-1212-efde-1523-785fef13d123"));
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Getting versions info charcteristic failed. {Exception}", exception);
|
||
throw new System.Exception(string.Format("Can not get versions info characteristic. {0}", exception.Message), exception);
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug("Get versions info characteristic retrieved successfully.");
|
||
return FirmwareVersionCharacteristic ;
|
||
}
|
||
/// <summary> Query name of lock.</summary>
|
||
private void GetName()
|
||
{
|
||
if (!string.IsNullOrEmpty(Name))
|
||
{
|
||
// Prevent valid name to be queried more than twice because Name does not change.
|
||
return;
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug("Query name of lock.");
|
||
try
|
||
{
|
||
Name = Device.Name ?? string.Empty;
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Retrieving bluetooth name failed . {Exception}", exception);
|
||
throw new System.Exception($"Can not get name of lock. {exception.Message}", exception);
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug($"Lock name is {Name}.");
|
||
Id = Name.GetBluetoothLockId();
|
||
return;
|
||
}
|
||
|
||
/// <summary> Full idvertisement name.</summary>
|
||
public string Name { get; private set; } = string.Empty;
|
||
|
||
/// <summary> Id part of idvertisement name.</summary>
|
||
public int Id { get; private set; }
|
||
|
||
/// <summary> Query GUID of lock.</summary>
|
||
private void GetGuid()
|
||
{
|
||
if (Guid != TextToLockItTypeHelper.INVALIDLOCKGUID)
|
||
{
|
||
// Prevent valid GUID to be queried more than twice because GUID does not change.
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug("Query name of lock.");
|
||
try
|
||
{
|
||
Guid = Device.Id;
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Retrieving bluetooth guid failed. {Exception}", exception);
|
||
throw new System.Exception($"Can not get guid of lock. {exception.Message}", exception);
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug($"Lock GUID is {Guid}.");
|
||
}
|
||
|
||
/// <summary> GUID.</summary>
|
||
public Guid Guid { get; private set; } = TextToLockItTypeHelper.INVALIDLOCKGUID;
|
||
|
||
private byte[] CopriKey { get; set; } = new byte[0];
|
||
|
||
/// <summary> Gets the device state.</summary>
|
||
public DeviceState? GetDeviceState()
|
||
{
|
||
if (DeviceInfo.Platform != DevicePlatform.Unknown && MainThread.IsMainThread == false)
|
||
{
|
||
throw new System.Exception("Can not get device state. Platform must not be unknown and bluetooth code must be run on main thread.");
|
||
}
|
||
|
||
DeviceState? state;
|
||
Log.ForContext<LockItBase>().Debug("Request to get connection state.");
|
||
try
|
||
{
|
||
state = Device?.State.GetDeviceState()
|
||
?? throw new System.Exception("Can not get bluetooth device state. State must not be null.");
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Retrieving bluetooth state failed. {Exception}", exception);
|
||
throw new System.Exception($"Can not get bluetooth state. {exception.Message}", exception);
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug($"Connection state is {state}.");
|
||
return state;
|
||
}
|
||
|
||
/// <summary> Reconnects to device. </summary>
|
||
/// <remarks> Consists of a bluetooth connect plus invocation of an authentication sequence. </remarks>
|
||
/// <param name="authInfo">Info required to connect.</param>
|
||
/// <param name="connectTimeout">Timeout to apply when connecting to bluetooth lock.</param>
|
||
/// <returns>True if connecting succeeded, false if not.</returns>
|
||
public abstract Task ReconnectAsync(
|
||
LockInfoAuthTdo authInfo,
|
||
TimeSpan connectTimeout);
|
||
|
||
/// <summary> Reconnects to device. </summary>
|
||
/// <remarks> Consists of a bluetooth connect plus invocation of an authentication sequence. </remarks>
|
||
/// <param name="authInfo">Info required to connect.</param>
|
||
/// <param name="connectTimeout">Timeout to apply when connecting to bluetooth lock.</param>
|
||
/// <returns>True if connecting succeeded, false if not.</returns>
|
||
protected async Task ReconnectAsync(
|
||
LockInfoAuthTdo authInfo,
|
||
TimeSpan connectTimeout,
|
||
Func<LockItBase> factory)
|
||
{
|
||
if (DeviceInfo.Platform != DevicePlatform.Unknown && MainThread.IsMainThread == false)
|
||
{
|
||
throw new System.Exception("Can not reconnect to lock. Platform must not be unknown and bluetooth code must be run on main thread.");
|
||
}
|
||
|
||
// Check if key is available.
|
||
if (authInfo == null)
|
||
{
|
||
Log.ForContext<LockItBase>().Error($"Can not authenticate. No auth info available.");
|
||
throw new AuthKeyException($"Can not authenticate. No auth info available.");
|
||
}
|
||
|
||
if (authInfo.K_seed.Length != SEEDLENGTH
|
||
|| authInfo.K_u.Length <= 0)
|
||
{
|
||
throw new AuthKeyException($"Can not authenticate. Invalid seed-/ k-user-lenght {authInfo.K_seed.Length}/ {authInfo.K_u.Length} detected.");
|
||
}
|
||
|
||
if (Device.State == Plugin.BLE.Abstractions.DeviceState.Connected)
|
||
{
|
||
throw new AlreadyConnectedException();
|
||
}
|
||
|
||
// Reset all references to characteristics.
|
||
LockControl = null;
|
||
ActivateLockCharacteristic = null;
|
||
AlarmCharacteristic = null;
|
||
AlarmSettingsCharacteristic = null;
|
||
AuthCharacteristic = null;
|
||
StateCharacteristic = null;
|
||
SoundCharacteristic = null;
|
||
ActivateLockWriteCounter = 0;
|
||
|
||
var cts = new CancellationTokenSource(connectTimeout);
|
||
|
||
// Connect to device and authenticate.
|
||
Log.ForContext<LockItBase>().Debug($"Request connect to device {Device.Name}. Connect state is {Device.State}.");
|
||
try
|
||
{
|
||
await Adapter.ConnectToDeviceAsync(
|
||
Device,
|
||
new ConnectParameters(forceBleTransport: true /* Force BLE transport */),
|
||
cts.Token);
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
if (exception is TaskCanceledException)
|
||
{
|
||
// A timeout occurred.
|
||
throw new System.Exception($"Can not reconnect.\r\nTimeout of {connectTimeout.TotalMilliseconds} [ms] elapsed.", exception);
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Error("Can not reconnect. {Exception}", exception);
|
||
throw new System.Exception($"Can not Reconnect. {exception.Message}", exception);
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug($"Connecting to device succeeded. Starting auth sequence...");
|
||
|
||
var lockIt = await Authenticate(Device, authInfo, Adapter, Cipher, factory);
|
||
CopriKey = lockIt.CopriKey;
|
||
}
|
||
|
||
/// <summary> Connects to device. </summary>
|
||
/// <param name="authInfo">Info required to connect.</param>
|
||
/// <param name="device">Device with must be connected.</param>
|
||
/// <returns>True if connecting succeeded, false if not.</returns>
|
||
protected static async Task<LockItBase> Authenticate(
|
||
IDevice device,
|
||
LockInfoAuthTdo authInfo,
|
||
IAdapter adapter,
|
||
ICipher cipher,
|
||
Func<LockItBase> factory)
|
||
{
|
||
if (DeviceInfo.Platform != DevicePlatform.Unknown && MainThread.IsMainThread == false)
|
||
{
|
||
throw new System.Exception("Can not authenticate. Platform must not be unknown and bluetooth code must be run on main thread.");
|
||
}
|
||
|
||
if (device == null)
|
||
throw new ArgumentException(nameof(device));
|
||
|
||
if (cipher == null)
|
||
throw new ArgumentException(nameof(cipher));
|
||
|
||
if (adapter == null)
|
||
throw new ArgumentException(nameof(adapter));
|
||
|
||
// Check if connect is required.
|
||
DeviceState deviceState;
|
||
Log.ForContext<LockItBase>().Debug("Retrieving connection state is in context of auth.");
|
||
try
|
||
{
|
||
deviceState = device?.State.GetDeviceState()
|
||
?? throw new System.Exception("Can not get bluetooth device state. State must not be null.");
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Can not authenticate. Retrieving bluetooth state failed. {Exception}", exception);
|
||
throw new System.Exception(string.Format("Can not authenticate. Getting bluetooth state failed. {0}", exception.Message), exception);
|
||
}
|
||
|
||
switch (deviceState)
|
||
{
|
||
case DeviceState.Disconnected:
|
||
throw new BluetoothDisconnectedException();
|
||
|
||
case DeviceState.Connected:
|
||
break;
|
||
|
||
default:
|
||
// Can not get state if device is not connected.
|
||
Log.ForContext<LockItBase>().Error($"Can not authenticate. Unexpected lock state {deviceState} detected.");
|
||
throw new System.Exception(string.Format("Can not authenticate. Unexpected bluetooth state {0} detected.", deviceState));
|
||
}
|
||
|
||
// Check if key is available.
|
||
if (authInfo == null)
|
||
{
|
||
Log.ForContext<LockItBase>().Error($"Can not authenticate. No auth info available.");
|
||
throw new AuthKeyException($"Can not authenticate. No auth info available.");
|
||
}
|
||
|
||
if (authInfo.K_seed.Length != SEEDLENGTH
|
||
|| authInfo.K_u.Length <= 0)
|
||
{
|
||
throw new AuthKeyException($"Can not authenticate. Invalid seed-/ k-user-lenght {authInfo.K_seed.Length}/ {authInfo.K_u.Length} detected.");
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug($"Connection state is {deviceState} in context of auth.");
|
||
|
||
var lockIt = factory();
|
||
|
||
if (InvalidatedSeed[lockIt.Guid].Contains(string.Join(",", authInfo.K_seed)))
|
||
{
|
||
throw new AuthKeyException($"Can not authenticate. Seed {string.Join(",", authInfo.K_seed)} was already used.");
|
||
}
|
||
|
||
InvalidatedSeed[lockIt.Guid].Add(string.Join(",", authInfo.K_seed));
|
||
|
||
// Connect to device and authenticate.
|
||
try
|
||
{
|
||
await AuthenticateAsync(
|
||
lockIt,
|
||
authInfo,
|
||
lockIt.Cipher);
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Authentication failed. {Exception}", exception);
|
||
try
|
||
{
|
||
// Disconnect from device if auth did not succeed.
|
||
await lockIt.Adapter.DisconnectDeviceAsync(lockIt.Device);
|
||
}
|
||
catch (System.Exception exceptionInner)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Authentication failed. Disconnect throw an exception. {Exception}", exceptionInner);
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Error($"Auth failed for device name={lockIt.Name}, GUID={lockIt.Guid}.");
|
||
|
||
throw;
|
||
}
|
||
|
||
lockIt.CopriKey = authInfo.K_u;
|
||
|
||
Log.ForContext<LockItBase>().Debug($"Auth succeeded for device name={lockIt.Name}, GUID={lockIt.Guid}, state={lockIt.GetDeviceState()}.");
|
||
return lockIt;
|
||
}
|
||
|
||
/// <summary> Performs an authentication.</summary>
|
||
private static async Task AuthenticateAsync(
|
||
LockItBase lockIt,
|
||
LockInfoAuthTdo lockInfo,
|
||
ICipher cipher)
|
||
{
|
||
Log.ForContext<LockItBase>().Debug($"Request to autenticate for {lockIt.Name}.");
|
||
|
||
var authCharacteristic = await lockIt.GetAuthCharacteristicAsync();
|
||
if (authCharacteristic == null)
|
||
{
|
||
Log.ForContext<LockItBase>().Debug("Getting auth-charcteristic failed.");
|
||
throw new CoundntGetCharacteristicException("Authentication failed. Auth characteristic must not be null.");
|
||
}
|
||
|
||
bool success;
|
||
|
||
try
|
||
{
|
||
success = await authCharacteristic.WriteAsync(lockInfo.K_seed);
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Writing copri seed failed.{AuthCharacteristic}{CommandWritten}{Exception}", ToSerilogString(authCharacteristic), ToSerilogString(lockInfo.K_seed), exception);
|
||
throw new System.Exception(string.Format("Can not authenticate. Writing copri seed failed. {0}", exception.Message), exception);
|
||
}
|
||
if (!success)
|
||
{
|
||
Log.ForContext<LockItBase>().Debug("Writing copri seed failed.{AuthCharacteristic}{CommandWritten}", ToSerilogString(authCharacteristic), ToSerilogString(lockInfo.K_seed));
|
||
throw new System.Exception("Can not authenticate. Writing copri seed did not succeed.");
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug("Copri seed written successfully.{AuthCharacteristic}{CommandWritten}.", ToSerilogString(authCharacteristic), ToSerilogString(lockInfo.K_seed));
|
||
|
||
byte[] seedLockEncrypted;
|
||
var cts = new CancellationTokenSource();
|
||
cts.CancelAfter(READ_TIMEOUT_MS);
|
||
try
|
||
{
|
||
seedLockEncrypted = await authCharacteristic.ReadAsync(cts.Token); // encrypted seed value (random value) from lock to decypt using k_user
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Retrieveing encrypted random value from lock (seed)(ReadAsync-call) failed.{ReadCharacteristic}{Exception}", ToSerilogString(authCharacteristic), exception);
|
||
throw new System.Exception(string.Format("Can not authenticate. Reading encrypted seed failed. {0}", exception.Message), exception);
|
||
}
|
||
finally
|
||
{
|
||
cts.Dispose();
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug("Retrieveing encrypted random value from lock (seed)(ReadAsync-call) succeeded.{ReadCharacteristic}{Reading}", ToSerilogString(authCharacteristic), "***");
|
||
|
||
var crypto = new AuthCryptoHelper(
|
||
seedLockEncrypted,
|
||
lockInfo.K_u,
|
||
cipher);
|
||
|
||
byte[] accessKeyEncrypted;
|
||
try
|
||
{
|
||
accessKeyEncrypted = crypto.GetAccessKeyEncrypted();
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Error getting encrypted access key. {Exception}", exception);
|
||
throw new System.Exception(string.Format("Can not authenticate. Getting access key failed. {0}", exception.Message), exception);
|
||
}
|
||
|
||
try
|
||
{
|
||
success = await authCharacteristic.WriteAsync(accessKeyEncrypted);
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Writing encrypted access key failed.{Key}{Seed}{AuthCharacteristic}{CommandWritten}{Exception}", ToSerilogString(crypto.KeyCopri), ToSerilogString(lockInfo.K_seed), ToSerilogString(authCharacteristic), ToSerilogString(accessKeyEncrypted), exception);
|
||
throw new System.Exception(string.Format("Can not authenticate. Writing access key failed. {0}", exception.Message), exception);
|
||
}
|
||
if (!success)
|
||
{
|
||
Log.ForContext<LockItBase>().Debug("Writing encrypted access key failed.{Key}{Seed}{AuthCharacteristic}{CommandWritten}", ToSerilogString(crypto.KeyCopri), ToSerilogString(lockInfo.K_seed), ToSerilogString(authCharacteristic), "***");
|
||
throw new System.Exception(string.Format("Can not authenticate. Writing access key did not succeed."));
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug("Encrypted access key written successfully.{Key}{Seed}{AuthCharacteristic}{CommandWritten}", ToSerilogString(crypto.KeyCopri), ToSerilogString(lockInfo.K_seed), ToSerilogString(authCharacteristic), "***");
|
||
}
|
||
|
||
/// <summary> Gets the lock state like locking state (open/ close). </summary>
|
||
/// <param name="doWaitRetry">True if to wait and retry in case of failures. </param>
|
||
/// <remarks>
|
||
/// Lock state is first byte of of value read from state characteristic ("0000baaa-1212-efde-1523-785fef13d123").
|
||
/// Values are as follows
|
||
/// Open = 0x00,
|
||
/// Closed = 0x01,
|
||
/// Unknown = 0x02,
|
||
/// CouldntCloseMoving = 0x03,
|
||
/// CouldntOpenBoldBlocked = 0x04,
|
||
/// CouldntCloseBoldBlocked = 0x05
|
||
/// TINK.Services.BluetoothLock.Tdo.LockitLockingState.
|
||
/// </remarks>
|
||
/// <returns> Lock state.</returns>
|
||
/// <exception cref="BluetoothDisconnectedException">App is not connected to lock.</exception>
|
||
/// <exception cref="CoundntGetCharacteristicException">Getting state characteristic to read from failed.</exception>
|
||
/// <exception cref="Exception">
|
||
/// Call not from main thread or unkonwn platform detected or
|
||
/// query device state (connected, disconnected, ....) failed for an unknown reason or returned an unexpected value or
|
||
/// reading state characteristic failed or reading from characteristic was empty.
|
||
/// </exception>
|
||
/// <exception> Exceptions thrown by PluginBle::ICharacteristic.ReasAsync.</exception>
|
||
public async Task<LockInfoTdo> GetLockStateAsync(bool doWaitRetry = false)
|
||
{
|
||
if (DeviceInfo.Platform != DevicePlatform.Unknown && MainThread.IsMainThread == false)
|
||
{
|
||
throw new System.Exception("Can not get lock state. Platform must not be unknown and bluetooth code must be run on main thread.");
|
||
}
|
||
|
||
DeviceState? deviceState;
|
||
Log.ForContext<LockItBase>().Debug("Request to get connection state in context of getting locking state.");
|
||
try
|
||
{
|
||
deviceState = Device?.State.GetDeviceState()
|
||
?? throw new System.Exception("Can not get bluetooth device state. State must not be null.");
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Can not get lock state. Retrieving bluetooth state failed. {Exception}", exception);
|
||
throw new System.Exception(string.Format("Can not get lock state. Getting bluetooth state failed. {0}", exception.Message), exception);
|
||
}
|
||
|
||
switch (deviceState)
|
||
{
|
||
case DeviceState.Disconnected:
|
||
throw new BluetoothDisconnectedException();
|
||
|
||
case DeviceState.Connected:
|
||
break;
|
||
|
||
default:
|
||
// Can not get state if device is not connected.
|
||
Log.ForContext<LockItBase>().Error($"Getting lock state failed. Unexpected lock state {deviceState} detected.");
|
||
throw new System.Exception(string.Format("Can not get lock state. Unexpected bluetooth state {0} detected.", deviceState));
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug($"Connection state is {deviceState}.");
|
||
|
||
var stateCharacteristic = await GetStateCharacteristicAsync();
|
||
if (stateCharacteristic == null)
|
||
{
|
||
Log.ForContext<LockItBase>().Error($"Can not get lock state. State characteristic is not available.");
|
||
throw new CoundntGetCharacteristicException("Can not get lock state. State characteristic must not be null.");
|
||
}
|
||
|
||
byte[] state;
|
||
async Task<byte[]> readAsyncDelegate()
|
||
{
|
||
var cts = new CancellationTokenSource();
|
||
cts.CancelAfter(READ_TIMEOUT_MS);
|
||
try
|
||
{
|
||
return await stateCharacteristic.ReadAsync(cts.Token);
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Retrieving lock state (ReadAsync-call) failed inside delegate.{StateCharacteristic}{Exception}", ToSerilogString(stateCharacteristic), exception);
|
||
throw;
|
||
}
|
||
finally
|
||
{
|
||
cts.Dispose();
|
||
}
|
||
}
|
||
|
||
try
|
||
{
|
||
state = doWaitRetry
|
||
? await _retryPollicy.ExecuteAsync(async () => await readAsyncDelegate())
|
||
: await readAsyncDelegate();
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Retrieving lock state (ReadAsync-call) failed.{StateCharacteristic}{Exception}", ToSerilogString(stateCharacteristic), exception);
|
||
throw new System.Exception(string.Format("Can not get lock state. Reading data failed. {0}", exception.Message), exception);
|
||
}
|
||
if (state == null || state.Length <= 0)
|
||
{
|
||
Log.ForContext<LockItBase>().Debug("Retrieving lock state (ReadAsync-call) failed. Data read is null or empty.{StateCharacteristic}", ToSerilogString(stateCharacteristic));
|
||
throw new System.Exception("Can not get lock state. No data read");
|
||
}
|
||
|
||
var lockInfoTdo = new LockInfoTdo.Builder
|
||
{
|
||
Id = Id,
|
||
Guid = Guid,
|
||
State = (LockitLockingState?)state[0]
|
||
}.Build();
|
||
|
||
Log.ForContext<LockItBase>().Debug("Retrieving lock state (ReadAsync-call) succeeded. {@LockInfoTdo}{StateCharacteristic}{Reading}",
|
||
lockInfoTdo,
|
||
ToSerilogString(stateCharacteristic),
|
||
state);
|
||
|
||
return lockInfoTdo;
|
||
}
|
||
|
||
/// <summary>Gets the battery percentage.</summary>
|
||
public async Task<double> GetBatteryPercentageAsync()
|
||
{
|
||
if (DeviceInfo.Platform != DevicePlatform.Unknown && MainThread.IsMainThread == false)
|
||
{
|
||
throw new System.Exception("Can not get battery percentage. Platform must not be unknown and bluetooth code must be run on main thread.");
|
||
}
|
||
|
||
DeviceState? deviceState;
|
||
Log.ForContext<LockItBase>().Debug("Request to get battery percentage in context of getting locking state.");
|
||
try
|
||
{
|
||
deviceState = Device?.State.GetDeviceState()
|
||
?? throw new System.Exception("Can not get bluetooth device state. State must not be null.");
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Can not get battery percentage. Retrieving bluetooth state failed. {Exception}", exception);
|
||
throw new System.Exception(string.Format("Can not get battery percentage. Getting bluetooth state failed. {0}", exception.Message), exception);
|
||
}
|
||
|
||
switch (deviceState)
|
||
{
|
||
case DeviceState.Disconnected:
|
||
throw new BluetoothDisconnectedException();
|
||
|
||
case DeviceState.Connected:
|
||
break;
|
||
|
||
default:
|
||
// Can not get state if device is not connected.
|
||
Log.ForContext<LockItBase>().Error($"Getting battery percentage failed. Unexpected battery percentage {deviceState} detected.");
|
||
throw new System.Exception(string.Format("Can not get battery percentage. Unexpected bluetooth state {0} detected.", deviceState));
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug($"Connection state is {deviceState}.");
|
||
|
||
var batteryCharacteristic = await GetBatteryCharacteristicAsync();
|
||
if (batteryCharacteristic == null)
|
||
{
|
||
Log.ForContext<LockItBase>().Error($"Can not get battery percentage. State characteristic is not available.");
|
||
throw new CoundntGetCharacteristicException("Can not get battery percentage. State characteristic must not be null.");
|
||
}
|
||
|
||
byte[] percentage;
|
||
var cts = new CancellationTokenSource();
|
||
cts.CancelAfter(READ_TIMEOUT_MS);
|
||
try
|
||
{
|
||
percentage = await batteryCharacteristic.ReadAsync(cts.Token);
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Retrieving charging level (ReadAsync-call) failed. {BatteryCharacteristic}{Exception}", ToSerilogString(batteryCharacteristic), exception);
|
||
throw new System.Exception(string.Format("Can not get battery percentage. Reading data failed. {0}", exception.Message), exception);
|
||
}
|
||
finally
|
||
{
|
||
cts.Dispose();
|
||
}
|
||
|
||
if (percentage == null || percentage.Length <= 0)
|
||
{
|
||
Log.ForContext<LockItBase>().Debug("Retrieving charging level (ReadAsync-call) failed. Data read is null or empty.{BatteryCharacteristic}", ToSerilogString(batteryCharacteristic));
|
||
throw new System.Exception("Can not get battery percentage. No data read.");
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug("Retrieving charging level (ReadAsync-call) succeeded.{Level}{BatteryCharacteristic}{Reading}", percentage[0], ToSerilogString(batteryCharacteristic), percentage);
|
||
|
||
return percentage[0];
|
||
}
|
||
|
||
/// <summary> Gets version info about the lock. </summary>
|
||
/// <remarks>
|
||
/// Lock state is first byte of of value read from state characteristic ("0000baaa-1212-efde-1523-785fef13d123").
|
||
/// Values are as follows
|
||
/// Byte number 0: firmware version,
|
||
/// Byte number 1: lock version (2 – classic, 3 – plus, 4 – GPS)
|
||
/// Byte number 2: hardware version,
|
||
/// </remarks>
|
||
/// <returns> .</returns>
|
||
public async Task<VersionInfoTdo> GetVersionInfoAsync()
|
||
{
|
||
if (DeviceInfo.Platform != DevicePlatform.Unknown && MainThread.IsMainThread == false)
|
||
{
|
||
throw new System.Exception("Can not get versions info. Platform must not be unknown and bluetooth code must be run on main thread.");
|
||
}
|
||
|
||
DeviceState? deviceState;
|
||
Log.ForContext<LockItBase>().Debug("Request to get connection state in context of getting versions info.");
|
||
try
|
||
{
|
||
deviceState = Device?.State.GetDeviceState()
|
||
?? throw new System.Exception("Can not get bluetooth device state. State must not be null.");
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Can not get versions info. Retrieving bluetooth state failed. {Exception}", exception);
|
||
throw new System.Exception(string.Format("Can not get versions info. Getting bluetooth state failed. {0}", exception.Message), exception);
|
||
}
|
||
|
||
switch (deviceState)
|
||
{
|
||
case DeviceState.Disconnected:
|
||
throw new BluetoothDisconnectedException();
|
||
|
||
case DeviceState.Connected:
|
||
break;
|
||
|
||
default:
|
||
// Can not get state if device is not connected.
|
||
Log.ForContext<LockItBase>().Error($"Getting versions info failed. Unexpected versions info {deviceState} detected.");
|
||
throw new System.Exception(string.Format("Can not get versions info. Unexpected bluetooth state {0} detected.", deviceState));
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug($"Connection state is {deviceState}.");
|
||
|
||
var firmwareVersionCharacteristic = await GetVersionsCharacteristicAsync();
|
||
if (firmwareVersionCharacteristic == null)
|
||
{
|
||
Log.ForContext<LockItBase>().Error($"Can not get versions info. versions info characteristic is not available.");
|
||
throw new CoundntGetCharacteristicException("Can not get versions info. versions info characteristic must not be null.");
|
||
}
|
||
|
||
byte[] version;
|
||
var cts = new CancellationTokenSource();
|
||
cts.CancelAfter(READ_TIMEOUT_MS);
|
||
try
|
||
{
|
||
version = await firmwareVersionCharacteristic.ReadAsync(cts.Token);
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Retrieving versions info (ReadAsync-call) failed inside delegate.{StateCharacteristic}{Exception}", ToSerilogString(firmwareVersionCharacteristic), exception);
|
||
throw;
|
||
}
|
||
finally
|
||
{
|
||
cts.Dispose();
|
||
}
|
||
|
||
if (version == null || version.Length <= 0)
|
||
{
|
||
Log.ForContext<LockItBase>().Debug("Retrieving versions info (ReadAsync-call) failed. Data read is null or empty.{StateCharacteristic}", ToSerilogString(firmwareVersionCharacteristic));
|
||
throw new System.Exception("Can not get versions info. No data read");
|
||
}
|
||
|
||
VersionInfo = new VersionInfoTdo.Builder
|
||
{
|
||
FirmwareVersion = version[0],
|
||
LockVersion = version[1],
|
||
HardwareVersion = version[2]
|
||
}.Build();
|
||
|
||
Log.ForContext<LockItBase>().Debug("Retrieving versions info (ReadAsync-call) succeeded. {@LockInfoTdo}{StateCharacteristic}{Reading}",
|
||
VersionInfo,
|
||
ToSerilogString(firmwareVersionCharacteristic),
|
||
version);
|
||
|
||
return VersionInfo;
|
||
}
|
||
|
||
public VersionInfoTdo VersionInfo { get; private set; }
|
||
|
||
/// <summary> Opens lock. </summary>
|
||
/// <returns> Locking state.</returns>
|
||
public abstract Task<LockitLockingState?> OpenAsync();
|
||
|
||
/// <summary> Close the lock.</summary>
|
||
/// <returns>Locking state.</returns>
|
||
public abstract Task<LockitLockingState?> CloseAsync();
|
||
|
||
/// <summary> Opens/ closes lock.</summary>
|
||
/// <param name="counter"></param>
|
||
/// <param name="open"></param>
|
||
/// <returns>True if opening/ closing command could be written successfully.</returns>
|
||
protected async Task<bool> OpenCloseLockAsync(bool open)
|
||
{
|
||
DeviceState deviceState;
|
||
Log.ForContext<LockItBase>().Debug(open
|
||
? "Request to get connection state in context of opening lock."
|
||
: "Request to get connection state in context of closing lock.");
|
||
try
|
||
{
|
||
deviceState = Device?.State.GetDeviceState()
|
||
?? throw new System.Exception(open
|
||
? "Can not open lock. Getting bluetooth device state failed. State must not be null."
|
||
: "Can not close lock. Getting bluetooth device state failed. State must not be null.");
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error(open
|
||
? "Retrieving bluetooth state failed when opening lock failed. {Exception}"
|
||
: "Retrieving bluetooth state failed when closing lock failed. {Exception}",
|
||
exception);
|
||
throw new System.Exception(open
|
||
? $"Can not open lock. Getting bluetooth failed. {exception.Message}"
|
||
: $"Can not close lock. Getting bluetooth failed. {exception.Message}",
|
||
exception);
|
||
}
|
||
|
||
switch (deviceState)
|
||
{
|
||
case DeviceState.Disconnected:
|
||
throw new BluetoothDisconnectedException();
|
||
|
||
case DeviceState.Connected:
|
||
break;
|
||
|
||
default:
|
||
// Can not open lock if bluetooth state is not connected.
|
||
Log.ForContext<LockItBase>().Debug(open
|
||
? $"Can not open lock. Unexpected connection state detected {deviceState}."
|
||
: $"Can not close lock. Unexpected connection state detected {deviceState}.");
|
||
return false;
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug(open
|
||
? $"Connection state before opening lock is {deviceState}."
|
||
: $"Connection state before closing lock is {deviceState}.");
|
||
|
||
var activateLockCharacteristic = await GetActivateLockCharacteristicAsync();
|
||
if (activateLockCharacteristic == null)
|
||
{
|
||
Log.ForContext<LockItBase>().Debug(open
|
||
? "Can not open lock. Getting lock control service failed."
|
||
: "Can not close lock. Getting lock control service failed.");
|
||
return false;
|
||
}
|
||
|
||
byte[] state = bitShift(
|
||
new byte[] { 0, 0, open ? (byte)1 : (byte)2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
|
||
++ActivateLockWriteCounter);
|
||
|
||
byte[] stateEnctryped;
|
||
try
|
||
{
|
||
stateEnctryped = Cipher.Encrypt(CopriKey, state);
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
ActivateLockWriteCounter--;
|
||
Log.ForContext<LockItBase>().Error(open
|
||
? "Encypting command to open lock failed. {Exception}"
|
||
: "Encypting command to close lock failed. {Exception}",
|
||
exception);
|
||
throw new System.Exception(open
|
||
? $"Can not open lock. Encrypting command to lock/ unlock failed. {exception.Message}"
|
||
: $"Can not close lock. Encrypting command to lock/ unlock failed. {exception.Message}",
|
||
exception);
|
||
}
|
||
|
||
bool success;
|
||
try
|
||
{
|
||
success = await activateLockCharacteristic.WriteAsync(stateEnctryped);
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
ActivateLockWriteCounter--;
|
||
Log.ForContext<LockItBase>().Error(open
|
||
? "Writing data to open lock failed.{ActivateLockCharacteristic}{CommandWritten}{Exception}"
|
||
: "Writing data to close lock failed.{ActivateLockCharacteristic}{CommandWritten}{Exception}",
|
||
ToSerilogString(activateLockCharacteristic),
|
||
ToSerilogString(stateEnctryped),
|
||
exception);
|
||
throw new System.Exception(open
|
||
? $"Can not open lock. Writing command failed. {exception.Message}"
|
||
: $"Can not close lock. Writing command failed. {exception.Message}",
|
||
exception);
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug(open
|
||
? "Command to open lock written successfully.{ActivateLockCharacteristic}{CommandWritten}"
|
||
: "Command to close lock written successfully.{ActivateLockCharacteristic}{CommandWritten}",
|
||
ToSerilogString(activateLockCharacteristic),
|
||
ToSerilogString(stateEnctryped));
|
||
|
||
return success;
|
||
}
|
||
|
||
/// <summary> Gets a value indicating whether alarm is on or off.</summary>
|
||
public async Task<bool> GetIsAlarmOffAsync()
|
||
{
|
||
if (DeviceInfo.Platform != DevicePlatform.Unknown && MainThread.IsMainThread == false)
|
||
{
|
||
throw new System.Exception("Can not turn alarm off. Platform must not be unknown and bluetooth code must be run on main thread.");
|
||
}
|
||
|
||
var alarmCharacteristic = await GetAlarmCharacteristicAsync();
|
||
if (alarmCharacteristic == null)
|
||
{
|
||
Log.ForContext<LockItBase>().Debug("Getting alarm characteristic failed.");
|
||
throw new System.Exception($"Can not get alarm whether alarm is on or off. Getting alarm characteristic returned null.");
|
||
}
|
||
|
||
byte[] alarmSettings;
|
||
var cts = new CancellationTokenSource();
|
||
cts.CancelAfter(READ_TIMEOUT_MS);
|
||
try
|
||
{
|
||
alarmSettings = await alarmCharacteristic.ReadAsync(cts.Token);
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Retrieving alarm settings (ReadAsync-call) failed.{AlarmCharacteristic}{Exception}", ToSerilogString(alarmCharacteristic), exception);
|
||
throw new System.Exception($"Can not get whether alarm is off or on {exception.Message}.");
|
||
}
|
||
finally
|
||
{
|
||
cts.Dispose();
|
||
}
|
||
|
||
if (alarmSettings == null || alarmSettings.Length < 1)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Retrieving alarm settings (ReadAsync-call) failed.{AlarmCharacteristic}{Reading}", ToSerilogString(alarmCharacteristic));
|
||
throw new System.Exception("Can not get whether alarm is off or on. Reading failed.");
|
||
}
|
||
|
||
var isAlarmOff = alarmSettings[0] == 0;
|
||
Log.ForContext<LockItBase>().Debug("Retrieving alarm settings (ReadAsync-call) succeeded.{IsArlarmOff}{AlarmCharacteristic}{Reading}", isAlarmOff, ToSerilogString(alarmCharacteristic), alarmSettings);
|
||
return isAlarmOff;
|
||
}
|
||
|
||
/// <summary> Sets alarm on or off.</summary>
|
||
public async Task SetIsAlarmOffAsync(bool isActivated)
|
||
{
|
||
if (DeviceInfo.Platform != DevicePlatform.Unknown && MainThread.IsMainThread == false)
|
||
{
|
||
throw new System.Exception("Can not turn alarm off. Platform must not be unknown and bluetooth code must be run on main thread.");
|
||
}
|
||
|
||
ICharacteristic alarmCharacteristic = await GetAlarmCharacteristicAsync();
|
||
if (alarmCharacteristic == null)
|
||
{
|
||
Log.ForContext<LockItBase>().Debug("Getting alarm characteristic failed.");
|
||
throw new System.Exception($"Can not set alarm {isActivated}. Getting alarm characteristic returned null.");
|
||
}
|
||
|
||
bool success;
|
||
var command = new byte[] { isActivated ? (byte)1 : (byte)0 };
|
||
try
|
||
{
|
||
success = await alarmCharacteristic.WriteAsync(command);
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Writing alarm settings failed.{AlarmCharacteristic}{CommandWritten}{Exception}", ToSerilogString(alarmCharacteristic), command[0], exception);
|
||
throw new System.Exception($"Can not set alarm settings. {exception.Message}", exception);
|
||
}
|
||
|
||
if (!success)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Writing alarm settings failed.{AlarmCharacteristic}{CommandWritten}", ToSerilogString(alarmCharacteristic), command[0]);
|
||
throw new System.Exception($"Can not set alarm settings. Writing settings did not succeed.");
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug("Alarm settings written successfully.{AlarmCharacteristic}{CommandWritten}.", ToSerilogString(alarmCharacteristic), command[0]);
|
||
}
|
||
|
||
public async Task<bool> SetSoundAsync(SoundSettings settings)
|
||
{
|
||
if (DeviceInfo.Platform != DevicePlatform.Unknown && MainThread.IsMainThread == false)
|
||
{
|
||
throw new System.Exception("Can not set sound settings. Platform must not be unknown and bluetooth code must be run on main thread.");
|
||
}
|
||
|
||
ICharacteristic soundCharacteristic = await GetSoundCharacteristicAsync();
|
||
if (soundCharacteristic == null)
|
||
{
|
||
Log.ForContext<LockItBase>().Debug("Getting sound characteristic failed.");
|
||
return false;
|
||
}
|
||
|
||
bool success;
|
||
byte command = (byte)settings;
|
||
try
|
||
{
|
||
success = await soundCharacteristic.WriteAsync(new byte[] { command });
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Writing sound settings failed.{SoundCharacteristic}{CommandWritten}{Exception}", ToSerilogString(soundCharacteristic), command, exception);
|
||
throw new System.Exception($"Can not set sound settings. {exception.Message}", exception);
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug(success
|
||
? "Writing sound settings failed.{SoundCharacteristic}{CommandWritten}"
|
||
: "Sound settings written successfully.{SoundCharacteristic}{CommandWritten}",
|
||
ToSerilogString(soundCharacteristic), command);
|
||
|
||
return success;
|
||
}
|
||
|
||
public async Task<bool> SetAlarmSettingsAsync(AlarmSettings settings)
|
||
{
|
||
if (DeviceInfo.Platform != DevicePlatform.Unknown && MainThread.IsMainThread == false)
|
||
{
|
||
throw new System.Exception("Can not set alarm settings. Platform must not be unknown and bluetooth code must be run on main thread.");
|
||
}
|
||
|
||
ICharacteristic alarmSettingsCharacteristic = await GetAlarmSettingsCharacteristicAsync();
|
||
if (alarmSettingsCharacteristic == null)
|
||
{
|
||
Log.ForContext<LockItBase>().Debug("Getting alarm settings characteristic failed.");
|
||
return false;
|
||
}
|
||
|
||
bool success;
|
||
byte command = (byte)settings;
|
||
try
|
||
{
|
||
success = await alarmSettingsCharacteristic.WriteAsync(new byte[] { command });
|
||
}
|
||
catch (System.Exception exception)
|
||
{
|
||
Log.ForContext<LockItBase>().Error("Writing alarm settings failed.{SoundCharacteristic}{CommandWritten}{Exception}", ToSerilogString(alarmSettingsCharacteristic), command, exception);
|
||
throw new System.Exception($"Can not set alarm settings. {exception.Message}", exception);
|
||
}
|
||
|
||
Log.ForContext<LockItBase>().Debug(success
|
||
? "Writing alarm settings failed.{SoundCharacteristic}{CommandWritten}"
|
||
: "Alarm settings written successfully.{SoundCharacteristic}{CommandWritten}",
|
||
ToSerilogString(alarmSettingsCharacteristic), command);
|
||
|
||
return success;
|
||
}
|
||
|
||
private static byte[] bitShift(byte[] data, int counter)
|
||
{
|
||
int mask = 0x000000FF;
|
||
data[0] = (byte)(counter & mask);
|
||
data[1] = (byte)(counter >> 8);
|
||
|
||
return data;
|
||
}
|
||
|
||
|
||
/// <summary> Disconnect from bluetooth lock. </summary>
|
||
public async Task Disconnect() => await Adapter.DisconnectDeviceAsync(Device);
|
||
|
||
/// <summary>
|
||
/// Don' t use .Destructure.ByTransforming<ICharacteristic>(...) because this would introduce a dependency to Plugin.BLE in main project.
|
||
/// </summary>
|
||
/// <param name="charcteristic"></param>
|
||
/// <returns></returns>
|
||
private static string ToSerilogString(ICharacteristic charcteristic)
|
||
=> charcteristic.Id.ToString();
|
||
|
||
private static string ToSerilogString(byte[] byteArray)
|
||
=> "***"; // For debuging purposes it might be reqired to return string.Join(",", byteArray); Do not log any confidental value in production context.
|
||
}
|
||
}
|