public async Task BleServiceTests_GetGattServicesByDeviceId_Returns_BleGattServices()
{
var deviceId = "deviceId";
var bMgrDevices = new BleDevice {
Id = deviceId, Name = "name_1"
};
var bMgerDeviceGattServices = new[]
{
new BleGattService {
DeviceId = "gatt-service-1"
},
new BleGattService {
DeviceId = "gatt-service-2"
},
new BleGattService {
DeviceId = "gatt-service-3"
},
};
var bMgr = new Mock <IBleManager>();
bMgr.Setup(b => b.GetDiscoveredDevices()).Returns(new[] { bMgrDevices });
bMgr.Setup(b => b.GetDeviceGattServices(It.IsAny <string>()))
.Returns(Task.FromResult((IEnumerable <BleGattService>)bMgerDeviceGattServices));
var srv = new BleService(bMgr.Object);
var res = await srv.GetGattServicesByDeviceId(deviceId);
res.Result.ShouldBe(ServiceResponseResult.Success);
res.Data.Count().ShouldBe(bMgerDeviceGattServices.Length);
foreach (var gt in res.Data)
{
bMgerDeviceGattServices.Any(t => t.Uuid == gt.Uuid).ShouldBeTrue();
}
}
public async Task BleServiceTests_GetDevices_ReturnsDevices()
{
var serviceDevices = new[]
{
new BleDevice {
Id = "id_1", Name = "name_1"
},
new BleDevice {
Id = "id_2", Name = "name_2"
},
new BleDevice {
Id = "id_3", Name = "name_3"
},
new BleDevice {
Id = "id_4", Name = "name_4"
},
} as IEnumerable <BleDevice>;
var bMgr = new Mock <IBleManager>();
bMgr.Setup(b => b.GetDiscoveredDevices()).Returns(serviceDevices);
var srv = new BleService(bMgr.Object);
var devices = await srv.GetDiscoveredDevices();
devices.ShouldNotBeNull();
devices.Count().ShouldBe(serviceDevices.Count());
foreach (var rd in devices)
{
serviceDevices.Any(d => d.Name == rd.Name && d.Id == rd.Id);
}
}
public async Task Scan()
{
Devices.Clear();
await BleService.StartScan(OnDeviceDiscovered);
IsScanning = true;
}
public void InitBleService(Context context)
{
IsConnecting = false;
servceConncection = new YsServiceConnection();
var bleCallBack = new YsBleCallBack();
servceConncection.Act_OnServiceDisconnected += delegate
{
mLeService = null;
};
servceConncection.Act_OnServiceConnected += delegate(ComponentName j, IBinder k)
{
mLeService = ((BleService.LocalBinder)k).GetService(bleCallBack);
mLeService.SetDecode(false);
mLeService.ConnectTimeout = 5 * 1000;
mLeService.Initialize();
};
context.BindService(new Intent(context, typeof(BleService)), servceConncection, Bind.AutoCreate);
bleCallBack.OnConnectedEvent += BleCallBack_OnConnectedEvent;
bleCallBack.OnConnectTimeoutEvent += BleCallBack_OnConnectTimeoutEvent;
bleCallBack.OnConnectionErrorEvent += BleCallBack_OnConnectionErrorEvent;
bleCallBack.OnDisconnectedEvent += BleCallBack_OnDisconnectedEvent;
bleCallBack.OnServicesUndiscoveredEvent += BleCallBack_OnServicesUndiscoveredEvent;
bleCallBack.OnServicesDiscoveredEvent += BleCallBack_OnServicesDiscoveredEvent;
bleCallBack.OnCharacteristicChangedEvent += BleCallBack_OnCharacteristicChangedEvent;
}
public async Task Scan()
{
Devices.Clear();
OnPropertyChanged("Devices");
await BleService.StartScan(OnDeviceDiscovered);
IsScanning = true;
}
private void RefreshList()
{
if (BleService.bleAdapter.AdapterCanBeEnabled && BleService.bleAdapter.CurrentState.IsDisabledOrDisabling())
{
BleService.bleAdapter.EnableAdapter();
}
Task.Run(() => BleService.ScanForDevices());
}
public async Task BleServiceTests_GetDeviceById_ReturnsNull(IEnumerable <BleDevice> devices)
{
var bMgr = new Mock <IBleManager>();
bMgr.Setup(b => b.GetDiscoveredDevices()).Returns(devices);
var srv = new BleService(bMgr.Object);
var res = await srv.GetDiscoveredDeviceById("deviceId");
res.ShouldBeNull();
}
public async Task BleServiceTests_Unpair(bool expUnpairResult)
{
var bleMock = new Mock <IBleManager>();
bleMock.Setup(b => b.Disconnect(It.IsAny <string>())).ReturnsAsync(expUnpairResult);
var srv = new BleService(bleMock.Object);
var res = await srv.DisconnectDeviceById("some-device-id");
res.ShouldBe(expUnpairResult);
}
public async Task BleServiceTests_GetDiscoveredDevices_ReturnsEmpty(IEnumerable <BleDevice> devices)
{
var bMgr = new Mock <IBleManager>();
bMgr.Setup(b => b.GetDiscoveredDevices()).Returns(devices);
var srv = new BleService(bMgr.Object);
var res = await srv.GetDiscoveredDevices();
res.ShouldNotBeNull();
res.Any().ShouldBeFalse();
}
public override bool TryGetService(BleUuid guid, out BleService service)
{
RequiresServices();
var services = _services;
for (int i = 0; i < services.Length; i++)
{
if (services[i].Uuid == guid)
{
service = services[i]; return(true);
}
}
service = null; return(false);
}
public async Task BleServiceTests_GetCharacteristics_NotFound()
{
var deviceId = "device-not-exists";
var serviceId = "gatt-service-id";
var bMgr = new Mock <IBleManager>();
bMgr.Setup(b => b.GetDeviceCharacteristics(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(new BleGattCharacteristic[] { });
var srv = new BleService(bMgr.Object);
var res = await srv.GetCharacteristics(deviceId, serviceId);
res.Result.ShouldBe(ServiceResponseResult.NotFound);
res.Message.ShouldContain("\'" + deviceId + "\'");
res.Message.ShouldContain("\'" + serviceId + "\'");
}
public async Task BleService_RegisterToCharacteristicNotifications_Success()
{
var bleMock = new Mock <IBleManager>();
bleMock.Setup(b => b.RegisterToCharacteristicNotifications(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(true);
var srv = new BleService(bleMock.Object);
var deviceId = "some-device-id";
var gattServiceId = "some-gatt-service-id";
var characteristicId = "some-characteristic-id";
var res = await srv.GetCharacteristicNotifications(deviceId, gattServiceId, characteristicId);
res.Result.ShouldBe(ServiceResponseResult.Success);
res.Message.ShouldBeNull();
}
public async Task BleServiceTests_GetCharacteristics()
{
var deviceId = "device-not-exists";
var serviceId = "gatt-service-id";
var bMgrResponse = new[] { new BleGattCharacteristic(Guid.NewGuid(), "some-description") };
var bMgr = new Mock <IBleManager>();
bMgr.Setup(b => b.GetDeviceCharacteristics(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(bMgrResponse);
var srv = new BleService(bMgr.Object);
var res = await srv.GetCharacteristics(deviceId, serviceId);
res.Result.ShouldBe(ServiceResponseResult.Success);
res.Data.ShouldBe(bMgrResponse);
}
public async Task BleServiceTests_WriteToCharacteristic_Success()
{
var bleMock = new Mock <IBleManager>();
bleMock.Setup(b => b.WriteToCharacteristric(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <IEnumerable <byte> >())).ReturnsAsync(true);
var srv = new BleService(bleMock.Object);
var deviceId = "some-device-id";
var gattServiceId = "some-gatt-service-id";
var characteristicId = "some-characteristic-id";
var res = await srv.WriteToCharacteristic(deviceId, gattServiceId, characteristicId, new byte[] { });
res.Result.ShouldBe(ServiceResponseResult.Success);
res.Message.ShouldBeNull();
}
public async Task BleServiceTests_GetDeviceById_ReturnsDevice()
{
var deviceId = "id_1";
var bMgrResponse = new BleDevice {
Id = deviceId, Name = "name_1"
};
var bMgr = new Mock <IBleManager>();
bMgr.Setup(b => b.GetDiscoveredDevices()).Returns(new[] { bMgrResponse });
var srv = new BleService(bMgr.Object);
var res = await srv.GetDiscoveredDeviceById(deviceId);
res.ShouldBe(bMgrResponse);
}
public async Task BleServiceTests_GetGattServicesByDeviceId_deviceNotExists()
{
var deviceId = "device-not-exists";
var bMgrResponse = new BleDevice {
Id = "dId", Name = "name_1"
};
var bMgr = new Mock <IBleManager>();
bMgr.Setup(b => b.GetDiscoveredDevices()).Returns(new[] { bMgrResponse });
var srv = new BleService(bMgr.Object);
var res = await srv.GetGattServicesByDeviceId(deviceId);
res.Result.ShouldBe(ServiceResponseResult.NotFound);
}
public async Task BleService_ReadFromCharacteristic_Success()
{
var bytes = Encoding.UTF8.GetBytes("some-value");
var bleMock = new Mock <IBleManager>();
bleMock.Setup(b => b.ReadFromCharacteristic(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(bytes);
var srv = new BleService(bleMock.Object);
var deviceId = "some-device-id";
var gattServiceId = "some-gatt-service-id";
var characteristicId = "some-characteristic-id";
var res = await srv.ReadFromCharacteristic(deviceId, gattServiceId, characteristicId);
res.Result.ShouldBe(ServiceResponseResult.Success);
res.Message.ShouldBeNull();
res.Data.ShouldBe(bytes);
}
public async Task BleService_ReadFromCharacteristic_Fails()
{
var bleMock = new Mock <IBleManager>();
bleMock.Setup(b => b.ReadFromCharacteristic(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(null as IEnumerable <byte>);
var srv = new BleService(bleMock.Object);
var deviceId = "some-device-id";
var gattServiceId = "some-gatt-service-id";
var characteristicId = "some-characteristic-id";
var res = await srv.ReadFromCharacteristic(deviceId, gattServiceId, characteristicId);
res.Result.ShouldBe(ServiceResponseResult.Fail);
res.Message.ShouldContain("\'" + deviceId + "\'");
res.Message.ShouldContain("\'" + gattServiceId + "\'");
res.Message.ShouldContain("\'" + characteristicId + "\'");
res.Data.ShouldBeNull();
}
public async Task BleServiceTests_WriteToCharacteristic_Throws()
{
var bleMock = new Mock <IBleManager>();
bleMock.Setup(b => b.WriteToCharacteristric(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <IEnumerable <byte> >()))
.ThrowsAsync(new NullReferenceException());
var srv = new BleService(bleMock.Object);
var deviceId = "some-device-id";
var gattServiceId = "some-gatt-service-id";
var characteristicId = "some-characteristic-id";
var res = await srv.WriteToCharacteristic(deviceId, gattServiceId, characteristicId, new byte[] { });
res.Result.ShouldBe(ServiceResponseResult.NotAcceptable);
res.Message.ShouldContain("\'" + deviceId + "\'");
res.Message.ShouldContain("\'" + gattServiceId + "\'");
res.Message.ShouldContain("\'" + characteristicId + "\'");
}
public async Task BleService_RegisterToCharacteristicNotifications_Throws()
{
var bleMock = new Mock <IBleManager>();
bleMock.Setup(b => b.RegisterToCharacteristicNotifications(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.ThrowsAsync(new NullReferenceException());
var srv = new BleService(bleMock.Object);
var deviceId = "some-device-id";
var gattServiceId = "some-gatt-service-id";
var characteristicId = "some-characteristic-id";
var res = await srv.GetCharacteristicNotifications(deviceId, gattServiceId, characteristicId);
res.Result.ShouldBe(ServiceResponseResult.NotAcceptable);
res.Message.ShouldContain("\'" + deviceId + "\'");
res.Message.ShouldContain("\'" + gattServiceId + "\'");
res.Message.ShouldContain("\'" + characteristicId + "\'");
}
/// <summary>
/// This methods initialize the Scan actions
/// </summary>
private async void ScanForDevices()
{
ComputeScanningPropertiesIndicators(ScanningWizardState.Scanning);
availableDevices.Clear();
await Task.Delay(100);
// when the timeout is reached, raise the event to stop the animation
Xamarin.Forms.Device.StartTimer(TimeSpan.FromSeconds(this.settings.BLUETOOTH_SCAN_TIMEOUT), () =>
{
// Also stop the inprogress scanning
this.BleService.StopScanning();
// Scan for devices
if (this.BleService.DiscoveredDevices != null)
{
foreach (BluetoothDevice btDevice in this.BleService.DiscoveredDevices)
{
Models.Device device = new Models.Device(btDevice.Address, btDevice.Name);
if (!this.availableDevices.Contains(device))
{
this.availableDevices.Add(device);
}
}
}
if (this.availableDevices.Count == 0)
{
App.Current.MainPage.DisplayAlert(Utils.GetTranslation("BluetoothPage_AlertNoDevicesTitle"), Utils.GetTranslation("BluetoothPage_AlertNoDevicesMessage"), Utils.GetTranslation("OK"));
ComputeScanningPropertiesIndicators(ScanningWizardState.Off);
}
else
{
ComputeScanningPropertiesIndicators(ScanningWizardState.DisplayResult);
}
return(false);
});
// Scan for devices
BleService.ScanForDevices();
}
private async void ReadBattery()
{
try
{
var msg = await BleService.ReadFromDevice();
if (!string.IsNullOrEmpty(msg))
{
int BattLevel = Convert.ToInt32(msg);
if (this.BattLevel == 0) // First time battery read
{
this.BattLevel = BattLevel;
}
if (Math.Abs(this.BattLevel - BattLevel) < 10)//Reading correct
{
this.BattLevel = BattLevel;
if (BattLevel > 60)
{
Battery.Source = "BatteryFull";
}
else if (BattLevel < 60 && BattLevel > 30)
{
Battery.Source = "BatteryMedium";
}
else if (BattLevel < 30)
{
Battery.Source = "BatteryLow";
}
}
}
}
catch (Exception ex)
{
Battery.Source = null;
Debug.WriteLine(ex.Message);
}
}
public async Task Stop()
{
await BleService.StopScan();
IsScanning = false;
}
