public void Should_return_DeviceType_in_string(
[AllEnumValues(typeof(DeviceClass))] DeviceClass deviceClass)
{
var expectedDeviceType = BluetoothDeviceType.Create(deviceClass);
_bluetoothDeviceInfoMock.Setup(bt => bt.DeviceType).Returns(expectedDeviceType);
StringAssert.Contains(_sut.DeviceType.Name, _sut.ToString());
}
public void Should_return_DeviceType_from_Name(
[AllEnumValues(typeof(DeviceClass))] DeviceClass deviceClass)
{
var expected = deviceClass.ToString();
var result = BluetoothDeviceType.Create(deviceClass);
Assert.AreEqual(expected, result.Name);
}
public void Should_return_tranlated_DeviceType_from_factory(
[AllEnumValues(typeof(DeviceClass))] DeviceClass deviceClass)
{
var expectedDeviceType = BluetoothDeviceType.Create(deviceClass);
_bluetoothDeviceInfoMock.Setup(bt => bt.DeviceType).Returns(expectedDeviceType);
Assert.AreEqual(expectedDeviceType, _sut.DeviceType);
}
public UnboundDeviceDiscoveryReceiver(
BluetoothDeviceType deviceType,
Action <BluetoothDevice> onFound,
List <BluetoothDevice> unBondedDevices)
{
this.deviceType = deviceType;
this.onFound = onFound;
this.unBondedDevices = unBondedDevices;
}
public static bool IsProbablyDataCapable(BluetoothDeviceType deviceClass)
{
switch (deviceClass)
{
case BluetoothDeviceType.Computer:
case BluetoothDeviceType.Phone:
return(true);
default:
return(false);
}
}
public virtual void Setup()
{
_bluetoothServiceMock = new Mock <IBluetoothService>();
_testSchedulerProvider = new TestSchedulerProvider();
_bluetoothDeviceInfoMock = new Mock <IBluetoothDeviceInfo>();
_sut = new BluetoothDevice(_bluetoothDeviceInfoMock.Object, _bluetoothServiceMock.Object,
_testSchedulerProvider);
_bluetoothDeviceInfoMock.Setup(bt => bt.DeviceAddress).Returns(_expectedAddress);
_bluetoothDeviceInfoMock.Setup(bt => bt.DeviceName).Returns(_expectedName);
_bluetoothDeviceInfoMock.Setup(bt => bt.DeviceType).Returns(BluetoothDeviceType.Create(DeviceClass.SmartPhone));
}
private bool IsBT(BluetoothDeviceType t)
{
switch (t)
{
case BluetoothDeviceType.Classic:
case BluetoothDeviceType.Dual:
return(true);
case BluetoothDeviceType.Le:
case BluetoothDeviceType.Unknown:
default:
return(false);
}
}
public void Should_return_IsValid_for_phone_types(
[AllEnumValues(typeof(DeviceClass))] DeviceClass deviceClass)
{
var expected = false;
switch (deviceClass)
{
case DeviceClass.Phone:
case DeviceClass.CellPhone:
case DeviceClass.CordlessPhone:
case DeviceClass.SmartPhone:
case DeviceClass.WiredPhone:
expected = true;
break;
}
var result = BluetoothDeviceType.Create(deviceClass);
Assert.AreEqual(expected, result.IsValid);
}
/// <summary>
/// Gets the worker needed for this device type
/// </summary>
/// <returns>The sensor worker.</returns>
/// <param name="dev">Dev.</param>
private BackgroundWorker getSensorWorker(BluetoothDevice dev)
{
BackgroundWorker worker = new BackgroundWorker();
worker.WorkerSupportsCancellation = true;
worker.RunWorkerCompleted += delegate
{
// if the worker stops it means the device has become disconnected
// sendDisconnectStateUpdate(dev.Address);
};
// Setting up worker depending on sensor
string manfName = new string(dev.Name.TakeWhile(Char.IsLetter).ToArray());
if (manfName == "HX")
{
worker.DoWork += (sender, e) => HexoSkinConnect(sender, e, dev);
return(worker);
}
// Get the type of device
BluetoothDeviceType t = AppUtil.getDeviceType(dev);
switch (t)
{
case BluetoothDeviceType.Le:
goto case BluetoothDeviceType.Dual;
case BluetoothDeviceType.Dual:
worker.DoWork += (sender, e) => LeSensorConnect(sender, e, dev);
break;
default:
// Unsupported Bluetooth Device Types
Log.Debug(LOG_TAG, "Unsupported Bluetooth Device!");
throw new NotSupportedException(t.ToString() + " Bluetooth Devices are not supported");
}
return(worker);
}
public void setBTDeviceType(BluetoothDeviceType type)
{
_type = type;
_deviceType = _type.ToString();
}
public WrappedBluetoothInfo(BluetoothDeviceInfo btDeviceInfo)
{
_btDeviceInfo = btDeviceInfo;
_deviceType = BluetoothDeviceType.Create(btDeviceInfo.ClassOfDevice.Device);
}
public void Should_return_MatchingUri_from_Image(
[AllEnumValues(typeof(DeviceClass))] DeviceClass deviceClass)
{
var result = BluetoothDeviceType.Create(deviceClass);
Uri expected;
switch (deviceClass)
{
//Phones
case DeviceClass.Phone:
case DeviceClass.CellPhone:
case DeviceClass.CordlessPhone:
case DeviceClass.SmartPhone:
case DeviceClass.WiredPhone:
expected = new Uri("pack://application:,,,/CallWall.Windows.Connectivity;component/Images/Bluetooth/Phone.png");
break;
//Computers
case DeviceClass.Computer:
case DeviceClass.DesktopComputer:
case DeviceClass.ServerComputer:
case DeviceClass.LaptopComputer:
case DeviceClass.HandheldComputer:
case DeviceClass.PdaComputer:
case DeviceClass.WearableComputer:
expected = new Uri("pack://application:,,,/CallWall.Windows.Connectivity;component/Images/Bluetooth/Computer.png");
break;
//Network
case DeviceClass.IsdnAccess:
case DeviceClass.AccessPointAvailable:
case DeviceClass.AccessPoint1To17:
case DeviceClass.AccessPoint17To33:
case DeviceClass.AccessPoint33To50:
case DeviceClass.AccessPoint50To67:
case DeviceClass.AccessPoint67To83:
case DeviceClass.AccessPoint83To99:
case DeviceClass.AccessPointNoService:
expected = new Uri("pack://application:,,,/CallWall.Windows.Connectivity;component/Images/Bluetooth/Network.png");
break;
//AV
case DeviceClass.AudioVideoUnclassified:
case DeviceClass.AudioVideoHeadset:
case DeviceClass.AudioVideoHandsFree:
case DeviceClass.AudioVideoMicrophone:
case DeviceClass.AudioVideoLoudSpeaker:
case DeviceClass.AudioVideoHeadphones:
case DeviceClass.AudioVideoPortable:
case DeviceClass.AudioVideoCar:
case DeviceClass.AudioVideoSetTopBox:
case DeviceClass.AudioVideoHiFi:
case DeviceClass.AudioVideoVcr:
case DeviceClass.AudioVideoVideoCamera:
case DeviceClass.AudioVideoCamcorder:
case DeviceClass.AudioVideoMonitor:
case DeviceClass.AudioVideoDisplayLoudSpeaker:
case DeviceClass.AudioVideoVideoConferencing:
case DeviceClass.AudioVideoGaming:
expected = new Uri("pack://application:,,,/CallWall.Windows.Connectivity;component/Images/Bluetooth/AudioVisual.png");
break;
//Peripheral/Accessories
case DeviceClass.Peripheral:
case DeviceClass.PeripheralJoystick:
case DeviceClass.PeripheralGamepad:
case DeviceClass.PeripheralRemoteControl:
case DeviceClass.PeripheralSensingDevice:
case DeviceClass.PeripheralDigitizerTablet:
case DeviceClass.PeripheralCardReader:
case DeviceClass.PeripheralKeyboard:
case DeviceClass.PeripheralPointingDevice:
case DeviceClass.PeripheralCombinedKeyboardPointingDevice:
expected = new Uri("pack://application:,,,/CallWall.Windows.Connectivity;component/Images/Bluetooth/Peripheral.png");
break;
//Imaging/Printers/Cameras
case DeviceClass.Imaging:
case DeviceClass.ImagingDisplay:
case DeviceClass.ImagingCamera:
case DeviceClass.ImagingScanner:
case DeviceClass.ImagingPrinter:
expected = new Uri("pack://application:,,,/CallWall.Windows.Connectivity;component/Images/Bluetooth/Imaging.png");
break;
//Wearable
case DeviceClass.Wearable:
case DeviceClass.WearableWristWatch:
case DeviceClass.WearablePager:
case DeviceClass.WearableJacket:
case DeviceClass.WearableHelmet:
case DeviceClass.WearableGlasses:
//Toys
case DeviceClass.Toy:
case DeviceClass.ToyRobot:
case DeviceClass.ToyVehicle:
case DeviceClass.ToyFigure:
case DeviceClass.ToyController:
case DeviceClass.ToyGame:
//Medical
case DeviceClass.Medical:
case DeviceClass.MedicalBloodPressureMonitor:
case DeviceClass.MedicalThermometer:
case DeviceClass.MedicalWeighingScale:
case DeviceClass.MedicalGlucoseMeter:
case DeviceClass.MedicalPulseOximeter:
case DeviceClass.MedicalHeartPulseRateMonitor:
case DeviceClass.MedicalDataDisplay:
//Other/Unknown
case DeviceClass.Uncategorized:
case DeviceClass.Miscellaneous:
default:
expected = new Uri("pack://application:,,,/CallWall.Windows.Connectivity;component/Images/Bluetooth/Miscellaneous.png");
break;
}
Assert.AreEqual(expected, result.Image);
}
public BluetoothCommonFunctionality(BluetoothDeviceType deviceType)
{
this.deviceType = deviceType;
this.msgPump.MsgPumpConnectResultEvent += this.ConnectResultHandler;
this.msgPump.MsgReceivedEvent += this.MsgReceivedHandler;
}
