internal static ClassOfDevice ConvertCoDs(BluetoothClass codAndroid)
{
DeviceClass dc = (DeviceClass)(int)codAndroid.DeviceClass;
ServiceClass sc = FindSetServiceBits(codAndroid);
return(new ClassOfDevice(dc, sc));
}
public void TryFindChildren()
{
if (Root == 0)
{
return;
}
IHSApplication hs = _plugin.hs;
DeviceClass root = (DeviceClass)hs.GetDeviceByRef(Root);
foreach (int childRef in root.get_AssociatedDevices(hs))
{
DeviceClass child = (DeviceClass)hs.GetDeviceByRef(childRef);
SubDeviceType subType = (SubDeviceType)int.Parse(child.get_Address(hs).Split('-')[1]);
switch (subType)
{
case SubDeviceType.Brightness:
Brightness = childRef;
break;
case SubDeviceType.Color:
Color = childRef;
break;
case SubDeviceType.Temperature:
Temperature = childRef;
break;
}
}
}
public void GetDevicesOfType(string classificationName)
{
var deviceManager = new DeviceManager();
var classification = new DeviceClass()
{
Name = classificationName
};
deviceManager.Devices = new List <IDevice>()
{
new Device()
{
Classification = classification
}
};
var devicesByClassification = deviceManager.GetDevicesOfType(classification);
Assert.Equal(1, devicesByClassification.Count());
Assert.Equal(classificationName, devicesByClassification.FirstOrDefault().Classification.Name);
var devicesByClassificationName = deviceManager.GetDevicesOfType(classification);
Assert.Equal(1, devicesByClassificationName.Count());
Assert.Equal(classificationName, devicesByClassificationName.FirstOrDefault().Classification.Name);
}
public override string ConfigDevice(int deviceId, [AllowNull] string user, int userRights, bool newDevice)
{
if (newDevice)
{
return(string.Empty);
}
try
{
DeviceClass deviceClass = (DeviceClass)HS.GetDeviceByRef(deviceId);
if (deviceClass.get_Interface(HS) == PlugInData.PlugInName)
{
var deviceIdentifier = DeviceIdentifier.Identify(deviceClass);
if (deviceIdentifier != null)
{
return(configPage.GetDeviceImportTab(deviceIdentifier));
}
}
else
{
return(configPage.GetDeviceHistoryTab(deviceClass));
}
return(string.Empty);
}
catch (Exception ex)
{
LogError(Invariant($"ConfigDevice for {deviceId} With {ex.Message}"));
return(string.Empty);
}
}
private void _createColor(string label)
{
if (Color != 0)
{
return;
}
IHSApplication hs = _plugin.hs;
int hsRef = hs.NewDeviceRef(label + " Color");
DeviceClass device = (DeviceClass)hs.GetDeviceByRef(hsRef);
device.set_Address(hs, GetSubDeviceAddress(SubDeviceType.Color));
device.set_Interface(hs, _plugin.Name);
device.set_InterfaceInstance(hs, _plugin.InstanceFriendlyName());
device.set_Device_Type_String(hs, "LIFX Device Color");
device.set_DeviceType_Set(hs, new DeviceTypeInfo_m.DeviceTypeInfo {
Device_API = DeviceTypeInfo_m.DeviceTypeInfo.eDeviceAPI.Plug_In
});
// Create the buttons and slider
VSVGPairs.VSPair colorPicker = new VSVGPairs.VSPair(ePairStatusControl.Both);
colorPicker.PairType = VSVGPairs.VSVGPairType.SingleValue;
colorPicker.Render = Enums.CAPIControlType.Color_Picker;
colorPicker.ControlUse = ePairControlUse._ColorControl;
hs.DeviceVSP_AddPair(hsRef, colorPicker);
device.MISC_Set(hs, Enums.dvMISC.SHOW_VALUES);
hs.SetDeviceString(hsRef, "ffffff", false);
Color = hsRef;
}
public string GetName(DeviceClass device)
{
List <string> parts = new List <string>();
string location1 = device.get_Location(HS);
if (location2Enabled)
{
string location2 = device.get_Location2(HS);
if (location1First)
{
AddIfNotEmpty(parts, location1);
AddIfNotEmpty(parts, location2);
}
else
{
AddIfNotEmpty(parts, location2);
AddIfNotEmpty(parts, location1);
}
}
else
{
AddIfNotEmpty(parts, location1);
}
AddIfNotEmpty(parts, device.get_Name(HS));
return(string.Join(" ", parts));
}
void wdStack_DeviceResponded(DeviceAddress bda, DeviceClass devClass, string bdName, bool bConnected)
{
this.BeginInvoke((MethodInvoker) delegate
{
bool needToCreate = true;
foreach (DeviceListViewItem item in listView1.Items)
{
if (item.DeviceItem.DevAddress.Equals(bda))
{
if (string.IsNullOrEmpty(item.DeviceItem.BdName))
{
//Replace item if old item has empty name
listView1.Items.Remove(item);
needToCreate = true;
}
else
{
needToCreate = false;
}
break;
}
}
if (needToCreate)
{
listView1.Items.Add(new DeviceListViewItem(bda, devClass, bdName, bConnected));
}
});
}
protected void UpdateFirstNodeAsNumber(IHSApplication HS, DeviceClass device, [AllowNull] XPathNodeIterator value)
{
double?data = null;
if ((value != null) && (value.MoveNext()))
{
string text = value.Current.ToString().Trim(new char[] { '%', ' ' });
if (double.TryParse(text, NumberStyles.Any, CultureInfo.InvariantCulture, out double doubleValue))
{
if (!inValidValues.Contains(doubleValue))
{
data = doubleValue;
}
else
{
Trace.WriteLine(Invariant($"Device {Name} Address [{device.get_Address(null)}] has invalid Value {doubleValue}"));
}
}
else
{
Trace.WriteLine(Invariant($"Device {Name} Address [{device.get_Address(null)}] has Non-Double Value:[{text}]"));
}
}
else
{
Trace.WriteLine(Invariant($"No node value found for {Name} Address [{device.get_Address(null)}]"));
}
UpdateDeviceData(HS, device, data);
}
protected void UpdateByCalculatingAsNumber(IHSApplication HS, DeviceClass device, [AllowNull] XPathNodeIterator value,
Func <double, double, double> calculator)
{
double?data = null;
while ((value != null) && (value.MoveNext()))
{
string text = value.Current.ToString().Trim(new char[] { '%', ' ' });
if (double.TryParse(text, NumberStyles.Any, CultureInfo.InvariantCulture, out double doubleValue))
{
if (!inValidValues.Contains(doubleValue))
{
if (!data.HasValue)
{
data = doubleValue;
}
else
{
data = calculator(doubleValue, data.Value);
}
}
}
}
UpdateDeviceData(HS, device, data);
}
private bool IsPhone(DeviceClass d)
{
switch (d)
{
case DeviceClass.PhoneCellular:
case DeviceClass.PhoneCordless:
case DeviceClass.PhoneIsdn:
case DeviceClass.PhoneModemOrGateway:
case DeviceClass.PhoneSmart:
case DeviceClass.PhoneUncategorized:
case DeviceClass.ComputerHandheldPcPda:
case DeviceClass.ComputerPalmSizePcPda:
case DeviceClass.ComputerWearable:
return(true);
case DeviceClass.ToyVehicle:
case DeviceClass.AudioVideoCamcorder:
case DeviceClass.AudioVideoCarAudio:
case DeviceClass.AudioVideoHandsfree:
case DeviceClass.AudioVideoHeadphones:
case DeviceClass.AudioVideoHifiAudio:
case DeviceClass.AudioVideoLoudspeaker:
case DeviceClass.AudioVideoMicrophone:
case DeviceClass.AudioVideoPortableAudio:
case DeviceClass.AudioVideoSetTopBox:
case DeviceClass.AudioVideoUncategorized:
case DeviceClass.AudioVideoVcr:
case DeviceClass.AudioVideoVideoCamera:
case DeviceClass.AudioVideoVideoConferencing:
case DeviceClass.AudioVideoVideoDisplayAndLoudspeaker:
case DeviceClass.AudioVideoVideoGamingToy:
case DeviceClass.AudioVideoVideoMonitor:
case DeviceClass.AudioVideoWearableHeadset:
case DeviceClass.ComputerDesktop:
case DeviceClass.ComputerLaptop:
case DeviceClass.ComputerServer:
case DeviceClass.ComputerUncategorized:
case DeviceClass.HealthBloodPressure:
case DeviceClass.HealthDataDisplay:
case DeviceClass.HealthGlucose:
case DeviceClass.HealthPulseOximeter:
case DeviceClass.HealthPulseRate:
case DeviceClass.HealthThermometer:
case DeviceClass.HealthUncategorized:
case DeviceClass.HealthWeighing:
case DeviceClass.ToyController:
case DeviceClass.ToyDollActionFigure:
case DeviceClass.ToyGame:
case DeviceClass.ToyRobot:
case DeviceClass.ToyUncategorized:
case DeviceClass.WearableGlasses:
case DeviceClass.WearableHelmet:
case DeviceClass.WearableJacket:
case DeviceClass.WearablePager:
case DeviceClass.WearableUncategorized:
case DeviceClass.WearableWristWatch:
default:
return(false);
}
}
/// <summary>
/// Creates the HS device.
/// </summary>
/// <param name="parent">The data for parent of device.</param>
/// <param name="rootDeviceData">The root device data.</param>
/// <param name="deviceData">The device data.</param>
/// <returns>New Device</returns>
private DeviceClass CreateDevice([AllowNull] DeviceClass parent, [AllowNull] RootDeviceData rootDeviceData, DeviceDataBase deviceData)
{
if (rootDeviceData != null)
{
LogDebug(Invariant($"Creating {deviceData.Name} under {rootDeviceData.Name}"));
}
else
{
LogDebug(Invariant($"Creating Root {deviceData.Name}"));
}
DeviceClass device = null;
int refId = HS.NewDeviceRef(rootDeviceData != null ? Invariant($"{rootDeviceData.Name} {deviceData.Name}") : deviceData.Name);
if (refId > 0)
{
device = (DeviceClass)HS.GetDeviceByRef(refId);
string address = rootDeviceData != null?CreateChildAddress(rootDeviceData.Name, deviceData.Name) : deviceData.Name;
device.set_Address(HS, address);
device.set_Device_Type_String(HS, deviceData.HSDeviceTypeString);
var deviceType = new DeviceTypeInfo_m.DeviceTypeInfo();
deviceType.Device_API = DeviceTypeInfo_m.DeviceTypeInfo.eDeviceAPI.Plug_In;
deviceType.Device_Type = deviceData.HSDeviceType;
device.set_DeviceType_Set(HS, deviceType);
device.set_Interface(HS, Name);
device.set_InterfaceInstance(HS, string.Empty);
device.set_Last_Change(HS, DateTime.Now);
device.set_Location(HS, Name);
var pairs = deviceData.StatusPairs;
foreach (var pair in pairs)
{
HS.DeviceVSP_AddPair(refId, pair);
}
var gPairs = deviceData.GraphicsPairs;
foreach (var gpair in gPairs)
{
HS.DeviceVGP_AddPair(refId, gpair);
}
device.MISC_Set(HS, Enums.dvMISC.STATUS_ONLY);
device.MISC_Set(HS, Enums.dvMISC.SHOW_VALUES);
device.MISC_Clear(HS, Enums.dvMISC.AUTO_VOICE_COMMAND);
device.MISC_Clear(HS, Enums.dvMISC.SET_DOES_NOT_CHANGE_LAST_CHANGE);
device.set_Status_Support(HS, false);
if (parent != null)
{
parent.set_Relationship(HS, Enums.eRelationship.Parent_Root);
device.set_Relationship(HS, Enums.eRelationship.Child);
device.AssociatedDevice_Add(HS, parent.get_Ref(HS));
parent.AssociatedDevice_Add(HS, device.get_Ref(HS));
}
deviceData.SetInitialData(HS, device);
}
return(device);
}
private void GetCurrentDevices()
{
var deviceEnumerator = HS.GetDeviceEnumerator() as clsDeviceEnumeration;
if (deviceEnumerator == null)
{
throw new HspiException(Invariant($"{PluginData.PlugInName} failed to get a device enumerator from HomeSeer."));
}
string parentAddress = DeviceIdentifier.CreateRootAddress(rootDeviceId);
do
{
DeviceClass device = deviceEnumerator.GetNext();
if ((device != null) &&
(device.get_Interface(HS) != null) &&
(device.get_Interface(HS).Trim() == PluginData.PlugInName))
{
string address = device.get_Address(HS);
if (address == parentAddress)
{
parentRefId = device.get_Ref(HS);
}
else if (address.StartsWith(parentAddress, StringComparison.Ordinal))
{
DeviceData childDeviceData = GetDeviceData(device);
if (childDeviceData != null)
{
currentChildDevices.Add(address, childDeviceData);
}
}
}
} while (!deviceEnumerator.Finished);
}
/// <summary>
/// Gets the devices for a particular <see cref="DeviceClass"/> and <see cref="DeviceEnumerationFlags"/>.
/// </summary>
/// <param name="deviceClass">Class of the device.</param>
/// <param name="deviceEnumFlags">The device enum flags.</param>
/// <returns>A collection of <see cref="DeviceInstance"/></returns>
public IList <DeviceInstance> GetDevices(DeviceClass deviceClass, DeviceEnumerationFlags deviceEnumFlags)
{
var enumDevicesCallback = new EnumDevicesCallback();
EnumDevices((int)deviceClass, enumDevicesCallback.NativePointer, IntPtr.Zero, deviceEnumFlags);
return(enumDevicesCallback.DeviceInstances);
}
static internal DeviceClass GenericHomeSeerDevice(DeviceClass dv, string dvName, string dvName_long, string device_id)
{
int dvRef;
Log("Creating Device: " + dvName_long + " " + dvName, LogType.LOG_TYPE_INFO);
var DT = new DeviceTypeInfo_m.DeviceTypeInfo();
DT.Device_API = DeviceTypeInfo_m.DeviceTypeInfo.eDeviceAPI.Plug_In;
if (dvName.Contains("Root"))
{
DT.Device_Type = 99;
}
hs.NewDeviceRef(dvName_long + " " + dvName);
dvRef = hs.GetDeviceRefByName(dvName_long + " " + dvName);
dv = (DeviceClass)hs.GetDeviceByRef(dvRef);
dv.set_Address(hs, "");
SetDeviceKeys(dv, device_id, dvName);
//dv.set_Code(hs, device_id + "-" + dvName_long + "-" + dvName);
dv.set_Location(hs, "Thermostat");
dv.set_Location2(hs, "Ecobee");
dv.set_Interface(hs, IFACE_NAME);
dv.set_Status_Support(hs, true);
dv.set_Can_Dim(hs, false);
dv.MISC_Set(hs, Enums.dvMISC.NO_LOG);
dv.set_DeviceType_Set(hs, DT);
dv.set_Relationship(hs, Enums.eRelationship.Child);
return(dv);
}
public static DeviceIdentifier Identify(DeviceClass hsDevice)
{
var childAddress = hsDevice.get_Address(null);
var parts = childAddress.Split(AddressSeparator);
if (parts.Length != 4)
{
return(null);
}
DeviceType?deviceType = ParseDeviceType(parts[2]);
if (deviceType == null)
{
return(null);
}
string deviceTypeData = parts[3];
if (deviceTypeData == null)
{
return(null);
}
return(new DeviceIdentifier(parts[1], deviceType.Value, deviceTypeData));
}
public override void UpdateDeviceData(IHSApplication HS, DeviceClass device, System.Xml.XmlElement value)
{
var childNavigator = value.CreateNavigator();
var nodeIter = childNavigator.Select(dayDeviceData.PathData.GetPath(Unit.US));
dayDeviceData.UpdateDeviceData(HS, device, nodeIter);
}
/// <summary>
/// Initializes a new instance of the <see cref="BluetoothDevice"/> class from the Java BluetoothDevice.
/// </summary>
/// <param name="bluetoothDeviceJavaObject">
/// The Java object that is an instance of android.bluetooth.BluetoothDevice.
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="bluetoothDeviceJavaObject"/> is null.
/// </exception>
internal BluetoothDevice(AndroidJavaObject bluetoothDeviceJavaObject)
{
try {
if (bluetoothDeviceJavaObject.IsNull())
{
throw new ArgumentNullException("bluetoothDeviceJavaObject");
}
Name = bluetoothDeviceJavaObject.Call <string>("getName").Trim();
Address = bluetoothDeviceJavaObject.Call <string>("getAddress");
BondState = (DeviceBondState)bluetoothDeviceJavaObject.Call <int>("getBondState");
AndroidJavaObject deviceClassJavaObject = bluetoothDeviceJavaObject.Call <AndroidJavaObject>("getBluetoothClass");
int deviceClassFull = deviceClassJavaObject.Call <int>("getDeviceClass");
DeviceClass = (BluetoothDeviceClass.Class)deviceClassFull;
DeviceMajorClass = DeviceClass.GetMajorClass();
IsConnectable = DeviceClass.IsProbablyHandheldDataCapableDevice();
if (Name == string.Empty)
{
Name = Address;
}
} catch {
Debug.LogError("Exception while converting BluetoothDevice");
throw;
}
}
private static T Create <T>(DeviceClass dc, ServiceClass sc)
where T : MarshalByRefObject
{
var p = new SimpleBluetoothClassMock(typeof(T), dc, sc);
return((T)p.GetTransparentProxy());
}
public override void SetInitialData(IHSApplication HS, DeviceClass device)
{
int refId = device.get_Ref(HS);
HS.set_DeviceInvalidValue(refId, false);
HS.SetDeviceString(refId, "Root", false);
}
private void GetCurrentDevices()
{
if (!(HS.GetDeviceEnumerator() is clsDeviceEnumeration deviceEnumerator))
{
throw new HspiException(Invariant($"{PluginData.PlugInName} failed to get a device enumerator from HomeSeer."));
}
string baseAddress = DeviceIdentifier.CreateDeviceIdSpecficAddress(CameraSettings.Id);
do
{
DeviceClass device = deviceEnumerator.GetNext();
if ((device != null) &&
(device.get_Interface(HS) != null) &&
string.Equals(device.get_Interface(HS).Trim(), PluginData.PlugInName, StringComparison.Ordinal))
{
string address = device.get_Address(HS);
if (address.StartsWith(baseAddress, StringComparison.Ordinal))
{
var deviceData = GetDeviceData(device);
if (deviceData != null)
{
devices.Add(address, deviceData);
deviceData.OnPlugInLoad(HS, CameraSettings);
if (deviceData.IsRootDevice)
{
parentRefId = device.get_Ref(HS);
}
}
}
}
} while (!deviceEnumerator.Finished);
}
public override void SetInitialData(IHSApplication HS, DeviceClass device)
{
int refId = device.get_Ref(HS);
HS.SetDeviceValueByRef(refId, 0D, false);
HS.set_DeviceInvalidValue(refId, true);
}
/// <summary>
/// Initializes a new instance of the <see cref="BluetoothDevice"/> class.
/// </summary>
/// <param name="deviceString">
/// The device string.
/// </param>
internal BluetoothDevice(string deviceString)
{
try {
string[] tokens =
deviceString.Split(
new[] { AndroidBluetoothMultiplayer.kDataDelimiter },
StringSplitOptions.None
);
Name = tokens[0].Trim();
Address = tokens[1];
BondState = (DeviceBondState)byte.Parse(tokens[2]);
int deviceClassFull = int.Parse(tokens[3]);
DeviceClass = (BluetoothDeviceClass.Class)deviceClassFull;
DeviceMajorClass = DeviceClass.GetMajorClass();
IsConnectable = DeviceClass.IsProbablyHandheldDataCapableDevice();
if (Name == string.Empty)
{
Name = Address;
}
} catch {
Debug.LogError(string.Format("Exception while parsing BluetoothDevice, string was: {0}", deviceString));
throw;
}
}
/// <summary>
/// Gets the current devices for plugin from Homeseer
/// </summary>
/// <returns>Current devices for plugin</returns>
/// <exception cref="HspiException"></exception>
private IDictionary <string, DeviceClass> GetCurrentDevices()
{
var deviceEnumerator = HS.GetDeviceEnumerator() as clsDeviceEnumeration;
if (deviceEnumerator == null)
{
throw new HspiException(Invariant($"{Name} failed to get a device enumerator from HomeSeer."));
}
var currentDevices = new Dictionary <string, DeviceClass>();
do
{
CancellationToken.ThrowIfCancellationRequested();
DeviceClass device = deviceEnumerator.GetNext();
if ((device != null) &&
(device.get_Interface(HS) != null) &&
(device.get_Interface(HS).Trim() == Name))
{
string address = device.get_Address(HS);
currentDevices.Add(address, device);
}
} while (!deviceEnumerator.Finished);
return(currentDevices);
}
public override void SetIOMulti(List <CAPI.CAPIControl> colSend)
{
foreach (var control in colSend)
{
try
{
int refId = control.Ref;
DeviceClass deviceClass = (DeviceClass)HS.GetDeviceByRef(refId);
var deviceIdentifier = DeviceIdentifier.Identify(deviceClass);
lock (connectorManagerLock)
{
if (connectorManager.TryGetValue(deviceIdentifier.DeviceId, out var connector))
{
connector.HandleCommand(deviceIdentifier, control.ControlValue, control.ControlUse).Wait();
}
else
{
throw new HspiException(Invariant($"{refId} Device Not Found for processing."));
}
}
}
catch (Exception ex)
{
LogError(Invariant($"Failed With {ExceptionHelper.GetFullMessage(ex)}"));
}
}
}
public void Save(DeviceClass deviceClass)
{
if (deviceClass == null)
{
throw new ArgumentNullException("deviceClass");
}
using (var context = new DeviceHiveContext())
{
context.DeviceClasses.Add(deviceClass);
if (deviceClass.ID > 0)
{
context.Entry(deviceClass).State = EntityState.Modified;
foreach (var equipment in deviceClass.Equipment.Where(e => e.ID > 0))
{
context.Entry(equipment).State = EntityState.Modified;
}
foreach (var equipment in context.Equipments.Where(e => e.DeviceClassID == deviceClass.ID))
{
if (context.Entry(equipment).State == EntityState.Unchanged)
{
context.Equipments.Remove(equipment);
}
}
}
context.SaveChanges();
}
}
/// <summary>
/// 更新设备分类
/// </summary>
/// <param name="model">设备分类对象</param>
/// <returns>返回处理结果</returns>
public CommonResult <DeviceClass> UpdateDeviceClass(DeviceClass model)
{
var result = new CommonResult <DeviceClass>();
try
{
CheckDeviceClass(model, result);
if (result.IsSuccess)
{
var dbSession = new DBService <DeviceClass>().DbSession;
if (dbSession.GetQueryable(t => t.DevCCode == model.DevCCode).FirstOrDefault() == null)
{
result.IsSuccess = false;
result.Message = "设备分类信息不存在";
}
else if (string.IsNullOrEmpty(model.SupCCode) == false && dbSession.GetQueryable(t => t.DevCCode == model.SupCCode).FirstOrDefault() == null)
{
result.IsSuccess = false;
result.Message = "设备分类上级不存在！";
}
else
{
result.Data = dbSession.Update(model);
}
}
}
catch (Exception ex)
{
Utils.Logger.Error(ex.Message);
throw ex;
}
return(result);
}
private void Awake()
{
DeviceChangeDetector = new DeviceChangeDetector();
DeviceChangeDetector.OnDeviceChanged += DeviceChangeDetector_OnDeviceChanged;
Controller = new MAJIKAInput();
CurrentActiveDeviceType = DeviceClass.TouchScreen;
}
private NameValueCollection GetCurrentDeviceImportDevices()
{
HSHelper hsHelper = new HSHelper(HS);
var deviceEnumerator = HS.GetDeviceEnumerator() as clsDeviceEnumeration;
var currentDevices = new NameValueCollection();
var importDevicesData = pluginConfig.ImportDevicesData;
do
{
DeviceClass device = deviceEnumerator.GetNext();
if ((device != null) &&
(device.get_Interface(HS) != null) &&
(device.get_Interface(HS).Trim() == PlugInData.PlugInName))
{
string address = device.get_Address(HS);
var childDeviceData = DeviceIdentifier.Identify(device);
if (childDeviceData != null)
{
if (pluginConfig.ImportDevicesData.TryGetValue(childDeviceData.DeviceId, out var importDeviceData))
{
currentDevices.Add(device.get_Ref(HS).ToString(CultureInfo.CurrentCulture), hsHelper.GetName(device));
}
}
}
} while (!deviceEnumerator.Finished);
return(currentDevices);
}
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 DeviceInstanceImpl(DeviceConfig devconf, DeviceClass devd, DeviceProperty devp)
: base(devconf, devd, devp)
{
devp_ = devp as DevicePropertyImpl;
sampling_timer_.Elapsed += OnSampling;
sampling_timer_.Interval = VOICE_OUTPUT_IVAL;
}
public ConfigForm(DeviceClass SelectedDevice)
{
InitializeComponent();
Debug.Assert(SelectedDevice != null, "Invalid SelectedDevice!");
this.CurrentDevice = SelectedDevice;
//暂时不支持以下界面；
this.tabControl.TabPages.Remove(this.tabPage_PPP);
this.tabControl.TabPages.Remove(this.tabPage_PPPoE);
}
/// <summary>
/// 集中处理操作返回错误码，并生成错误说明信息；
/// </summary>
/// <param name="eCode">tagErrorCode</param>
/// <returns>错误说明信息</returns>
public static string HandleDeviceError(DevControl.tagErrorCode eCode, DeviceClass device)
{
string errorMsg;
if (eCode == DevControl.tagErrorCode.DM_ERR_NOAUTH)
{
LoginForm loginform = new LoginForm();
DialogResult result = loginform.ShowDialog();
if (result == DialogResult.OK)
{
eCode = device.Login(loginform.UserName, loginform.Password);
}
}
errorMsg = HandleError(eCode);
return errorMsg;
}
public static BluetoothDeviceType Create(DeviceClass deviceClass)
{
switch (deviceClass)
{
//Phones
case DeviceClass.Phone:
case DeviceClass.CellPhone:
case DeviceClass.CordlessPhone:
case DeviceClass.SmartPhone:
case DeviceClass.WiredPhone:
return new BluetoothDeviceType(deviceClass.ToString(), BluetoothImages.PhoneIconUri, true, 1);
//Computers
case DeviceClass.Computer:
case DeviceClass.DesktopComputer:
case DeviceClass.ServerComputer:
case DeviceClass.LaptopComputer:
case DeviceClass.HandheldComputer:
case DeviceClass.PdaComputer:
case DeviceClass.WearableComputer:
return new BluetoothDeviceType(deviceClass.ToString(), BluetoothImages.ComputerIconUri, false, 2);
//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:
return new BluetoothDeviceType(deviceClass.ToString(), BluetoothImages.NetworkIconUri, false, 3);
//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:
return new BluetoothDeviceType(deviceClass.ToString(), BluetoothImages.AudioVisualIconUri, false, 3);
//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:
return new BluetoothDeviceType(deviceClass.ToString(), BluetoothImages.PeripheralIconUri, false, 3);
//Imaging/Printers/Cameras
case DeviceClass.Imaging:
case DeviceClass.ImagingDisplay:
case DeviceClass.ImagingCamera:
case DeviceClass.ImagingScanner:
case DeviceClass.ImagingPrinter:
return new BluetoothDeviceType(deviceClass.ToString(), BluetoothImages.ImagingIconUri, false, 3);
////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:
return new BluetoothDeviceType(deviceClass.ToString(), BluetoothImages.MiscellaneousIconUri, false, 3);
}
}
/// <summary>
/// Gets the devices for a particular <see cref="DeviceClass"/> and <see cref="DeviceEnumerationFlags"/>.
/// </summary>
/// <param name="deviceClass">Class of the device.</param>
/// <param name="deviceEnumFlags">The device enum flags.</param>
/// <returns>A collection of <see cref="DeviceInstance"/></returns>
public IList<DeviceInstance> GetDevices(DeviceClass deviceClass, DeviceEnumerationFlags deviceEnumFlags)
{
var enumDevicesCallback = new EnumDevicesCallback();
EnumDevices((int)deviceClass, enumDevicesCallback.NativePointer, IntPtr.Zero, deviceEnumFlags);
return enumDevicesCallback.DeviceInstances;
}
private static void searchCB(IntPtr dev, IntPtr data)
{
uint ipAddr = 0;
StringBuilder devname = new StringBuilder(100);
StringBuilder macAdd = new StringBuilder(100);
DevControl.tagErrorCode eCode = DevControl.DM_GetDeviceInfo(dev, ref ipAddr, macAdd, devname);
if (eCode == DevControl.tagErrorCode.DM_ERR_OK)
{
DeviceClass device = new DeviceClass(dev, ipAddr, macAdd.ToString(), devname.ToString());
DevList.Add(device);
}
else
{
string errMsg = ErrorHandling.GetErrorMsg(eCode);
Log.WriteError(errMsg);
}
}
public static async Task<IList<DeviceInformation>> EnumerateDevices(DeviceClass deviceClass)
{
return (await DeviceInformation.FindAllAsync(deviceClass)).ToList();
}
