~wjc/HomeApp.git

			@@ -37,7 +37,7 @@
			}
			}
			/// <summary>
			/// 本地所有设备的缓存(排序)
			/// 本地所有设备的缓存
			/// </summary>
			public List<CommonDevice> listAllDevice
			{
			@@ -45,28 +45,22 @@
			{
			lock (dicAllDevice)
			{
			var list = new List<CommonDevice>();
			foreach (var device in dicAllDevice.Values)
			//先获取全部的Mac
			var listMac = new List<string>();
			foreach (var strMac in this.dicDeviceEpoint.Keys)
			{
			list.Add(device);
			listMac.Add(strMac);
			}
			return list;
			//根据MAC地址,获取全部回路的设备对象(强制排序)
			return this.GetDevicesByMac(listMac);
			}
			}
			}

			/// <summary>
			/// R文件里面设备模块ID的翻译名字的前缀
			/// 设备的模块ID的枚举 keys:模块ID (Axxx代表是第三方设备)
			/// </summary>
			public const string deviceModelIdName = "uDeviceModelId";
			/// <summary>
			/// R文件里面设备默认名字的ID
			/// </summary>
			public Dictionary<string, int> dicDeviceDefultNameID = null;
			/// <summary>
			/// 设备的模块ID的枚举(keys:模块ID value:设备具体类型值-设备所属类型值(自定义的值,嘛,只要不重复就可以)
			/// </summary>
			private Dictionary<string, string> dicDeviceModelIdEnum = null;
			private Dictionary<string, DeviceNameContent> dicDeviceModelIdEnum = null;
			/// <summary>
			/// 需要转换的设备的模块ID(keys:旧模块ID,value:新模块ID)
			/// </summary>
			@@ -103,9 +97,9 @@
			{
			this.dicAllDevice.Clear();
			this.dicDeviceEpoint.Clear();

			//初始化R文件里面设备默认名字的ID
			this.InitDeviceDefultNameIDList();

			//初始化设备枚举
			this.InitDeviceModelIdEnum();

			//获取本地全部的设备文件
			List<string> listFile = this.GetAllDeviceFile();
			@@ -121,12 +115,6 @@

			if (device == null \|\| device.CurrentGateWayId == null)
			{
			#if DEBUG
			//调查,为什么它会把全部设备删掉？
			string file1 = UserCenterLogic.CombinePath(file);
			string file2 = UserCenterLogic.CombinePath("Back_" + file);
			System.IO.File.Copy(file1, file2, true);
			#endif
			//失效的文件，没有网关id的都删除掉
			Global.DeleteFilebyHomeId(file);
			continue;
			@@ -141,12 +129,6 @@
			}
			else
			{
			#if DEBUG
			//调查,为什么它会把全部设备删掉？
			string file1 = UserCenterLogic.CombinePath(file);
			string file2 = UserCenterLogic.CombinePath("Back_" + file);
			System.IO.File.Copy(file1, file2, true);
			#endif
			//如果是主人,或者管理员,那么这个文件是非法的,直接删除
			Global.DeleteFilebyHomeId(file);
			continue;
			@@ -209,7 +191,7 @@
			var listGateway = HdlGatewayLogic.Current.GetAllLocalGateway();
			foreach (var gateway in listGateway)
			{
			string gwId = HdlGatewayLogic.Current.GetGatewayId(gateway);
			string gwId = gateway.GwId;
			if (listId.Contains(gwId) == false)
			{
			//这个网关对于当前这个成员来说是非法的
			@@ -227,12 +209,13 @@
			/// <para>-1:异常 1:正常 2:设备信息缺损</para>
			/// </summary>
			/// <param name="zbGateway">网关对象</param>
			public int SetDeviceToMemmoryByGateway(ZbGateway zbGateway)
			/// <param name="useLocalConnect">是否强制使用本地连接发送</param>
			public int SetDeviceToMemmoryByGateway(ZbGateway zbGateway, bool useLocalConnect)
			{
			//从网关获取全部的设备
			int statu = 0;
			List<CommonDevice> listDevice = new List<CommonDevice>();
			List<CommonDevice> list = this.GetDeviceListFromGateway(zbGateway, ref statu, true);
			List<CommonDevice> list = this.GetDeviceListFromGateway(zbGateway, ref statu, useLocalConnect);
			if (list == null)
			{
			return -1;
			@@ -240,8 +223,17 @@
			listDevice.AddRange(list);

			//获取这个网关的本地所有设备
			string gwID = HdlGatewayLogic.Current.GetGatewayId(zbGateway);
			string gwID = zbGateway.GwId;
			List<CommonDevice> listLocalDevices = this.GetDeviceByGatewayID(gwID);
			//获取ota设备
			foreach (var ota in this.dicOTADevice.Values)
			{
			if (ota.CurrentGateWayId == gwID)
			{
			listLocalDevices.Add(ota);
			}
			}

			Dictionary<string, CommonDevice> dicExist = new Dictionary<string, CommonDevice>();
			foreach (var device in listLocalDevices)
			{
			@@ -250,6 +242,7 @@
			}

			//添加设备的缓存
			var listDriveDevice = new List<CommonDevice>();
			for (int i = 0; i < listDevice.Count; i++)
			{
			var device = listDevice[i];
			@@ -267,47 +260,47 @@
			dicExist.Remove(maikey);
			}
			//获取设备的固定属性
			HdlDeviceFixedAttributeLogic.Current.SetAllFixedAttributeToDevice(device);
			}

			for (int i = 0; i < listDevice.Count; i++)
			{
			var device = listDevice[i];
			//对未命名的设备重新命名
			if (this.GetSimpleEpointName(device) == string.Empty)
			if (HdlDeviceFixedAttributeLogic.Current.SetAllFixedAttributeToDevice(device) == true)
			{
			//根据设备类型获取名称
			var dName = this.GetDeviceObjectText(new List<CommonDevice>() { device }, false);
			//虚拟设备的话，附加回路号
			if (device.DriveCode > 0)
			{
			//在端点名字的后面附加【回路】字样
			dName += "(" + device.DeviceEpoint + Language.StringByID(R.MyInternationalizationString.uDeviceCircuit) + ")";
			}
			//多回路设备的话，附加回路号
			else if (dicDeviceEpoint.ContainsKey(device.DeviceAddr) == true && dicDeviceEpoint[device.DeviceAddr].Count > 1)
			{
			var arry = dName.Split(new string[] { "(" }, StringSplitOptions.RemoveEmptyEntries);
			dName = arry[0].Trim();
			//在端点名字的后面附加【回路】字样
			dName += "(" + device.DeviceEpoint + Language.StringByID(R.MyInternationalizationString.uDeviceCircuit) + ")";
			}

			HdlThreadLogic.Current.RunThread(async () =>
			{
			await this.ReName(device, dName, ShowErrorMode.NO);
			});
			System.Threading.Thread.Sleep(200);
			}
			//对未命名的虚拟设备重新命名
			if (device.DriveCode > 0 && this.GetSimpleEpointName(device) == string.Empty)
			{
			listDriveDevice.Add(device);
			}
			}
			//设置虚拟设备的默认名字
			this.SetDriveDeviceDefultName(listDriveDevice);

			//只有完全获取的时候,才会去处理删除的问题
			if (statu == 1)
			if (statu != 1)
			{
			//如果本地和网关的设备不一致的时候，删除本地的设备
			foreach (var device in dicExist.Values)
			return statu;
			}

			//如果本地和网关的设备不一致的时候，删除本地的设备
			var listDeleteMac = new List<string>();
			foreach (var device in dicExist.Values)
			{
			if (device is OTADevice)
			{
			this.DeleteMemmoryOtaDevice(device.DeviceAddr);
			}
			else
			{
			this.DeleteMemmoryDevice(device, true);
			}
			if (listDeleteMac.Contains(device.DeviceAddr) == false)
			{
			//收集被删除的Mac
			listDeleteMac.Add(device.DeviceAddr);
			}
			}
			if (listDeleteMac.Count > 0)
			{
			//将真实物理设备从房间中移除
			this.DeleteRealDeviceFromRoom(listDeleteMac);
			}

			return statu;
			@@ -333,6 +326,8 @@
			var tempDevice = this.dicOTADevice[mainKeys];
			//将DeviceInfo的属性设置到主属性中
			this.SetDeviceInfoToMain(tempDevice, device);
			//刷新设备功能类型(这个东西需要独立出来)
			this.RefreshDeviceFunctionType(tempDevice, device, false);
			device = tempDevice;
			}

			@@ -354,6 +349,8 @@
			var tempDevice = this.dicAllDevice[mainKeys];
			//将DeviceInfo的属性设置到主属性中
			this.SetDeviceInfoToMain(tempDevice, device);
			//刷新设备功能类型(这个东西需要独立出来)
			this.RefreshDeviceFunctionType(tempDevice, device, false);
			device = tempDevice;
			}
			else
			@@ -381,28 +378,57 @@
			}
			}

			/// <summary>
			/// 添加虚拟设备到缓存
			/// </summary>
			/// <param name="device">设备对象</param>
			public void AddVirtualDeviceToMemory(CommonDevice device)
			{
			string mainKeys = this.GetDeviceMainKeys(device);
			this.dicAllDevice[mainKeys] = device;

			//设备回路收集
			if (this.dicDeviceEpoint.ContainsKey(device.DeviceAddr) == false)
			{
			this.dicDeviceEpoint[device.DeviceAddr] = new HashSet<int>();
			}
			if (this.dicDeviceEpoint[device.DeviceAddr].Contains(device.DeviceEpoint) == false)
			{
			this.dicDeviceEpoint[device.DeviceAddr].Add(device.DeviceEpoint);
			}
			device.ReSave();
			}

			#endregion

			#region ■ 修改设备___________________________

			/// <summary>
			/// 更改名字并且刷新缓存(修改失败时，会显示信息)
			/// 更改端点名字并且刷新缓存(修改失败时，会显示信息)
			/// </summary>
			/// <param name="device">设备对象</param>
			/// <param name="newName">新名字</param>
			/// <param name="mode">是否显示错误</param>
			public async Task<bool> ReName(CommonDevice device, string newName, ShowErrorMode mode = ShowErrorMode.YES)
			public bool ReName(CommonDevice device, string newName, ShowErrorMode mode = ShowErrorMode.YES)
			{
			//先别管那么多，更改名字后，刷新设备缓存
			this.SetEpointName(device, newName);

			this.BackupDeviceAfterReName(device);

			//如果住宅为虚拟住宅
			if (Common.Config.Instance.Home.IsVirtually == true)
			{
			//修改设备名字的话,主页需要重新刷新
			Phone.UserView.UserPage.Instance.RefreshAllForm = true;
			return true;
			}

			//不再检测名字是否一样
			//成员只能修改自己本地的名字
			if (UserCenterResourse.UserInfo.AuthorityNo != 3)
			{
			var result = await device.RenameDeviceNameAsync(device.DeviceAddr, device.DeviceEpoint, newName);
			var result = this.RenameDeviceNameAsync(device, newName);
			if (result == null \|\| result.deviceRenameData == null \|\| result.deviceRenameData.Result == 1)
			{
			//设备名称修改失败
			@@ -416,9 +442,9 @@
			}
			return false;
			}
			//备份数据
			await HdlGatewayLogic.Current.UpLoadDeviceBackupDataToGateway(device, GatewayBackupEnum.A端点名称, newName);
			}
			//修改设备名字的话,主页需要重新刷新
			Phone.UserView.UserPage.Instance.RefreshAllForm = true;
			return true;
			}

			@@ -428,7 +454,7 @@
			/// <param name="listDevice">设备对象</param>
			/// <param name="newMacName">新名字</param>
			/// <param name="mode">是否显示错误</param>
			public async Task<bool> ReMacName(List<CommonDevice> listDevice, string newMacName, ShowErrorMode mode = ShowErrorMode.YES)
			public bool ReMacName(List<CommonDevice> listDevice, string newMacName, ShowErrorMode mode = ShowErrorMode.YES)
			{
			if (listDevice.Count == 0)
			{
			@@ -444,6 +470,11 @@
			//更改名字后，刷新设备缓存
			this.BackupDeviceAfterReName(device2);
			}
			//如果住宅为虚拟住宅
			if (Common.Config.Instance.Home.IsVirtually == true)
			{
			return true;
			}

			CommonDevice device = listDevice[0];
			//不再检测名字是否一样
			@@ -451,7 +482,7 @@
			if (UserCenterResourse.UserInfo.AuthorityNo != 3)
			{
			//修改物理名字
			var result = await device.RenameDeviceMacNameAsync(device.DeviceAddr, device.DeviceEpoint, newMacName);
			var result = this.RenameDeviceMacNameAsync(device, newMacName);
			if (result == null \|\| result.renameDeviceMacNameData == null \|\| result.renameDeviceMacNameData.Result != 0)
			{
			//设备名称修改失败
			@@ -464,15 +495,162 @@
			}
			return false;
			}
			//备份数据
			await HdlGatewayLogic.Current.UpLoadDeviceBackupDataToGateway(device, GatewayBackupEnum.AMac名称, newMacName);
			//如果它只有一个回路,则更改端点名字
			if (this.dicDeviceEpoint.ContainsKey(device.DeviceAddr) == true && this.dicDeviceEpoint[device.DeviceAddr].Count == 1)
			if (this.dicDeviceEpoint.ContainsKey(device.DeviceAddr) == true)
			{
			return await this.ReName(device, newMacName);
			//只有一个端点
			if (this.dicDeviceEpoint[device.DeviceAddr].Count == 1)
			{
			return this.ReName(device, newMacName);
			}
			//如果它有两个端点时,pir传感器特殊处理
			else if (this.dicDeviceEpoint[device.DeviceAddr].Count == 2)
			{
			var myType = this.GetMyDeviceEnumInfo(listDevice);
			if (myType.ConcreteType == DeviceConcreteType.Sensor_Pir)
			{
			foreach (var myDevice in listDevice)
			{
			if (myDevice.Type == DeviceType.IASZone)
			{
			return this.ReName(myDevice, newMacName);
			}
			}
			}
			}
			}
			}
			return true;
			}

			/// <summary>
			/// 设置虚拟设备的默认名字
			/// </summary>
			/// <param name="listDriveDevice">虚拟设备列表</param>
			private void SetDriveDeviceDefultName(List<CommonDevice> listDriveDevice)
			{
			if (listDriveDevice.Count == 0)
			{
			return;
			}
			//如果虚拟设备还没有名字的话
			HdlThreadLogic.Current.RunThread(() =>
			{
			//如果不这样放在一个线程里,有可能对Dictionary产生影响
			foreach (var myDevice in listDriveDevice)
			{
			string dName = string.Empty;
			if (this.IsMiniLight(myDevice) == true)
			{
			//Mini夜灯
			dName = Language.StringByID(R.MyInternationalizationString.uMiniNightLight);
			}
			else
			{
			//根据设备类型获取名称
			dName = this.GetDeviceObjectText(new List<CommonDevice>() { myDevice }, false);
			//在端点名字的后面附加【回路】字样
			dName += "(" + myDevice.DeviceEpoint + Language.StringByID(R.MyInternationalizationString.uDeviceCircuit) + ")";
			}
			this.ReName(myDevice, dName, ShowErrorMode.NO);

			System.Threading.Thread.Sleep(100);
			}
			});
			}

			///<summary >
			/// 修改设备mac名称
			/// <para>macName:设备名称</para>
			/// </summary>
			private CommonDevice.RenameDeviceMacNameAllData RenameDeviceMacNameAsync(CommonDevice device, string macName)
			{
			//如果当前是虚拟住宅
			if (Common.Config.Instance.Home.IsVirtually == true)
			{
			return Phone.TemplateData.TemplateDeviceDataLogic.Current.ReDeviceMacName(device, macName);
			}

			//获取编辑设备Mac名字的命令字符
			var sendData = this.GetReDeviceMacNameCommandText(device.DeviceAddr, device.DeviceEpoint, macName);
			var result = HdlDeviceCommonLogic.Current.SendJobjectDataToGateway(device, "MacRename", sendData, "MacRename_Respon", 8);
			if (result.ErrorMsg != null \|\| result.ErrorMsgDiv == 0)
			{
			return null;
			}
			//加缓存
			Phone.TemplateData.TemplateDeviceDataLogic.Current.ReDeviceMacName(device, macName);

			var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.RenameDeviceMacNameData>(result.ReceiptData);
			return new CommonDevice.RenameDeviceMacNameAllData { renameDeviceMacNameData = tempData };
			}

			/// <summary>
			/// 修改设备端口（按键）名称
			/// </summary>
			/// <param name="device">设备对象</param>
			/// <param name="deviceName">设备端点名字</param>
			/// <returns></returns>
			private CommonDevice.DeviceRenameAllData RenameDeviceNameAsync(CommonDevice device, string deviceName)
			{
			//如果当前是虚拟住宅
			if (Common.Config.Instance.Home.IsVirtually == true)
			{
			return Phone.TemplateData.TemplateDeviceDataLogic.Current.ReDeviceEpointName(device, deviceName);
			}
			//获取编辑设备端点名字的命令字符
			var sendData = this.GetReDeviceEpointNameCommandText(device.DeviceAddr, device.DeviceEpoint, deviceName);
			var result = HdlDeviceCommonLogic.Current.SendJobjectDataToGateway(device, "DeviceRename", sendData, "DeviceRenameRespon", 8);
			if (result.ErrorMsg != null \|\| result.ErrorMsgDiv == 0)
			{
			return null;
			}
			//加缓存
			Phone.TemplateData.TemplateDeviceDataLogic.Current.ReDeviceEpointName(device, deviceName);

			var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.DeviceRenameResponseData>(result.ReceiptData);
			return new CommonDevice.DeviceRenameAllData { deviceRenameData = tempData };
			}

			/// <summary>
			/// 获取编辑设备Mac名字的命令字符
			/// </summary>
			/// <param name="deviceAddr"></param>
			/// <param name="deviceEpoint"></param>
			/// <param name="deviceName"></param>
			/// <returns></returns>
			public string GetReDeviceMacNameCommandText(string deviceAddr, int deviceEpoint, string deviceName)
			{
			var bytes = new byte[64];
			var reamarkGwBytes = Encoding.UTF8.GetBytes(deviceName);
			System.Array.Copy(reamarkGwBytes, 0, bytes, 0, 64 < reamarkGwBytes.Length ? 64 : reamarkGwBytes.Length);
			deviceName = Encoding.UTF8.GetString(bytes);

			var jObject = new Newtonsoft.Json.Linq.JObject { { "DeviceAddr", deviceAddr }, { "Epoint", deviceEpoint }, { "Cluster_ID", 0 }, { "Command", 100 } };
			var data = new Newtonsoft.Json.Linq.JObject { { "MacName", deviceName } };
			jObject.Add("Data", data);
			return jObject.ToString();
			}

			/// <summary>
			/// 获取编辑设备端点名字的命令字符
			/// </summary>
			/// <param name="deviceAddr"></param>
			/// <param name="deviceEpoint"></param>
			/// <param name="deviceName"></param>
			/// <returns></returns>
			public string GetReDeviceEpointNameCommandText(string deviceAddr, int deviceEpoint, string deviceName)
			{
			var bytes = new byte[64];
			var reamarkGwBytes = Encoding.UTF8.GetBytes(deviceName);
			System.Array.Copy(reamarkGwBytes, 0, bytes, 0, 64 < reamarkGwBytes.Length ? 64 : reamarkGwBytes.Length);
			deviceName = Encoding.UTF8.GetString(bytes);

			var jObject = new Newtonsoft.Json.Linq.JObject { { "DeviceAddr", deviceAddr }, { "Epoint", deviceEpoint }, { "Cluster_ID", 0 }, { "Command", 96 } };
			var data = new Newtonsoft.Json.Linq.JObject { { "DeviceName", deviceName } };
			jObject.Add("Data", data);

			return jObject.ToString();
			}

			/// <summary>
			@@ -484,15 +662,25 @@
			lock (dicAllDevice)
			{
			string mainKeys = this.GetDeviceMainKeys(device);
			if (this.dicAllDevice.ContainsKey(mainKeys) == false)
			if (this.dicAllDevice.ContainsKey(mainKeys) == true)
			{
			return;
			}
			this.dicAllDevice[mainKeys] = device;
			device.ReSave();
			//一般设备
			this.dicAllDevice[mainKeys] = device;
			device.ReSave();

			//添加自动备份
			HdlAutoBackupLogic.AddOrEditorFile(device.FilePath);
			//添加自动备份
			HdlAutoBackupLogic.AddOrEditorFile(device.FilePath);
			}
			else if (this.dicOTADevice.ContainsKey(mainKeys) == true)
			{
			//Ota设备
			this.dicOTADevice[mainKeys] = (OTADevice)device;
			device.ReSave();

			//添加自动备份
			HdlAutoBackupLogic.AddOrEditorFile(device.FilePath);

			}
			}
			}

			@@ -506,29 +694,36 @@
			/// <param name="listdevice">设备对象(MAC地址必须要相同)</param>
			public async Task<bool> DeleteDevice(List<CommonDevice> listdevice)
			{
			var data = new CommonDevice.RemoveDeviceData();
			var info = new CommonDevice.RemoveDeviceListInfo();
			info.DeviceAddr = listdevice[0].DeviceAddr;
			data.DeviceAddrList.Add(info);

			//删一次的时候，它会把MAC地址下面全部的设备都删除
			var result = await listdevice[0].DeleteDeviceAsync(data);
			if (result == null \|\| result.removeDeviceResponseData == null \|\| result.removeDeviceResponseData.Result != 0)
			//虚拟住宅的话,不需要删除网关的设备
			if (Config.Instance.Home.IsVirtually == false)
			{
			//设备删除失败
			string msg = Language.StringByID(R.MyInternationalizationString.uDeviceDeleteFail);
			//拼接上【网关回复超时】的Msg
			msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result);
			var data = new CommonDevice.RemoveDeviceData();
			var info = new CommonDevice.RemoveDeviceListInfo();
			info.DeviceAddr = listdevice[0].DeviceAddr;
			data.DeviceAddrList.Add(info);

			this.ShowErrorMsg(msg);
			return false;
			//删一次的时候，它会把MAC地址下面全部的设备都删除
			var result = await listdevice[0].DeleteDeviceAsync(data);
			if (result == null \|\| result.removeDeviceResponseData == null \|\| result.removeDeviceResponseData.Result != 0)
			{
			//设备删除失败
			string msg = Language.StringByID(R.MyInternationalizationString.uDeviceDeleteFail);
			//拼接上【网关回复超时】的Msg
			msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result);

			this.ShowErrorMsg(msg);
			return false;
			}
			}

			//删除文件
			//删除缓存的Ota设备
			this.DeleteMemmoryOtaDevice(listdevice[0].DeviceAddr);
			//删除一般设备文件
			foreach (CommonDevice device in listdevice)
			{
			this.DeleteMemmoryDevice(device);
			}

			if (this.dicDeviceRoomId.ContainsKey(listdevice[0].DeviceAddr) == true)
			{
			//移除真实设备的房间索引
			@@ -539,18 +734,21 @@
			}

			/// <summary>
			/// 删除缓存的设备
			/// 删除缓存的一般设备
			/// </summary>
			/// <param name="device">设备对象</param>
			/// <param name="deleteRoom">是否从房间删除</param>
			public void DeleteMemmoryDevice(CommonDevice device, bool deleteRoom = true)
			{
			if (deleteRoom == true && Room.CurrentRoom != null)
			//删除缓存设备的话,主页需要重新刷新
			Phone.UserView.UserPage.Instance.RefreshAllForm = true;

			if (deleteRoom == true)
			{
			//从房间中删除
			Room.CurrentRoom.DeleteDevice(device);
			HdlRoomLogic.Current.DeleteDevice(device);
			//删除我的喜爱的设备
			Room.CurrentRoom.DeleteLoveDevice(device);
			HdlRoomLogic.Current.DeleteLoveDevice(device);
			}

			//删除缓存
			@@ -560,6 +758,11 @@
			if (this.dicAllDevice.ContainsKey(mainKeys) == true)
			{
			this.dicAllDevice.Remove(mainKeys);
			}
			if (this.dicDeviceEpoint.ContainsKey(device.DeviceAddr) == true)
			{
			//变更端点数
			this.dicDeviceEpoint[device.DeviceAddr].Remove(device.DeviceEpoint);
			}
			}

			@@ -580,9 +783,17 @@
			HdlAutoBackupLogic.DeleteFile(device.FilePath);
			}
			}
			}

			/// <summary>
			/// 删除缓存的Ota设备
			/// </summary>
			/// <param name="macAdrr"></param>
			/// <param name="ePoint"></param>
			public void DeleteMemmoryOtaDevice(string macAdrr, int ePoint = 200)
			{
			//删除200端口文件
			string otaKeys = this.GetDeviceMainKeys(device.DeviceAddr, 200);
			string otaKeys = this.GetDeviceMainKeys(macAdrr, ePoint);
			if (this.dicOTADevice.ContainsKey(otaKeys) == true)
			{
			string otaFile = this.dicOTADevice[otaKeys].FilePath;
			@@ -591,12 +802,12 @@
			if (UserCenterResourse.UserInfo.AuthorityNo == 3)
			{
			//成员的话,直接删除,没有商量的余地
			Global.DeleteFilebyHomeId(filePath);
			Global.DeleteFilebyHomeId(otaFile);
			}
			else
			{
			//变更：搞掉它,不留了
			Global.DeleteFilebyHomeId(filePath);
			Global.DeleteFilebyHomeId(otaFile);
			//删除自动备份
			HdlAutoBackupLogic.DeleteFile(otaFile);
			}
			@@ -607,6 +818,33 @@

			#endregion

			#region ■ 同步设备___________________________
			/// <summary>
			/// 同步设备并且刷新缓存(同步失败时，会显示信息)
			/// </summary>
			/// <param name="litdevice">设备对象(MAC地址必须要相同)</param>
			public async Task<bool> SynchronizationDevice(List<CommonDevice> listdevice)
			{
			//虚拟住宅的话,不需要删除网关的设备
			if (Config.Instance.Home.IsVirtually == false)
			{
			//同步
			var result = await listdevice[0].SyncMsgToBindSource(listdevice[0].DeviceAddr, listdevice[0].DeviceEpoint);
			if (result == null \|\| result.result != 0)
			{
			//同步删除失败
			string msg = Language.StringByID(R.MyInternationalizationString.SynchronizationFailed);
			//拼接上【网关回复超时】的Msg
			msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result);

			this.ShowErrorMsg(msg);
			return false;
			}
			}
			return true;
			}
			#endregion

			#region ■ 测试设备___________________________

			/// <summary>
			@@ -615,7 +853,11 @@
			/// <param name="device"></param>
			public void SetFixedPositionCommand(CommonDevice device)
			{
			device.IdentifyControl(device.DeviceAddr, device.DeviceEpoint, 5);
			//如果当前住宅不是虚拟住宅
			if (Common.Config.Instance.Home.IsVirtually == false)
			{
			device.IdentifyControl(device.DeviceAddr, device.DeviceEpoint, 5);
			}
			}

			/// <summary>
			@@ -625,6 +867,32 @@
			/// <returns></returns>
			public bool DeviceIsCanFixedPosition(CommonDevice device)
			{
			if (device.Type == DeviceType.DoorLock \|\| device.Type == DeviceType.PMSensor)
			{
			//门锁没有定位功能
			return false;
			}
			var myTypeInfo = this.GetMyDeviceEnumInfo(new List<CommonDevice>() { device });
			if (device.Type == DeviceType.IASZone)
			{
			if (myTypeInfo.ConcreteType == DeviceConcreteType.Sensor_Pir)
			{
			//传感器除了Pir都没有定位功能
			return true;
			}
			else if (myTypeInfo.ConcreteType == DeviceConcreteType.Sensor_SphericalMotion)
			{
			//球型移动传感器虽然是电池设备,但是它有定位功能
			return true;
			}
			return false;
			}
			//温湿度传感器没有定位功能
			if (myTypeInfo.ConcreteType == DeviceConcreteType.Sensor_TemperatureHumidity)
			{
			return false;
			}

			foreach (var data in device.InClusterList)
			{
			//拥有on/off功能的，才支持测试
			@@ -632,6 +900,22 @@
			{
			return true;
			}
			}
			return false;
			}

			/// <summary>
			/// 检测设备是否拥有一键同步功能
			/// </summary>
			/// <param name="device"></param>
			/// <returns></returns>
			public bool DeviceIsCanSynchronization(CommonDevice device)
			{
			//获取设备类型的
			var deviceEnumInfo = Common.LocalDevice.Current.GetMyDeviceEnumInfo(new List<CommonDevice>() { device });
			if (deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_SimpleMultifunction)
			{
			return true;
			}
			return false;
			}
			@@ -679,24 +963,23 @@
			/// <summary>
			/// 根据网关ID获取所有的设备
			/// </summary>
			/// <param name="gwId">网关ID</param>
			/// <param name="gwId">网关ID</param>>
			/// <returns></returns>
			public List<CommonDevice> GetDeviceByGatewayID(string gwId)
			{
			List<CommonDevice> list = new List<CommonDevice>();
			lock (dicAllDevice)
			{
			//各网关的所有设备
			var listMac = new List<string>();
			//各网关的所有设备的Mac
			foreach (CommonDevice device in this.dicAllDevice.Values)
			{
			if (gwId == device.CurrentGateWayId)
			{
			list.Add(device);
			listMac.Add(device.DeviceAddr);
			}
			}
			return this.GetDevicesByMac(listMac);
			}

			return list;
			}

			/// <summary>
			@@ -767,6 +1050,122 @@
			}

			/// <summary>
			/// 根据MAC地址,获取简约面板全部回路的设备对象
			/// </summary>
			/// <param name="listDevice"></param>
			/// <returns></returns>
			public List<CommonDevice> GetMutilfunctionPanelByMac(List<CommonDevice> listDevice, bool sort = true)
			{
			//和彪哥、设备和产品部同事确认：
			//简约多功能面板[不显示多余的回路，只显示携带的2个继电器，1个温度传感器，1个湿度传感器
			var list = new List<CommonDevice>();
			foreach (var dev in listDevice)
			{
			if (dev.Type == DeviceType.TemperatureSensor)
			{
			if (dev.DeviceEpoint == 64)
			{
			list.Add(dev);
			}
			}
			else if (dev.Type == DeviceType.FreshAirHumiditySensor)
			{
			if (dev.DeviceEpoint == 65)
			{
			list.Add(dev);
			}
			}
			else if (dev.Type == DeviceType.OnOffOutput)
			{
			list.Add(dev);
			}
			}

			if (sort == false)
			{
			return list;
			}
			list.Sort((obj1, obj2) =>
			{
			if (obj1.DeviceEpoint > obj2.DeviceEpoint)
			{
			return 1;
			}
			return -1;
			});

			return list;
			}

			/// <summary>
			/// 根据MAC地址,获取新风、简约环境面板全部回路的设备对象
			/// </summary>
			/// <param name="listDevice"></param>
			/// <returns></returns>
			public List<CommonDevice> GetPanelMatchEpointByMac(List<CommonDevice> listDevice, bool sort = true)
			{
			var list = new List<CommonDevice>();
			foreach (var dev in listDevice)
			{
			if (dev.Type == DeviceType.TemperatureSensor)
			{
			list.Add(dev);
			}
			else if (dev.Type == DeviceType.FreshAirHumiditySensor)
			{
			list.Add(dev);
			}
			}
			if (sort == false)
			{
			return list;
			}
			list.Sort((obj1, obj2) =>
			{

			if (obj1.DeviceEpoint > obj2.DeviceEpoint)
			{
			return 1;
			}
			return -1;
			});
			return list;
			}

			/// <summary>
			/// 根据MAC地址,获取全部回路的设备对象(强制排序)
			/// </summary>
			/// <param name="DeviceAddr">Mac地址</param>
			/// <returns></returns>
			public List<CommonDevice> GetDevicesByMac(List<string> listMacAddr)
			{
			//先排序
			listMacAddr.Sort();

			var list = new List<CommonDevice>();
			foreach (string strMac in listMacAddr)
			{
			var listEpoint = new List<int>();
			//获取全部的端点
			foreach (int epoint in this.dicDeviceEpoint[strMac])
			{
			listEpoint.Add(epoint);
			}
			//然后排序
			listEpoint.Sort();
			foreach (int epoint in listEpoint)
			{
			var device = this.GetDevice(strMac, epoint);
			if (device != null)
			{
			list.Add(device);
			}
			}
			}
			return list;
			}

			/// <summary>
			/// 根据MAC地址,获取全部回路的数量
			/// </summary>
			/// <param name="DeviceAddr">Mac地址</param>
			@@ -787,7 +1186,7 @@
			public List<string> GetAllDeviceFile()
			{
			List<string> listDeviceFile = new List<string>();
			List<string> listAllFile = Global.FileListByHomeId();
			List<string> listAllFile = HdlFileLogic.Current.GetRootPathListFile();

			foreach (string file in listAllFile)
			{
			@@ -817,6 +1216,104 @@
			return this.dicOTADevice[mainkeys];
			}

			/// <summary>
			/// 获取特殊的,没有其他回路,单纯只有200端点的OTA设备
			/// </summary>
			/// <param name="gwId">网关ID</param>
			/// <returns></returns>
			public List<OTADevice> GetSpecialOtaDevice(string gwId)
			{
			var list = new List<OTADevice>();
			foreach (var ota in this.dicOTADevice.Values)
			{
			if (ota.CurrentGateWayId != gwId)
			{
			//不是同一个网关
			continue;
			}
			//没有其他回路
			if (dicDeviceEpoint.ContainsKey(ota.DeviceAddr) == false
			\|\| dicDeviceEpoint[ota.DeviceAddr].Count == 0)
			{
			//目前只针对中央空调
			if (ota.ModelIdentifier == "MAC/GW-ZB.10")
			{
			list.Add(ota);
			}
			}
			}
			return list;
			}

			#endregion

			#region ■ 获取设备信息_______________________

			/// <summary>
			/// 读取单个端点回路设备信息
			/// </summary>
			/// <param name="device">设备对象</param>
			/// <returns></returns>
			public CommonDevice.DeviceInfoData ReadDeviceEpointDeviceInfo(CommonDevice device)
			{
			var jObject = new Newtonsoft.Json.Linq.JObject { { "DeviceAddr", device.DeviceAddr }, { "Epoint", device.DeviceEpoint }, { "Cluster_ID", 0 }, { "Command", 80 } };
			var result = HdlDeviceCommonLogic.Current.SendJobjectDataToGateway(device, "GetStatusRecord", jObject.ToString(), "GetStatusRecord_Respon");
			if (result.ErrorMsg != null \|\| result.ErrorMsgDiv == 0)
			{
			return null;
			}
			var info = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.DeviceInfoData>(result.ReceiptData);
			return info;
			}

			#endregion

			#region ■ 设置设备功能类型___________________

			/// <summary>
			/// 设置设备功能类型到网关
			/// </summary>
			/// <param name="device">设备回路</param>
			/// <param name="functionType">功能类型</param>
			/// <returns></returns>
			public bool SendDeviceFunctionTypeToGateway(CommonDevice device, DeviceFunctionType functionType)
			{
			//如果是虚拟住宅
			if (Common.Config.Instance.Home.IsVirtually == true)
			{
			device.DfunctionType = functionType;
			return true;
			}
			//获取命令字符
			var sendCommond = this.GetDeviceFunctionTypeCommandText(device, functionType);
			var result = HdlDeviceCommonLogic.Current.SendJobjectDataToGateway(device, "Device/SetEPDeviceFunctionType", sendCommond, "Device/SetEPDeviceFunctionTypeRespon");
			if (result.ErrorMsg != null \|\| result.ErrorMsgDiv == 0)
			{
			return false;
			}
			var resultData = Newtonsoft.Json.Linq.JObject.Parse(result.ReceiptData);
			if (resultData.Property("Result") != null)
			{
			//0:修改成功 1:修改失败
			return resultData["Result"].ToString() == "0";
			}
			return false;
			}

			/// <summary>
			/// 获取更改设备功能类型的命令文本
			/// </summary>
			/// <param name="device"></param>
			/// <param name="functionType"></param>
			/// <returns></returns>
			public string GetDeviceFunctionTypeCommandText(CommonDevice device, DeviceFunctionType functionType)
			{
			var jObject = new Newtonsoft.Json.Linq.JObject { { "DeviceAddr", device.DeviceAddr }, { "Epoint", device.DeviceEpoint }, { "Cluster_ID", 0 }, { "Command", 110 } };
			var data = new Newtonsoft.Json.Linq.JObject { { "FunctionType", (int)functionType } };
			jObject.Add("Data", data);
			return jObject.ToString();
			}

			#endregion

			#region ■ 获取设备名称_______________________
			@@ -833,18 +1330,98 @@
			{
			return dName;
			}
			//根据设备类型获取名称
			dName = this.GetDeviceObjectText(new List<CommonDevice>() { device }, false);
			//如果是虚拟设备
			if (device.DriveCode > 0
			\|\| (this.dicDeviceEpoint.ContainsKey(device.DeviceAddr) == true && this.dicDeviceEpoint[device.DeviceAddr].Count > 1))
			if (this.IsMiniLight(device) == true)
			{
			var arry = dName.Split(new string[] { "(" }, StringSplitOptions.RemoveEmptyEntries);
			dName = arry[0].Trim();
			//在端点名字的后面附加【回路】字样
			dName += "(" + device.DeviceEpoint + Language.StringByID(R.MyInternationalizationString.uDeviceCircuit) + ")";
			//Mini夜灯
			return Language.StringByID(R.MyInternationalizationString.uMiniNightLight);
			}
			return dName;

			//如果这个设备只有一个回路的话,返回Mac名字给它
			if (this.GetDevicesCountByMac(device.DeviceAddr) <= 1)
			{
			return this.GetDeviceMacName(device);
			}

			//同一设备里面,不同类型的回路,它的命名都从1开始
			int epointNo = 0;
			var listSort = this.GetDevicesByMac(device.DeviceAddr);
			foreach (var myDevice in listSort)
			{
			if (myDevice.Type == device.Type)
			{
			//同一类型编号+1
			epointNo++;
			if (myDevice.DeviceEpoint == device.DeviceEpoint)
			{
			//已经到达它自己
			break;
			}
			}
			}

			if (device.Type == DeviceType.OnOffOutput
			\|\| device.Type == DeviceType.DimmableLight
			\|\| device.Type == DeviceType.ColorDimmableLight
			\|\| device.Type == DeviceType.ColorTemperatureLight)
			{
			//继电器,掉光器都叫回路
			return Language.StringByID(R.MyInternationalizationString.uDeviceCircuit) + epointNo;
			}
			if (device.Type == DeviceType.Thermostat)
			{
			//空调都叫室内机
			return Language.StringByID(R.MyInternationalizationString.uIndoorUnit) + epointNo;
			}

			//获取设备类型
			var deviceInfoType = this.GetMyDeviceEnumInfo(new List<CommonDevice>() { device });
			if (device.Type == DeviceType.OnOffSwitch)
			{
			//面板的干接点叫按键
			if (deviceInfoType.BeloneType == DeviceBeloneType.A按键面板)
			{
			return Language.StringByID(R.MyInternationalizationString.uPanelButton) + epointNo;
			}
			//其他的干接点叫干接点
			else
			{
			var infoContent = this.GetDeviceModelIdNameInfo("A419");
			return infoContent != null ? infoContent.A官方名字 : string.Empty;
			}
			}
			else if (device.Type == DeviceType.FreshAirHumiditySensor)
			{
			//新风面板/简约多功能/简约环境面板湿度传感器
			return deviceInfoType.DeviceDefultName + Language.StringByID(R.MyInternationalizationString.HumiditySensor);
			}
			else if (device.Type == DeviceType.TemperatureSensor)
			{
			if (deviceInfoType.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueFreshAir
			\|\| deviceInfoType.ConcreteType == DeviceConcreteType.ButtonPanel_SimpleEnvironment
			\|\| deviceInfoType.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueEnvironment
			\|\| deviceInfoType.ConcreteType == DeviceConcreteType.ButtonPanel_SimpleMultifunction)
			{
			//新风面板/简约多功能/简约/方悦环境面板温度传感器
			return deviceInfoType.DeviceDefultName + Language.StringByID(R.MyInternationalizationString.TemperatureSensor);
			}
			else if (deviceInfoType.BeloneType == DeviceBeloneType.A按键面板)
			{
			//面板的温度探头叫面板名字+温度
			return deviceInfoType.DeviceDefultName + Language.StringByID(R.MyInternationalizationString.uTemperature);
			}
			else if (((TemperatureSensor)device).SensorDiv == 1)
			{
			//温度传感器
			return Language.StringByID(R.MyInternationalizationString.TemperatureSensor);
			}
			else if (((TemperatureSensor)device).SensorDiv == 2)
			{
			//湿度传感器
			return Language.StringByID(R.MyInternationalizationString.HumiditySensor);
			}
			}
			//其他情况,使用它的默认名称
			return deviceInfoType.DeviceDefultName + epointNo;
			}

			/// <summary>
			@@ -859,53 +1436,15 @@
			{
			return dName;
			}

			//是否拥有配置的模块ID
			if (this.dicDeviceModelIdEnum.ContainsKey(device.ModelIdentifier) == true)
			if (this.IsMiniLight(device) == true)
			{
			//获取模块ID名字
			return this.GetNameByModelId(device);
			}
			else
			{
			//获取第三方设备的翻译名字
			var myDeviceType = this.GetMyDeviceEnumInfo(new List<CommonDevice>() { device });
			return Language.StringByID(myDeviceType.ConcreteTextId);
			}
			}

			/// <summary>
			/// 根据模块ID，获取翻译名字
			/// </summary>
			/// <param name="device"></param>
			/// <returns></returns>
			private string GetNameByModelId(CommonDevice device)
			{
			if (device.ModelIdentifier == string.Empty)
			{
			//未知设备
			return Language.StringByID(R.MyInternationalizationString.UnknowDevice);
			//Mini夜灯
			return Language.StringByID(R.MyInternationalizationString.uMiniNightLight);
			}

			string modelKeys = device.ModelIdentifier;
			if (this.dicDeviceModelIdEnum.ContainsKey(modelKeys) == false)
			{
			//未知设备
			return Language.StringByID(R.MyInternationalizationString.UnknowDevice);
			}

			string[] strValue = this.dicDeviceModelIdEnum[modelKeys].Split(new string[] { "-" }, StringSplitOptions.RemoveEmptyEntries);
			int ConcreteValue = Convert.ToInt32(strValue[0]);

			string keyName = deviceModelIdName + ConcreteValue;
			if (this.dicDeviceDefultNameID.ContainsKey(keyName) == true)
			{
			//R文件里面设置的名字
			return Language.StringByID(this.dicDeviceDefultNameID[keyName]);
			}

			//未知设备
			return Language.StringByID(R.MyInternationalizationString.UnknowDevice);
			//获取设备类型
			var deviceInfoType = this.GetMyDeviceEnumInfo(new List<CommonDevice>() { device });
			return deviceInfoType.DeviceDefultName;
			}

			/// <summary>
			@@ -914,7 +1453,7 @@
			/// <param name="device">设备对象</param>
			/// <param name="macName">Mac名字</param>
			/// <returns></returns>
			private void SetMacName(CommonDevice device, string macName)
			public void SetMacName(CommonDevice device, string macName)
			{
			device.DeviceName = macName;
			}
			@@ -925,7 +1464,7 @@
			/// <param name="device">设备对象</param>
			/// <param name="epointName">端点名字</param>
			/// <returns></returns>
			private void SetEpointName(CommonDevice device, string epointName)
			public void SetEpointName(CommonDevice device, string epointName)
			{
			device.DeviceEpointName = epointName;
			}
			@@ -948,32 +1487,6 @@
			public string GetSimpleEpointName(CommonDevice device)
			{
			return device.DeviceEpointName;
			}

			/// <summary>
			/// 初始化R文件里面设备默认名字的ID
			/// </summary>
			private void InitDeviceDefultNameIDList()
			{
			if (this.dicDeviceDefultNameID != null)
			{
			return;
			}
			this.dicDeviceDefultNameID = new Dictionary<string, int>();
			Type type = typeof(R.MyInternationalizationString);

			var PropertyList = type.GetFields();
			foreach (var item in PropertyList)
			{
			if (item.Name.StartsWith(deviceModelIdName) == true
			\|\| item.Name.StartsWith("uDeviceBelongId") == true)
			{
			this.dicDeviceDefultNameID[item.Name] = Convert.ToInt32(item.GetValue(null));
			}
			}

			//初始化设备枚举
			this.InitDeviceModelIdEnum();
			}

			#endregion
			@@ -1016,9 +1529,41 @@

			//获取设备【图标】
			this.GetDeviceIcon(device, ref unSelectFilePath, ref selectFilePath);
			if (btnIcon.UnSelectedImagePath != unSelectFilePath)
			{
			btnIcon.UnSelectedImagePath = unSelectFilePath;
			}
			if (btnIcon.SelectedImagePath != selectFilePath)
			{
			btnIcon.SelectedImagePath = selectFilePath;
			}
			}

			btnIcon.UnSelectedImagePath = unSelectFilePath;
			btnIcon.SelectedImagePath = selectFilePath;
			/// <summary>
			/// 设置设备【图标】到指定的控件(注意,此函数设置的选择状态的图片是白色的)
			/// </summary>
			/// <param name="btnIcon">控件对象</param>
			/// <param name="device">设备对象</param>
			/// <returns></returns>
			public void SetDeviceIconToControl2(Button btnIcon, CommonDevice device)
			{
			if (device == null)
			{
			btnIcon.UnSelectedImagePath = "Device/ThirdPartyDevice.png";
			return;
			}
			string unSelectFilePath = device.IconPath;
			string selectFilePath = unSelectFilePath.Replace(".png", "Selected2.png");

			//获取设备【图标】
			if (btnIcon.UnSelectedImagePath != unSelectFilePath)
			{
			btnIcon.UnSelectedImagePath = unSelectFilePath;
			}
			if (btnIcon.SelectedImagePath != selectFilePath)
			{
			btnIcon.SelectedImagePath = selectFilePath;
			}
			}

			/// <summary>
			@@ -1095,7 +1640,7 @@
			}

			/// <summary>
			/// 设置【设备类型】的图标到指定的控件
			/// 设置【设备类型】的图标到指定的控件(此方法不能用在设备功能类型菜单的图标)
			/// </summary>
			/// <param name="btnIcon">控件对象</param>
			/// <param name="listdevice">设备对象</param>
			@@ -1117,7 +1662,7 @@
			}

			/// <summary>
			/// 获取【设备类型】的图标
			/// 获取【设备类型】的图标(此方法不能用在设备功能类型菜单的图标)
			/// </summary>
			/// <param name="listdevice">设备对象</param>
			/// <param name="unSelectPath">图片地址</param>
			@@ -1133,13 +1678,42 @@
			}

			/// <summary>
			/// 获取【设备类型】的图标
			/// 获取【设备功能类型】的菜单图标
			/// </summary>
			/// <param name="specificType">自定义设备类型</param>
			/// <param name="unSelectPath">图片地址</param>
			/// <param name="selectPath">图片地址</param>
			/// <returns></returns>
			public void GetDeviceObjectIcon(DeviceConcreteType specificType, ref string unSelectPath, ref string selectPath)
			public void GetDeviceFunctionTypeMenuIcon(DeviceConcreteType specificType, ref string unSelectPath, ref string selectPath)
			{
			//新风小模块
			if (specificType == DeviceConcreteType.Relay_FangyueFreshAirModul)
			{
			unSelectPath = "Device/FreshAirEpoint.png";
			selectPath = "Device/FreshAirEpointSelected.png";
			return;
			}
			//PM2.5空气质量传感器
			else if (specificType == DeviceConcreteType.Sensor_PMTwoPointFive)
			{
			unSelectPath = "Device/AirQualitySensorEpoint.png";
			selectPath = "Device/AirQualitySensorEpointSelected.png";
			return;
			}
			//上面需要特殊处理

			//获取【设备类型】的图标
			this.GetDeviceObjectIcon(specificType, ref unSelectPath, ref selectPath);
			}

			/// <summary>
			/// 获取【设备类型】的图标 2020.05.13:次函数不再公开
			/// </summary>
			/// <param name="specificType">自定义设备类型</param>
			/// <param name="unSelectPath">图片地址</param>
			/// <param name="selectPath">图片地址</param>
			/// <returns></returns>
			private void GetDeviceObjectIcon(DeviceConcreteType specificType, ref string unSelectPath, ref string selectPath)
			{
			//将具体类型转字符串
			string strSpecific = Enum.GetName(typeof(DeviceConcreteType), specificType);
			@@ -1179,43 +1753,6 @@

			#endregion

			#region ■ 设备UI相关_________________________

			/// <summary>
			/// 获取设备所匹配的设备UI对象
			/// </summary>
			/// <param name="device"></param>
			/// <returns></returns>
			public DeviceUI GetDeviceUI(CommonDevice device)
			{
			//创建一个新的东西给过去
			var deviceUi = new DeviceUI();
			deviceUi.DeviceAddr = device.DeviceAddr;
			deviceUi.DeviceEpoint = device.DeviceEpoint;
			return deviceUi;
			}

			/// <summary>
			/// 获取设备所匹配的设备UI对象
			/// </summary>
			/// <param name="filePath"></param>
			/// <returns></returns>
			public DeviceUI GetDeviceUI(string filePath)
			{
			string[] arry = filePath.Split(new string[] { "_" }, StringSplitOptions.RemoveEmptyEntries);
			if (arry.Length != 4)
			{
			return null;
			}
			//创建一个新的东西给过去
			var deviceUi = new DeviceUI();
			deviceUi.DeviceAddr = arry[2];
			deviceUi.DeviceEpoint = Convert.ToInt32(arry[3]);
			return deviceUi;
			}

			#endregion

			#region ■ 获取自定义的设备类型_______________

			/// <summary>
			@@ -1242,7 +1779,11 @@
			return info;
			}
			//获取第三方设备的【设备类型】
			return this.GetNotHdlMyDeviceEnumInfo(listdevice);
			info = this.GetNotHdlMyDeviceEnumInfo(listdevice);
			//这里再次判断是否是河东设备,有可能它的模块ID写错了
			info.IsHdlDevice = this.IsHdlDevice(checkDevice);

			return info;
			}

			/// <summary>
			@@ -1262,28 +1803,39 @@
			checkDevice = temp;
			}
			}
			//获取自定义设备类型
			var myInfoType = this.GetMyDeviceEnumInfo(listDevice);
			//获取设备类型的翻译名字
			string strName = myInfoType.ObjectTypeName;
			if (strName == string.Empty)
			{
			//加一层保险,未知设备
			strName = Language.StringByID(R.MyInternationalizationString.UnknowDevice);
			}

			string strName = string.Empty;
			if (this.dicDeviceModelIdEnum.ContainsKey(checkDevice.ModelIdentifier) == true)
			if (ApendFalge == true)
			{
			//根据模块ID，获取设备名字
			strName = this.GetNameByModelId(checkDevice);
			}
			else
			{
			//获取第三方设备的【设备类型】
			var myDeviceType = this.GetNotHdlMyDeviceEnumInfo(listDevice);
			strName = Language.StringByID(myDeviceType.ConcreteTextId);
			}
			if (ApendFalge == true && listDevice[0].DriveCode > 0)
			{
			//虚拟设备加个标识
			strName += "✩";
			}
			else if (ApendFalge == true && this.IsHdlDevice(checkDevice) == false)
			{
			//第三方设备加个标识
			strName += "★";
			if (listDevice[0].DriveCode > 0)
			{
			//虚拟设备加个标识
			strName += "✩";
			}
			else
			{
			foreach (var temp in listDevice)
			{
			//拿拥有模块ID的那个回路来判断
			if (temp.ModelIdentifier != string.Empty)
			{
			if (this.IsHdlDevice(checkDevice) == false)
			{
			//第三方设备加个标识
			strName += "★";
			break;
			}
			}
			}
			}
			}
			return strName;
			}
			@@ -1307,29 +1859,35 @@
			return null;
			}
			string modelKeys = device.ModelIdentifier;
			//交换一下模块ID(麦乐克那边的传感器)
			this.ChangedDeviceModeId(ref modelKeys);

			if (this.dicDeviceModelIdEnum.ContainsKey(modelKeys) == false)
			{
			//没有匹配到模块ID，则直接走第三方设备的判断
			return null;
			}

			string[] strValue = this.dicDeviceModelIdEnum[modelKeys].Split(new string[] { "-" }, StringSplitOptions.RemoveEmptyEntries);
			int ConcreteValue = Convert.ToInt32(strValue[0]);
			int BeloneValue = Convert.ToInt32(strValue[1]);
			var nameContent = this.dicDeviceModelIdEnum[modelKeys];
			//设置设备的【设备所属类型】
			info.BeloneType = (DeviceBeloneType)BeloneValue;
			if (dicDeviceDefultNameID.ContainsKey("uDeviceBelongId" + BeloneValue) == true)
			{
			//设备所属类型的翻译名字
			info.BeloneTextId = dicDeviceDefultNameID["uDeviceBelongId" + BeloneValue];
			}
			info.BeloneType = (DeviceBeloneType)nameContent.BeloneTypeValue;
			info.BeloneText = nameContent.A所属名字;

			//设备具体类型
			info.ConcreteType = (DeviceConcreteType)ConcreteValue;
			if (info.ConcreteType.ToString() == ConcreteValue.ToString())
			info.ConcreteType = (DeviceConcreteType)nameContent.ConcreteTypeValue;
			if (info.ConcreteType.ToString() == nameContent.ConcreteTypeValue.ToString())
			{
			info.ConcreteType = DeviceConcreteType.UnKownDevice;
			}
			//设备的官方名称
			info.ConcreteText = nameContent.A官方名字;

			//设备的类型翻译名称
			info.ObjectTypeName = nameContent.A类型名字;

			//设备默认名字
			info.DeviceDefultName = nameContent.A备注名字;

			return info;
			}

			@@ -1349,31 +1907,22 @@
			\|\| info.BeloneType == DeviceBeloneType.A彩灯)
			{
			//归为灯光
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId15;
			info.BeloneType = DeviceBeloneType.A灯光;
			info.ConcreteType = DeviceConcreteType.Light;

			int value = (int)info.BeloneType;
			if (dicDeviceDefultNameID.ContainsKey("uDeviceBelongId" + value) == true)
			{
			//设备所属类型的翻译名字
			info.BeloneTextId = dicDeviceDefultNameID["uDeviceBelongId" + value];
			}
			info.ConcreteText = this.dicDeviceModelIdEnum["A418"].A官方名字;
			info.BeloneType = DeviceBeloneType.A灯光;
			info.BeloneText = this.dicDeviceModelIdEnum["A418"].A官方名字;
			info.ObjectTypeName = this.dicDeviceModelIdEnum["A418"].A类型名字;//调光模块
			}
			else if (info.BeloneType == DeviceBeloneType.A传感器
			\|\| device.Type == DeviceType.TemperatureSensor)
			\|\| device.Type == DeviceType.TemperatureSensor
			\|\| device.Type == DeviceType.FreshAirHumiditySensor)
			{
			//传感器合并
			info.BeloneType = DeviceBeloneType.A传感器;
			info.ConcreteType = DeviceConcreteType.Sensor;
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId1200;

			int value = (int)info.BeloneType;
			if (dicDeviceDefultNameID.ContainsKey("uDeviceBelongId" + value) == true)
			{
			//设备所属类型的翻译名字
			info.BeloneTextId = dicDeviceDefultNameID["uDeviceBelongId" + value];
			}
			info.ConcreteText = this.dicDeviceModelIdEnum["A402"].A官方名字;
			info.BeloneType = DeviceBeloneType.A传感器;
			info.BeloneText = this.dicDeviceModelIdEnum["A402"].A官方名字;
			info.ObjectTypeName = this.dicDeviceModelIdEnum["A402"].A类型名字;//传感器
			}

			return info;
			@@ -1401,47 +1950,50 @@
			{
			if (listdevice.Count > 1)
			{
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId200;
			info.ConcreteText = this.dicDeviceModelIdEnum["A401"].A官方名字;
			info.BeloneType = DeviceBeloneType.A按键面板;
			info.ConcreteType = DeviceConcreteType.ButtonPanel;
			}
			else
			{
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId16;
			info.ConcreteText = this.dicDeviceModelIdEnum["A419"].A官方名字;
			info.BeloneType = DeviceBeloneType.A干接点;
			info.ConcreteType = DeviceConcreteType.DryContact;
			}
			info.ObjectTypeName = this.dicDeviceModelIdEnum["A401"].A类型名字;//智能面板
			}
			//3包含窗帘的话,当窗帘处理
			else if (dicType.ContainsKey(DeviceType.WindowCoveringDevice) == true)
			{
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId100;
			info.ConcreteText = this.dicDeviceModelIdEnum["A400"].A官方名字;
			info.BeloneType = DeviceBeloneType.A窗帘;
			info.ConcreteType = DeviceConcreteType.Curtain;
			info.ObjectTypeName = this.dicDeviceModelIdEnum["A400"].A类型名字;//遮阳模块
			}
			//4空气开关
			else if (dicType.ContainsKey(DeviceType.AirSwitch) == true)
			{
			//默认值
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId4100;
			info.BeloneType = DeviceBeloneType.A智能空开;
			info.ConcreteText = this.dicDeviceModelIdEnum["A408"].A官方名字;
			info.BeloneType = DeviceBeloneType.A开关;
			info.ConcreteType = DeviceConcreteType.AirSwitch;
			info.ObjectTypeName = this.dicDeviceModelIdEnum["A408"].A类型名字;//开关模块

			if (dicType[DeviceType.AirSwitch].DfunctionType == DeviceFunctionType.A开关)
			{
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId13;
			info.ConcreteText = this.dicDeviceModelIdEnum["A416"].A官方名字;
			info.BeloneType = DeviceBeloneType.A开关;
			info.ConcreteType = DeviceConcreteType.Switch;
			}
			else if (dicType[DeviceType.AirSwitch].DfunctionType == DeviceFunctionType.A插座)
			{
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId14;
			info.ConcreteText = this.dicDeviceModelIdEnum["A417"].A官方名字;
			info.BeloneType = DeviceBeloneType.A插座;
			info.ConcreteType = DeviceConcreteType.Socket1;
			}
			else if (dicType[DeviceType.AirSwitch].DfunctionType == DeviceFunctionType.A灯光)
			{
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId15;
			info.ConcreteText = this.dicDeviceModelIdEnum["A418"].A官方名字;
			info.BeloneType = DeviceBeloneType.A灯光;
			info.ConcreteType = DeviceConcreteType.Light;
			}
			@@ -1450,25 +2002,26 @@
			else if (dicType.ContainsKey(DeviceType.OnOffOutput) == true)
			{
			//默认值
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId2300;
			info.ConcreteText = this.dicDeviceModelIdEnum["A403"].A官方名字;
			info.BeloneType = DeviceBeloneType.A继电器;
			info.ConcreteType = DeviceConcreteType.Relay;
			info.ObjectTypeName = this.dicDeviceModelIdEnum["A403"].A类型名字;//开关模块

			if (dicType[DeviceType.OnOffOutput].DfunctionType == DeviceFunctionType.A开关)
			{
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId13;
			info.ConcreteText = this.dicDeviceModelIdEnum["A416"].A官方名字;
			info.BeloneType = DeviceBeloneType.A开关;
			info.ConcreteType = DeviceConcreteType.Switch;
			}
			else if (dicType[DeviceType.OnOffOutput].DfunctionType == DeviceFunctionType.A插座)
			{
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId14;
			info.ConcreteText = this.dicDeviceModelIdEnum["A417"].A官方名字;
			info.BeloneType = DeviceBeloneType.A插座;
			info.ConcreteType = DeviceConcreteType.Socket1;
			}
			else if (dicType[DeviceType.OnOffOutput].DfunctionType == DeviceFunctionType.A灯光)
			{
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId15;
			info.ConcreteText = this.dicDeviceModelIdEnum["A418"].A官方名字;
			info.BeloneType = DeviceBeloneType.A灯光;
			info.ConcreteType = DeviceConcreteType.Light;
			}
			@@ -1476,51 +2029,58 @@
			//6调光器
			else if (dicType.ContainsKey(DeviceType.DimmableLight) == true)
			{
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId2500;
			info.ConcreteText = this.dicDeviceModelIdEnum["A404"].A官方名字;
			info.BeloneType = DeviceBeloneType.A调光器;
			info.ConcreteType = DeviceConcreteType.DimmableLight;
			info.ObjectTypeName = this.dicDeviceModelIdEnum["A404"].A类型名字;//调光模块
			}
			//7彩灯
			else if (dicType.ContainsKey(DeviceType.ColorDimmableLight) == true)
			{
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId9;
			info.ConcreteText = this.dicDeviceModelIdEnum["A410"].A官方名字;
			info.BeloneType = DeviceBeloneType.A彩灯;
			info.ConcreteType = DeviceConcreteType.ColorLight;
			info.ObjectTypeName = this.dicDeviceModelIdEnum["A410"].A类型名字;//调光模块
			}
			//8空调
			else if (dicType.ContainsKey(DeviceType.Thermostat) == true)
			{
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId3600;
			info.ConcreteText = this.dicDeviceModelIdEnum["A406"].A官方名字;
			info.BeloneType = DeviceBeloneType.A空调;
			info.ConcreteType = DeviceConcreteType.AirConditioner;
			info.ObjectTypeName = this.dicDeviceModelIdEnum["A406"].A类型名字;//空调模块
			}
			//9中继器
			else if (dicType.ContainsKey(DeviceType.Repeater) == true)
			{
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId3900;
			info.ConcreteText = this.dicDeviceModelIdEnum["A407"].A官方名字;
			info.BeloneType = DeviceBeloneType.A中继器;
			info.ConcreteType = DeviceConcreteType.Repeater;
			info.ObjectTypeName = this.dicDeviceModelIdEnum["A407"].A类型名字;//系统设备
			}
			//10转换器
			else if (dicType.ContainsKey(DeviceType.Transverter) == true)
			{
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId4200;
			info.ConcreteText = this.dicDeviceModelIdEnum["A409"].A官方名字;
			info.BeloneType = DeviceBeloneType.A转换器;
			info.ConcreteType = DeviceConcreteType.Converter;
			info.ObjectTypeName = this.dicDeviceModelIdEnum["A409"].A类型名字;//转换器
			}
			//11智能门锁
			else if (dicType.ContainsKey(DeviceType.DoorLock) == true)
			{
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId2800;
			info.ConcreteText = this.dicDeviceModelIdEnum["A405"].A官方名字;
			info.BeloneType = DeviceBeloneType.A智能门锁;
			info.ConcreteType = DeviceConcreteType.IntelligentLocks;
			info.ObjectTypeName = this.dicDeviceModelIdEnum["A405"].A类型名字;//智能门锁
			}
			//12包含传感器的话,当传感器处理
			else if (dicType.ContainsKey(DeviceType.IASZone) == true)
			{
			info.BeloneType = DeviceBeloneType.A传感器;
			info.ConcreteType = DeviceConcreteType.Sensor;
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId1200;
			info.ConcreteText = this.dicDeviceModelIdEnum["A402"].A官方名字;
			info.ObjectTypeName = this.dicDeviceModelIdEnum["A402"].A类型名字;//传感器
			//设置传感器具体的类型
			this.SetSensorDeviceSpecificType(ref info, listdevice);
			}
			@@ -1551,31 +2111,53 @@
			{
			//设置传感器具体的类型
			info.BeloneType = DeviceBeloneType.A温湿度传感器;
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId10;
			info.ConcreteText = this.dicDeviceModelIdEnum["A411"].A官方名字;
			info.ConcreteType = DeviceConcreteType.Sensor_TemperatureHumidity;
			}
			else if (temperatrue == true && humidity == false)
			{
			//设置传感器具体的类型
			info.BeloneType = DeviceBeloneType.A温度传感器;
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId11;
			info.ConcreteText = this.dicDeviceModelIdEnum["A412"].A官方名字;
			info.ConcreteType = DeviceConcreteType.Sensor_Temperature;
			}
			else if (temperatrue == false && humidity == true)
			{
			//设置传感器具体的类型
			info.BeloneType = DeviceBeloneType.A湿度传感器;
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceBelongId12;
			info.ConcreteText = this.dicDeviceModelIdEnum["A413"].A官方名字;
			info.ConcreteType = DeviceConcreteType.Sensor_Humidity;
			}
			info.ObjectTypeName = this.dicDeviceModelIdEnum["A411"].A类型名字;//传感器
			}
			//14新风设备
			else if (dicType.ContainsKey(DeviceType.FreshAir) == true)
			{
			info.ConcreteText = this.dicDeviceModelIdEnum["A414"].A官方名字;
			info.BeloneType = DeviceBeloneType.A新风;
			info.ConcreteType = DeviceConcreteType.Relay_FangyueFreshAirModul;
			info.ObjectTypeName = this.dicDeviceModelIdEnum["A414"].A类型名字;//新风
			}
			//15 PM2.5传感器设备
			else if (dicType.ContainsKey(DeviceType.PMSensor) == true)
			{
			info.ConcreteText = this.dicDeviceModelIdEnum["A415"].A官方名字;
			info.BeloneType = DeviceBeloneType.APM2点5空气质量传感器;
			info.ConcreteType = DeviceConcreteType.Sensor_PMTwoPointFive;
			info.ObjectTypeName = this.dicDeviceModelIdEnum["A415"].A类型名字;//传感器
			}
			//16色温灯
			else if (dicType.ContainsKey(DeviceType.ColorTemperatureLight) == true)
			{
			info.ConcreteText = this.dicDeviceModelIdEnum["A420"].A官方名字;
			info.BeloneType = DeviceBeloneType.A彩灯;
			info.ConcreteType = DeviceConcreteType.ColorLight_Temperature;
			info.ObjectTypeName = this.dicDeviceModelIdEnum["A420"].A类型名字;//调光模块
			}

			int value = (int)info.BeloneType;
			if (dicDeviceDefultNameID.ContainsKey("uDeviceBelongId" + value) == true)
			{
			//设备所属类型的翻译名字
			info.BeloneTextId = dicDeviceDefultNameID["uDeviceBelongId" + value];
			}
			//设备所属类型的翻译名字
			info.BeloneText = info.ConcreteText;
			info.DeviceDefultName = info.ConcreteText;

			return info;
			}
			@@ -1601,43 +2183,43 @@
			{
			//运动传感器
			info.ConcreteType = DeviceConcreteType.Sensor_Motion;
			info.ConcreteTextId = R.MyInternationalizationString.uMotionSensor;
			info.ConcreteText = Language.StringByID(R.MyInternationalizationString.uMotionSensor);
			}
			else if (iasZone.IasDeviceType == 40)
			{
			//烟雾传感器
			info.ConcreteType = DeviceConcreteType.Sensor_Fire;
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceModelId1302;
			info.ConcreteText = Language.StringByID(R.MyInternationalizationString.uSensorFire);
			}
			else if (iasZone.IasDeviceType == 42)
			{
			//水侵传感器
			info.ConcreteType = DeviceConcreteType.Sensor_Water;
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceModelId1304;
			info.ConcreteText = Language.StringByID(R.MyInternationalizationString.uSensorWater);
			}
			else if (iasZone.IasDeviceType == 43)
			{
			//燃气传感器
			info.ConcreteType = DeviceConcreteType.Sensor_CarbonMonoxide;
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceModelId1300;
			info.ConcreteText = Language.StringByID(R.MyInternationalizationString.uSensorCarbonMonoxide);
			}
			else if (iasZone.IasDeviceType == 44)
			{
			//紧急按钮
			info.ConcreteType = DeviceConcreteType.Sensor_EmergencyButton;
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceModelId1305;
			info.ConcreteText = Language.StringByID(R.MyInternationalizationString.uSensorEmergencyButton);
			}
			else if (iasZone.IasDeviceType == 277)
			{
			//钥匙扣
			info.ConcreteType = DeviceConcreteType.Sensor_Keyfob;
			info.ConcreteTextId = R.MyInternationalizationString.uKeyfob;
			info.ConcreteText = Language.StringByID(R.MyInternationalizationString.uKeyfob);
			}
			else if (iasZone.IasDeviceType == 21 \|\| iasZone.IasDeviceType == 22)
			{
			//门窗传感器
			info.ConcreteType = DeviceConcreteType.Sensor_DoorWindow;
			info.ConcreteTextId = R.MyInternationalizationString.uDeviceModelId1301;
			info.ConcreteText = Language.StringByID(R.MyInternationalizationString.uSensorDoorWindow);
			}
			}

			@@ -1651,12 +2233,21 @@
			private void InitRealDeviceRoomId()
			{
			this.dicDeviceRoomId = new Dictionary<string, string>();
			string fullName = UserCenterLogic.CombinePath(DirNameResourse.DeviceRoomIdFile);
			var strData = UserCenterLogic.LoadFileContent(fullName);
			string fullName = DirNameResourse.DeviceRoomIdFile;
			var strData = HdlFileLogic.Current.ReadFileTextContent(fullName);
			if (strData != null)
			{
			this.dicDeviceRoomId = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, string>>(strData);
			}
			}

			/// <summary>
			/// 获取全部物理设备所属房间的记录
			/// </summary>
			/// <returns></returns>
			public Dictionary<string, string> GetAllRealDeviceRoomData()
			{
			return this.dicDeviceRoomId;
			}

			/// <summary>
			@@ -1667,22 +2258,53 @@
			/// <param name="saveRoadDevice">如果只有一个回路,是否把回路的房间一起修改</param>
			public void SaveRealDeviceRoomId(List<CommonDevice> listDevice, string roomId, bool saveRoadDevice = true)
			{
			if (listDevice != null)
			if (listDevice == null)
			{
			this.dicDeviceRoomId[listDevice[0].DeviceAddr] = roomId;
			return;
			}

			//保存记录
			string fullName = UserCenterLogic.CombinePath(DirNameResourse.DeviceRoomIdFile);
			UserCenterLogic.SaveFileContent(fullName, this.dicDeviceRoomId);

			//添加自动备份
			HdlAutoBackupLogic.AddOrEditorFile(DirNameResourse.DeviceRoomIdFile);

			//如果设备只有一个回路，如果改变了真实设备区域，则它的回路的区域也一起改了
			if (saveRoadDevice == true && listDevice != null && listDevice.Count == 1)
			{
			Common.Room.CurrentRoom.ChangedRoom(listDevice[0], roomId, false);
			if (listDevice[0] is OTADevice)
			{
			//单纯只是Ota设备则不处理
			return;
			}
			HdlRoomLogic.Current.ChangedRoom(listDevice[0], roomId, false);
			}
			bool save = false;
			if (roomId == string.Empty)
			{
			//选择的是未分配
			this.dicDeviceRoomId.Remove(listDevice[0].DeviceAddr);
			save = true;
			}
			else
			{
			if (this.dicDeviceRoomId.ContainsKey(listDevice[0].DeviceAddr) == false)
			{
			this.dicDeviceRoomId[listDevice[0].DeviceAddr] = roomId;
			save = true;
			}
			else
			{
			//2020.05.18追加:如果记录的房间ID是不存在的话,则重新覆盖
			var room = HdlRoomLogic.Current.GetRoomById(this.dicDeviceRoomId[listDevice[0].DeviceAddr]);
			if (room == null \|\| this.dicDeviceRoomId[listDevice[0].DeviceAddr] != roomId)
			{
			this.dicDeviceRoomId[listDevice[0].DeviceAddr] = roomId;
			save = true;
			}
			}
			}

			if (save == true)
			{
			//保存记录
			HdlFileLogic.Current.SaveFileContent(DirNameResourse.DeviceRoomIdFile, this.dicDeviceRoomId);

			//添加自动备份
			HdlAutoBackupLogic.AddOrEditorFile(DirNameResourse.DeviceRoomIdFile);
			}
			}

			@@ -1698,13 +2320,8 @@
			//未分配区域
			return Language.StringByID(R.MyInternationalizationString.uDeviceNotAssignedRoom);
			}
			var room = Room.CurrentRoom.GetRoomById(this.dicDeviceRoomId[device.DeviceAddr]);
			if (room != null)
			{
			return room.Name;
			}
			//未分配区域
			return Language.StringByID(R.MyInternationalizationString.uDeviceNotAssignedRoom);
			var room = HdlRoomLogic.Current.GetRoomById(this.dicDeviceRoomId[device.DeviceAddr]);
			return HdlRoomLogic.Current.GetRoomName(room);
			}

			/// <summary>
			@@ -1718,12 +2335,222 @@
			{
			return null;
			}
			return Room.CurrentRoom.GetRoomById(this.dicDeviceRoomId[device.DeviceAddr]);
			return HdlRoomLogic.Current.GetRoomById(this.dicDeviceRoomId[device.DeviceAddr]);
			}

			/// <summary>
			/// 将真实物理设备从房间中移除
			/// </summary>
			/// <param name="device">随便一个回路</param>
			public void DeleteRealDeviceFromRoom(CommonDevice device)
			{
			//将真实物理设备从房间中移除
			this.DeleteRealDeviceFromRoom(new List<string>() { device.DeviceAddr });
			}

			/// <summary>
			/// 将真实物理设备从房间中移除
			/// </summary>
			/// <param name="listMac">设备Mac地址</param>
			public void DeleteRealDeviceFromRoom(List<string> listMac)
			{
			bool save = false;
			foreach (var deviceMacAddr in listMac)
			{
			if (this.dicDeviceRoomId.ContainsKey(deviceMacAddr) == true)
			{
			this.dicDeviceRoomId.Remove(deviceMacAddr);
			save = true;
			}
			}
			if (save == false)
			{
			//没有改变,不需要保存
			return;
			}
			//保存记录
			HdlFileLogic.Current.SaveFileContent(DirNameResourse.DeviceRoomIdFile, this.dicDeviceRoomId);

			//添加自动备份
			HdlAutoBackupLogic.AddOrEditorFile(DirNameResourse.DeviceRoomIdFile);
			}

			/// <summary>
			/// 根据房间ID,移除指定的真实物理设备的所属房间记录
			/// </summary>
			/// <param name="i_RoomId"></param>
			public void DeleteRealDeviceByRoomId(string i_RoomId)
			{
			var listDeleteKey = new List<string>();
			foreach (var deviceAddr in this.dicDeviceRoomId.Keys)
			{
			if (this.dicDeviceRoomId[deviceAddr] == i_RoomId
			&& listDeleteKey.Contains(deviceAddr) == false)
			{
			listDeleteKey.Add(deviceAddr);
			}
			}
			//将真实物理设备从房间中移除
			this.DeleteRealDeviceFromRoom(listDeleteKey);
			}

			#endregion

			#region ■ 设备排序___________________________

			/// <summary>
			/// 设备排序
			/// </summary>
			/// <param name="i_listDevice">请确保这个东西已经按mac和端点排序了</param>
			/// <returns></returns>
			public List<CommonDevice> SortDeviceByBelongType(List<CommonDevice> i_listDevice)
			{
			//获取排序规则
			var listRule = this.GetBelongTypeSortRule();
			var dicDevice = new Dictionary<DeviceBeloneType, List<CommonDevice>>();
			dicDevice[DeviceBeloneType.A未知设备] = new List<CommonDevice>();

			foreach (var device in i_listDevice)
			{
			//获取所属类型
			var typeInfo = this.GetDeviceBelongEnumInfo(device);
			if (listRule.Contains(typeInfo.BeloneType) == false)
			{
			//不在排序范围内,都丢在最后面
			dicDevice[DeviceBeloneType.A未知设备].Add(device);
			continue;
			}
			if (dicDevice.ContainsKey(typeInfo.BeloneType) == false)
			{
			dicDevice[typeInfo.BeloneType] = new List<CommonDevice>();
			}
			dicDevice[typeInfo.BeloneType].Add(device);
			}

			var listSort = new List<CommonDevice>();
			foreach (var myType in listRule)
			{
			//根据规则顺序,添加设备
			if (dicDevice.ContainsKey(myType) == false \|\| dicDevice[myType].Count == 0)
			{
			continue;
			}
			listSort.AddRange(dicDevice[myType]);
			}

			return listSort;
			}

			/// <summary>
			/// 获取设备所属类型的的排序规则
			/// </summary>
			/// <returns></returns>
			public HashSet<DeviceBeloneType> GetBelongTypeSortRule()
			{
			//谁在前面,谁就优先显示
			var list = new HashSet<DeviceBeloneType>();
			list.Add(DeviceBeloneType.A灯光);
			list.Add(DeviceBeloneType.A彩灯);
			list.Add(DeviceBeloneType.A开关);
			list.Add(DeviceBeloneType.A插座);
			list.Add(DeviceBeloneType.A调光器);
			list.Add(DeviceBeloneType.A窗帘);
			list.Add(DeviceBeloneType.A新风);
			list.Add(DeviceBeloneType.A空调);
			list.Add(DeviceBeloneType.A继电器);
			list.Add(DeviceBeloneType.A干接点);
			list.Add(DeviceBeloneType.A智能门锁);
			list.Add(DeviceBeloneType.A智能空开);
			list.Add(DeviceBeloneType.A传感器);

			//其他的看着办呗,都是排在后面的,都归为这个属性
			list.Add(DeviceBeloneType.A未知设备);

			return list;
			}

			#endregion

			#region ■ 一般方法___________________________

			/// <summary>
			/// 从缓存变量检测设备是否在线
			/// </summary>
			/// <param name="i_device"></param>
			/// <param name="checkAll">是否检测全部回路</param>
			/// <returns></returns>
			public bool CheckDeviceIsOnline(CommonDevice i_device, bool checkAll = true)
			{
			if (checkAll == false)
			{
			//不检测全部回路
			return i_device.IsOnline == 1 \|\| i_device.IsOnline == 2;
			}
			var listDevice = this.GetDevicesByMac(i_device.DeviceAddr, false);
			foreach (var device in listDevice)
			{
			//0:离线 1:在线 2:正在刷新状态
			bool statu = i_device.IsOnline == 1 \|\| i_device.IsOnline == 2;
			if (statu == true)
			{
			//有一个回路在线,即在线
			return true;
			}
			}
			return false;
			}

			/// <summary>
			/// 判断该设备是否可以显示在主页
			/// </summary>
			/// <param name="i_device"></param>
			/// <returns></returns>
			public bool CanShowInHomeHomeMainPage(CommonDevice i_device)
			{
			if (i_device == null \|\| i_device.Type == DeviceType.OnOffSwitch)//干接点
			{
			//这个设备不见了
			return false;
			}
			if (i_device.Type == DeviceType.OnOffOutput \|\| i_device.Type == DeviceType.AirSwitch)
			{
			//2020.03.23追加式样:未指定类型的继电器,不显示
			if (i_device.DfunctionType == DeviceFunctionType.A未定义
			\|\| i_device.DfunctionType == DeviceFunctionType.A不指定)
			{
			return false;
			}
			}
			//2020.03.30追加式样:如果是面板的温度探头,不显示
			else if (i_device.Type == DeviceType.TemperatureSensor && ((TemperatureSensor)i_device).SensorDiv == 1)
			{
			var myInfoType = LocalDevice.Current.GetMyDeviceEnumInfo(new List<CommonDevice>() { i_device });
			if (myInfoType.BeloneType == DeviceBeloneType.A按键面板)
			{
			return false;
			}
			}
			else if (i_device.Type == DeviceType.FreshAirHumiditySensor)
			{
			//新风的湿度传感器不显示
			return false;
			}

			//如果是新风面板或环境面板,则都不显示任何回路
			var myInfoTypeTemp = LocalDevice.Current.GetMyDeviceEnumInfo(new List<CommonDevice>() { i_device });
			if (myInfoTypeTemp.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueFreshAir \|\| myInfoTypeTemp.ConcreteType == DeviceConcreteType.ButtonPanel_SimpleEnvironment)
			{
			return false;
			}
			else if (myInfoTypeTemp.ConcreteType == DeviceConcreteType.ButtonPanel_SimpleMultifunction)
			{
			if (i_device.Type != DeviceType.OnOffOutput)
			{
			return false;
			}
			}
			return true;
			}

			/// <summary>
			/// 判断是不是河东的设备
			@@ -1736,13 +2563,23 @@
			}

			/// <summary>
			/// 是否是Mini夜灯
			/// </summary>
			/// <param name="device"></param>
			/// <returns></returns>
			public bool IsMiniLight(CommonDevice device)
			{
			return device.DriveCode != 0 && device.Type == DeviceType.ColorTemperatureLight;
			}

			/// <summary>
			/// 获取设备的唯一主键
			/// </summary>
			/// <param name="device"></param>
			/// <returns></returns>
			public string GetDeviceMainKeys(CommonDevice device)
			{
			return device.DeviceAddr + device.DeviceEpoint;
			return this.GetDeviceMainKeys(device.DeviceAddr, device.DeviceEpoint);
			}

			/// <summary>
			@@ -1753,7 +2590,7 @@
			/// <returns></returns>
			public string GetDeviceMainKeys(string DeviceAddr, int DeviceEpoint)
			{
			return DeviceAddr + DeviceEpoint;
			return DeviceAddr + "_" + DeviceEpoint;
			}

			/// <summary>
			@@ -1773,22 +2610,42 @@
			}

			/// <summary>
			/// 获取模块ID所指向的各种名字信息
			/// </summary>
			/// <param name="strKey"></param>
			/// <returns></returns>
			public DeviceNameContent GetDeviceModelIdNameInfo(string strKey)
			{
			if (this.dicDeviceModelIdEnum.ContainsKey(strKey) == false)
			{
			return new DeviceNameContent();
			}
			return this.dicDeviceModelIdEnum[strKey];
			}

			/// <summary>
			/// 附加设备的版本代号(返回Ver.XXX)
			/// </summary>
			/// <param name="versionValue">版本号</param>
			/// <returns></returns>
			public string AppendVersion(int versionValue)
			{
			//10101 3个byte 显示为：ver.1.01.01
			//中间那个byte为奇数时，代表是测试版本,在显示最新版本时,不需要显示，但是在历史版本那里可以显示
			//中间那个byte为偶数时, 代表是正式版本

			//直接是10进制
			string txt10 = Convert.ToString(versionValue).PadLeft(4, '0');
			//这个是小数点前面的值
			int value1 = Convert.ToInt32(txt10.Substring(0, txt10.Length - 2));
			//这个是小数点后面的值
			int value2 = Convert.ToInt32(txt10.Substring(txt10.Length - 2, 2));
			string txt10 = Convert.ToString(versionValue).PadLeft(6, '0');
			//这个是第一位
			int value1 = Convert.ToInt32(txt10.Substring(0, 2));
			//这个是第二位
			string value2 = txt10.Substring(2, 2);
			//这个是第三位
			string value3 = txt10.Substring(4, 2);

			//Ver.
			string ver = Language.StringByID(R.MyInternationalizationString.uVersionAbbreviation);
			return ver + value1 + "." + value2.ToString().PadLeft(2, '0');
			return ver + value1 + "." + value2 + "." + value3;
			}

			/// <summary>
			@@ -1797,7 +2654,7 @@
			/// <param name="msg"></param>
			private void ShowErrorMsg(string msg)
			{
			Application.RunOnMainThread(() =>
			HdlThreadLogic.Current.RunMain(() =>
			{
			var contr = new ShowMsgControl(ShowMsgType.Error, msg);
			contr.Show();
			@@ -1810,7 +2667,7 @@
			/// <param name="msg"></param>
			private void ShowTipMsg(string msg)
			{
			Application.RunOnMainThread(() =>
			HdlThreadLogic.Current.RunMain(() =>
			{
			var contr = new ShowMsgControl(ShowMsgType.Tip, msg);
			contr.Show();
			@@ -1829,22 +2686,11 @@
			/// </summary>
			/// <param name="zbGateway">网关对象</param>
			/// <param name="statu">状态-> -1:异常,会返回null, 1：没有异常, 2:数据接收不全</param>
			/// <param name="ignoreTime">是否无视时间(此变量是给获取在线状态用的),true:每次调用都去网关获取,false:3分钟内返回的是本地的设备</param>
			/// <param name="useLocalConnect">是否使用本地连接发送</param>
			/// <param name="mode">是否显示错误</param>
			/// <returns></returns>
			public List<CommonDevice> GetDeviceListFromGateway(ZbGateway zbGateway, ref int statu, bool ignoreTime, ShowErrorMode mode = ShowErrorMode.YES)
			public List<CommonDevice> GetDeviceListFromGateway(ZbGateway zbGateway, ref int statu, bool useLocalConnect, ShowErrorMode mode = ShowErrorMode.YES)
			{
			if (ignoreTime == false)
			{
			if ((DateTime.Now - zbGateway.LastDateTime).TotalMilliseconds < 3 * 60 * 1000)
			{
			//不无视时间,返回本地设备列表
			statu = 1;
			return this.GetDeviceByGatewayID(HdlGatewayLogic.Current.GetGatewayId(zbGateway));
			}
			}
			zbGateway.LastDateTime = DateTime.Now;

			//如果切换到了别的界面，则不显示错误信息
			string nowFormId = UserCenterResourse.NowActionFormID;

			@@ -1860,11 +2706,13 @@
			statu = -1;
			return null;
			}
			//需要变更功能类型的回路
			var listFucDevice = new List<CommonDevice>();

			//是否达成中断的时机
			bool canBreak = false;
			//网关ID
			string gatewayID = HdlGatewayLogic.Current.GetGatewayId(zbGateway);
			string gatewayID = zbGateway.GwId;
			//超时时间
			int TimeOut = 0;
			//设备总数
			@@ -1877,7 +2725,7 @@
			var listCheck = new HashSet<string>();
			Action<string, string> getDeviceAction = (topic, message) =>
			{
			if (topic == gatewayID + "/" + "DeviceInfoRespon")
			if (topic == gatewayID + "/DeviceInfoRespon")
			{
			try
			{
			@@ -1911,8 +2759,36 @@
			if (listCheck.Contains(mainkeys) == false)
			{
			listDevice.Add(device);

			listCheck.Add(mainkeys);
			//刷新一下本地缓存
			var localDevice = this.GetDevice(mainkeys);
			var tempDevice = localDevice == null ? device : localDevice;

			//如果这个设备ID变更了的话
			bool typeNotEquals = localDevice != null && deviceID != localDevice.Type;
			if (typeNotEquals == true)
			{
			//重新New这个对象
			typeNotEquals = this.ReNewDeviceOnTypeIsChanged(localDevice, deviceID);
			//重新再次获取对象
			tempDevice = this.GetDevice(mainkeys);
			}

			//刷新属性
			this.SetDeviceInfoToMain(tempDevice, device);
			if (this.RefreshDeviceFunctionType(tempDevice, device, false) == true)
			{
			//需要发送功能类型给网关
			listFucDevice.Add(tempDevice);
			}
			if (typeNotEquals == true)
			{
			//重新生成缓存
			tempDevice.ReSave();
			HdlAutoBackupLogic.AddOrEditorFile(tempDevice.FilePath);
			//全部主页菜单需要刷新
			Phone.UserView.UserPage.Instance.RefreshAllForm = true;
			}
			}
			}
			}
			@@ -1926,13 +2802,24 @@
			canBreak = true;
			}
			}
			else if (topic == gatewayID + "/DeviceInfoResponEnd")
			{
			}
			};

			realWay.Actions += getDeviceAction;
			try
			{
			var jObject = new Newtonsoft.Json.Linq.JObject { { "Cluster_ID", 0 }, { "Command", 93 } };
			realWay.Send("GetDeviceInfo", jObject.ToString());
			if (useLocalConnect == false)
			{
			realWay.Send("GetDeviceInfo", jObject.ToString());
			}
			else
			{
			//强制使用本地连接
			realWay.SendLocation("GetDeviceInfo", Encoding.UTF8.GetBytes(jObject.ToString()));
			}
			}
			catch { canBreak = true; }

			@@ -1972,7 +2859,63 @@
			statu = 2;
			}
			}
			else
			{
			statu = 1;
			}
			if (listFucDevice.Count > 0)
			{
			//如果存在需要变更的功能类型
			HdlThreadLogic.Current.RunThread(() =>
			{
			for (int i = 0; i < listFucDevice.Count; i++)
			{
			this.SendDeviceFunctionTypeToGateway(listFucDevice[i], listFucDevice[i].DfunctionType);
			System.Threading.Thread.Sleep(100);
			}
			});
			}

			return listDevice;
			}

			/// <summary>
			/// 在设备Type变更时,重新New这个设备对象(仅限在刷新设备列表使用,并且本地需要存在)
			/// </summary>
			/// <param name="oldLocalDevice">原来的本地对象</param>
			/// <param name="newDeviceType">新的设备Type</param>
			private bool ReNewDeviceOnTypeIsChanged(CommonDevice oldLocalDevice, DeviceType newDeviceType)
			{
			//先获取本地这个旧设备对象的json
			string oldFile = System.IO.Path.Combine(Config.Instance.FullPath, oldLocalDevice.FilePath);
			var deviceData = HdlFileLogic.Current.ReadFileTextContent(oldFile);
			if (deviceData == null)
			{
			//应该不会
			return false;
			}
			//根据新Type重新New对象
			var newDevice = CommonDevice.CommonDeviceByByteString(newDeviceType.ToString(), deviceData);
			if (newDevice == null)
			{
			//好像有点可能
			return false;
			}
			//删除本地文件
			HdlFileLogic.Current.DeleteFile(oldFile);
			HdlAutoBackupLogic.DeleteFile(oldLocalDevice.FilePath);

			//重新生成文件
			if (newDevice.IsCustomizeImage == false)
			{
			newDevice.IconPath = string.Empty;
			}
			string mainkey = this.GetDeviceMainKeys(newDevice);
			lock (dicAllDevice)
			{
			this.dicAllDevice[mainkey] = newDevice;
			}
			return true;
			}

			#endregion
			@@ -1980,7 +2923,7 @@
			#region ■ 创建新设备对象相关_________________

			/// <summary>
			/// 根据设备类型创建设备对象的实例
			/// 根据设备类型创建设备对象的实例(数据在DeviceInfo中)
			/// </summary>
			/// <param name="deviceType">设备类型</param>
			/// <param name="jobject">主题Data</param>
			@@ -1988,7 +2931,7 @@
			/// <returns></returns>
			private CommonDevice NewDeviceObjectByDeviceId(DeviceType deviceType, Newtonsoft.Json.Linq.JObject jobject, ZbGateway zbGateway)
			{
			string gwId = HdlGatewayLogic.Current.GetGatewayId(zbGateway);
			string gwId = zbGateway.GwId;

			//根据设备类型创建设备对象的实例
			CommonDevice device = this.NewDeviceObjectByDeviceId(deviceType);
			@@ -2003,15 +2946,10 @@
			{
			return null;
			}
			this.SetMacName(device, string.Empty);
			this.SetEpointName(device, string.Empty);

			//设置设备主键类
			this.SetNewDeviceMainKeys(device, jobject);
			device.CurrentGateWayId = gwId;

			//将DeviceInfo的属性设置到主属性中
			this.SetDeviceInfoToMain(device, device);

			return device;
			}
			@@ -2023,20 +2961,16 @@
			/// <param name="device">设置源设备对象</param>
			public void SetDeviceInfoToMain(CommonDevice mainDevice, CommonDevice device)
			{
			if (string.IsNullOrEmpty(device.DeviceInfo.MacName) == false)
			{
			mainDevice.DeviceName = device.DeviceInfo.MacName;
			}
			if (string.IsNullOrEmpty(device.DeviceInfo.DeviceName) == false)
			{
			mainDevice.DeviceEpointName = device.DeviceInfo.DeviceName;
			}
			mainDevice.DeviceName = device.DeviceInfo.MacName;
			mainDevice.DeviceEpointName = device.DeviceInfo.DeviceName;
			mainDevice.CurrentGateWayId = device.CurrentGateWayId;
			mainDevice.ZigbeeType = device.DeviceInfo.ZigbeeType;
			mainDevice.IsOnline = device.DeviceInfo.IsOnline;
			mainDevice.DriveCode = device.DeviceInfo.DriveCode;
			mainDevice.IasDeviceType = device.DeviceInfo.DeviceType;
			mainDevice.Profile = device.DeviceInfo.Profile;
			mainDevice.Type = device.Type;
			mainDevice.DeviceID = (int)device.Type;

			//固件版本
			mainDevice.ImgVersion = device.DeviceInfo.ImgVersion;
			@@ -2050,6 +2984,13 @@
			mainDevice.ModelIdentifier = device.DeviceInfo.ModelIdentifier;
			//序列号
			mainDevice.SerialNumber = device.DeviceInfo.ProductCode;
			//设备功能类型
			mainDevice.DfunctionType = (DeviceFunctionType)device.DeviceInfo.FunctionType;
			if (mainDevice.DfunctionType == DeviceFunctionType.A不指定)
			{
			//式样变更:功能类型不允许选择为空网关默认的FunctionType为0
			mainDevice.DfunctionType = DeviceFunctionType.A未定义;
			}

			mainDevice.InClusterList.Clear();
			mainDevice.InClusterList.AddRange(device.DeviceInfo.InClusterList);
			@@ -2074,24 +3015,6 @@
			}
			}
			}
			//如果是调光器
			else if (mainDevice.Type == DeviceType.DimmableLight)
			{
			mainDevice.DfunctionType = DeviceFunctionType.A灯光;
			if (mainDevice.IsCustomizeImage == false)
			{
			mainDevice.IconPath = "Device/Light.png";
			}
			}
			//如果是彩灯的话
			else if (mainDevice.Type == DeviceType.ColorDimmableLight)
			{
			mainDevice.DfunctionType = DeviceFunctionType.A灯光;
			if (mainDevice.IsCustomizeImage == false)
			{
			mainDevice.IconPath = "Device/ColorLight.png";
			}
			}
			}

			/// <summary>
			@@ -2106,15 +3029,23 @@
			//根据设备类型创建设备对象的实例
			if (deviceType == DeviceType.ColorDimmableLight) { device = new ColorDimmableLight(); }
			else if (deviceType == DeviceType.DimmableLight) { device = new DimmableLight(); }
			else if (deviceType == DeviceType.ColorDimmerSwitch) { device = new ColorDimmerSwitch(); }
			else if (deviceType == DeviceType.LevelControlSwitch) { device = new LevelControlSwitch(); }
			else if (deviceType == DeviceType.OnOffSwitch) { device = new Panel(); }
			else if (deviceType == DeviceType.OnOffOutput) { device = new ToggleLight(); }
			else if (deviceType == DeviceType.AirSwitch) { device = new AirSwitch(); }
			else if (deviceType == DeviceType.WindowCoveringDevice) { device = new Rollershade(); }
			else if (deviceType == DeviceType.WindowCoveringController) { device = new WindowCoveringController(); }
			else if (deviceType == DeviceType.IASZone) { device = new IASZone(); }
			else if (deviceType == DeviceType.Repeater) { device = new Repeater(); }
			else if (deviceType == DeviceType.Thermostat) { device = new AC(); }
			else if (deviceType == DeviceType.FreshAir) { device = new FreshAir(); }
			else if (deviceType == DeviceType.DoorLock) { device = new DoorLock(); }
			else if (deviceType == DeviceType.TemperatureSensor) { device = new TemperatureSensor(); }
			else if (deviceType == DeviceType.PMSensor) { device = new PMSensor(); }
			else if (deviceType == DeviceType.FreshAirHumiditySensor) { device = new HumiditySensor(); }
			else if (deviceType == DeviceType.ColorTemperatureLight) { device = new ColorTemperatureLight(); }
			else if (deviceType == DeviceType.Buzzer) { device = new Buzzer(); }
			else if (deviceType == DeviceType.OtaDevice \|\| deviceType == DeviceType.OtaPanelDevice) { device = new OTADevice(); }
			else { return null; }

			@@ -2132,11 +3063,142 @@
			public void SetNewDeviceMainKeys(CommonDevice device, Newtonsoft.Json.Linq.JObject jobject)
			{
			//设置设备主键类
			device.Time = jobject.Value<int>("Time");
			device.DeviceID = jobject.Value<int>("Device_ID");
			device.DeviceAddr = jobject.Value<string>("DeviceAddr");
			device.DeviceEpoint = jobject.Value<int>("Epoint");
			device.DataID = jobject.Value<int>("Data_ID");
			}

			#endregion

			#region ■ 刷新设备功能类型___________________

			/// <summary>
			/// 刷新设备的功能类型,如果返回true,代表需要另外调用【SendDeviceFunctionTypeToGateway】函数,sendFucType为true时自动调用
			/// </summary>
			/// <param name="mainDevice">主设备对象</param>
			/// <param name="device">设置源设备对象</param>
			/// <param name="sendFucType">当需要变更时,是否发送功能类型到网关(此变量给获取设备列表有特殊含义)</param>
			public bool RefreshDeviceFunctionType(CommonDevice mainDevice, CommonDevice device, bool sendFucType)
			{
			//如果是调光器
			if (mainDevice.Type == DeviceType.DimmableLight)
			{
			if (mainDevice.IsCustomizeImage == false)
			{
			mainDevice.IconPath = "Device/Light.png";
			}
			mainDevice.DfunctionType = DeviceFunctionType.A灯光;
			if (device.DeviceInfo.FunctionType != (int)DeviceFunctionType.A灯光)
			{
			//调光器固定灯光
			if (sendFucType == true)
			{
			this.SendDeviceFunctionTypeToGateway(mainDevice, DeviceFunctionType.A灯光);
			}
			return true;
			}
			}
			//如果是色温灯
			else if (mainDevice.Type == DeviceType.ColorTemperatureLight)
			{
			if (mainDevice.IsCustomizeImage == false)
			{
			mainDevice.IconPath = "Device/ColorLightTemperature.png";
			}
			mainDevice.DfunctionType = DeviceFunctionType.A灯光;
			if (device.DeviceInfo.FunctionType != (int)DeviceFunctionType.A灯光)
			{
			//色温灯固定灯光
			if (sendFucType == true)
			{
			this.SendDeviceFunctionTypeToGateway(mainDevice, DeviceFunctionType.A灯光);
			}
			return true;
			}
			}
			//如果是三路继电器的回路的话,默认为灯光
			else if (mainDevice.Type == DeviceType.OnOffOutput)
			{
			//根据功能类型,重新设置设备回路图标
			this.ResetIconPathByDeviceFunctionType(mainDevice);
			//2020.05.13变更:继电器都默认为灯光
			if (mainDevice.DfunctionType == DeviceFunctionType.A未定义)
			{
			mainDevice.DfunctionType = DeviceFunctionType.A灯光;
			if (device.DeviceInfo.FunctionType != (int)DeviceFunctionType.A灯光)
			{
			//继电器默认为灯光
			if (sendFucType == true)
			{
			this.SendDeviceFunctionTypeToGateway(mainDevice, DeviceFunctionType.A灯光);
			}
			return true;
			}
			}
			}
			//如果是空气开关的话
			else if (mainDevice.Type == DeviceType.AirSwitch)
			{
			//根据功能类型,重新设置设备回路图标
			this.ResetIconPathByDeviceFunctionType(mainDevice);
			//空气开关默认为开关
			if (mainDevice.DfunctionType == DeviceFunctionType.A未定义)
			{
			mainDevice.DfunctionType = DeviceFunctionType.A开关;
			if (device.DeviceInfo.FunctionType != (int)DeviceFunctionType.A开关)
			{
			//空气开关默认为开关
			if (sendFucType == true)
			{
			this.SendDeviceFunctionTypeToGateway(mainDevice, DeviceFunctionType.A开关);
			}
			return true;
			}
			}
			}
			//如果是彩灯的话
			else if (mainDevice.Type == DeviceType.ColorDimmableLight)
			{
			if (mainDevice.IsCustomizeImage == false)
			{
			mainDevice.IconPath = "Device/ColorLight.png";
			}
			mainDevice.DfunctionType = DeviceFunctionType.A灯光;
			if (device.DeviceInfo.FunctionType != (int)DeviceFunctionType.A灯光)
			{
			//彩灯默认为开关
			if (sendFucType == true)
			{
			this.SendDeviceFunctionTypeToGateway(mainDevice, DeviceFunctionType.A开关);
			}
			return true;
			}
			}
			return false;
			}

			/// <summary>
			/// 根据功能类型,重新设置设备回路图标
			/// </summary>
			/// <param name="device"></param>
			private void ResetIconPathByDeviceFunctionType(CommonDevice device)
			{
			if (device.IsCustomizeImage == true)
			{
			return;
			}
			if (device.DfunctionType == DeviceFunctionType.A开关)
			{
			device.IconPath = "Device/Switch.png";
			}
			else if (device.DfunctionType == DeviceFunctionType.A插座)
			{
			device.IconPath = "Device/Socket1.png";
			}
			else
			{
			device.IconPath = "Device/Light.png";
			}
			}

			#endregion
			@@ -2150,71 +3212,49 @@
			/// </summary>
			private void InitDeviceModelIdEnum()
			{
			//*********************************************************************
			//新设备添加方法：
			//1、在最下面添加 DeviceConcreteType ，然后是 DeviceBeloneType
			//2、以设备的具体类型为名字DeviceConcreteType(去掉【-】)添加设备的【所属图片】，【真实物理图片】。回路图片需要特殊处理
			//3、如果需要共有图片,则在这个函数的最底下添加
			//4、显示的模块ID需要交换的话,则在这个函数的最底下添加
			//*********************************************************************

			if (this.dicDeviceModelIdEnum != null)
			{
			return;
			}
			this.dicDeviceModelIdEnum = new Dictionary<string, string>();
			this.dicDeviceModelIdEnum = new Dictionary<string, DeviceNameContent>();

			//定义规则：模块ID(已翻译)=设备具体类型值-设备所属类型值(自定义的值,嘛,只要不重复就可以)
			//第一个值是:DeviceConcreteType 第二个值是:DeviceBeloneType

			//*********************************************************************
			//新设备添加方法：
			//1、在这里填写上模块ID，然后是 DeviceConcreteType ，然后是 DeviceBeloneType
			//2、然后在最下面添加【设备的具体类型】，【设备的所属类型】
			//3、已设备的具体类型为名字(去掉【-】)添加设备的【所属图片】，【真实物理图片】。回路图片需要特殊处理
			//4、添加R文件,添加Language文件
			//*********************************************************************

			//=========★★开合帘类(100-199)★★=========
			this.dicDeviceModelIdEnum["MWM65B-ZB.20"] = "100-100";//智能开合帘电机
			this.dicDeviceModelIdEnum["MVSM35B-ZB.20"] = "101-100";//智能管状电机

			//=========★★按键面板类(200-1199)★★=========
			this.dicDeviceModelIdEnum["MPT4/R4-ZB.18"] = "200-200";//4按键触摸面板(带4路继电器底座)
			this.dicDeviceModelIdEnum["MPT3/R3-ZB.18"] = "201-200";//3按键触摸面板
			this.dicDeviceModelIdEnum["MPT2/R2-ZB.18"] = "202-200";//2按键触摸面板
			this.dicDeviceModelIdEnum["MPT1/R1-ZB.18"] = "203-200";//12按键触摸面板
			this.dicDeviceModelIdEnum["MPT4-ZB.18"] = "210-200";//4按键触摸面板(只带电源底座)
			this.dicDeviceModelIdEnum["MPT4R4L/S-ZB.18"] = "220-200";//简约4按键面板
			this.dicDeviceModelIdEnum["MPT3R3L/S-ZB.18"] = "221-200";//简约3按键面板
			this.dicDeviceModelIdEnum["MPT2R2L/S-ZB.18"] = "222-200";//简约2按键面板

			//=========★★PIR传感器类(1200-1299)★★=========
			this.dicDeviceModelIdEnum["MSPIR01-ZB.10"] = "1200-1200";//pir传感器220

			//=========★★安防类传感器类(1300-2299)★★=========
			this.dicDeviceModelIdEnum["MULTI-GASE--EA07"] = "1300-1300";//燃气传感器
			this.dicDeviceModelIdEnum["MULTI-MECI--EA01"] = "1301-1300";//门窗磁传感器
			this.dicDeviceModelIdEnum["MULTI-FIRE--EA05"] = "1302-1300";//烟雾传感器
			this.dicDeviceModelIdEnum["MULTI-MOTI--EA04"] = "1303-1300";//红外传感器
			this.dicDeviceModelIdEnum["MULTI-WATE--EA02"] = "1304-1300";//水浸传感器
			this.dicDeviceModelIdEnum["MULTI-BURO--EA06"] = "1305-1300";//紧急按键

			//=========★★继电器类(2300-2499)★★=========
			this.dicDeviceModelIdEnum["MPR0310-ZB.10"] = "2300-2300";//3路继电器小模块

			//=========★★调光器类(2500-2799)★★=========
			this.dicDeviceModelIdEnum["MPD0101-ZB.10"] = "2500-2500";//1路调光器小模块

			//=========★★智能门锁类(2800-????)★★=========
			this.dicDeviceModelIdEnum["H06C"] = "2800-2800";//智能门锁(H06C)

			//=========★★空调类(3600-3899)★★=========
			this.dicDeviceModelIdEnum["MAC/GW-ZB.10"] = "3600-3600";//zigbee空调网关模块

			//=========★★中继器类(3900-3999)★★=========
			this.dicDeviceModelIdEnum["MSR-ZB.10"] = "3900-3900"; //zigbee中继器

			//=========★★空气开关类(4100-4199)★★=========
			this.dicDeviceModelIdEnum["MBCI01-ZB.10"] = "4100-4100";//zigbee微断云控制器

			//=========★★转换器类(4200-4699)★★=========
			this.dicDeviceModelIdEnum["MBUS/GW-ZB.10"] = "4200-4200";//zigbee转buspro协议转换器
			this.dicDeviceModelIdEnum["M485/GW-ZB.10"] = "4201-4200";//zigbee转485协议转换器


			var listText = this.GetDeviceNameFileContent();
			foreach (var dataText in listText)
			{
			if (dataText == string.Empty \|\| dataText.StartsWith(";") == true)
			{
			//这是注释
			continue;
			}
			string[] strArry1 = dataText.Split(new string[] { "=" }, StringSplitOptions.RemoveEmptyEntries);
			if (strArry1.Length != 2)
			{
			//非法设置
			continue;
			}
			string[] strArry2 = strArry1[1].Split(new string[] { "/" }, StringSplitOptions.RemoveEmptyEntries);
			if (strArry2.Length < 6)
			{
			//非法设置
			continue;
			}
			var content = new DeviceNameContent();
			content.ConcreteTypeValue = Convert.ToInt32(strArry2[0].Trim());
			content.A官方名字 = strArry2[1].Trim();
			content.A备注名字 = strArry2[2].Trim();
			content.BeloneTypeValue= Convert.ToInt32(strArry2[3].Trim());
			content.A所属名字 = strArry2[4].Trim();
			content.A类型名字 = strArry2[5].Trim();
			this.dicDeviceModelIdEnum[strArry1[0].Trim()] = content;
			}

			//✩✩✩✩✩需要交换的模块ID✩✩✩✩✩
			this.dicDeviceModelIdChanged = new Dictionary<string, string>();
			@@ -2226,13 +3266,64 @@
			this.dicDeviceModelIdChanged["MULTI-WATE--EA02"] = "MSW01/M-ZB.10";//水浸传感器
			this.dicDeviceModelIdChanged["MULTI-BURO--EA06"] = "MBU01/M-ZB.10";//紧急按键



			//✩✩✩✩✩需要共有的图片对象✩✩✩✩✩
			//两者都是DeviceConcreteType
			//Keys:指定的设备 value:沿用的图片是哪款设备的
			this.dicPictrueShard = new Dictionary<string, string>();
			this.dicPictrueShard["ButtonPanel_SimpleFour"] = "ButtonPanel_Four";//简约4按键面板沿用 4按键的图标
			this.dicPictrueShard["ButtonPanel_SimpleThree"] = "ButtonPanel_Three";//简约3按键面板沿用 3按键的图标
			this.dicPictrueShard["ButtonPanel_SimpleTwo"] = "ButtonPanel_Two";//简约2按键面板沿用 2按键的图标
			this.dicPictrueShard["IntelligentLocks_Sone"] = "IntelligentLocks_H06C";//S-one的门锁图片沿用 H06C的图标
			this.dicPictrueShard["Relay_FangyueFreshAirModul"] = "Relay_ThreeLoad";//方悦新风小模块图片沿用 3路继电器的图标
			this.dicPictrueShard["ButtonPanel_FourButtonScene"] = "ButtonPanel_Four";//简约4按键场景面板沿用 4按键面板的图标
			}

			/// <summary>
			/// 获取设备名字文件的内容
			/// </summary>
			/// <returns></returns>
			private List<string> GetDeviceNameFileContent()
			{
			System.IO.StreamReader streamReader = null;
			var listText = new List<string>();
			try
			{
			#if iOS
			string textFile = Foundation.NSBundle.MainBundle.PathForResource("DeviceName.ini", null);
			streamReader = new System.IO.StreamReader(textFile, Encoding.UTF8);
			string text;
			while ((text = streamReader.ReadLine()) != null)
			{
			listText.Add(text.Trim());
			}
			return listText;
			#endif
			#if Android
			var stream = Application.Activity.Assets.Open("DeviceName.ini");
			streamReader = new System.IO.StreamReader(stream, Encoding.UTF8);
			string text;
			while ((text = streamReader.ReadLine()) != null)
			{
			listText.Add(text.Trim());
			}
			stream.Close();
			return listText;
			#endif
			}
			catch
			{
			return listText;
			}
			finally
			{
			try
			{
			streamReader?.Close();
			}
			catch
			{
			}
			}
			}

			#endregion
			@@ -2241,13 +3332,10 @@
			#region ■ 自定义设备类型_________________________

			/// <summary>
			/// <para>仅限底层使用：设备的具体【设备类型】,自定义与模块id关联的枚举(值为LocalDevice里面dicDeviceModelIdEnum所指定的值)</para>
			/// <para>变量名可以作为【设备类型】图片,这个值是瞎写的,没什么特殊意义</para>
			/// <para>设备的具体【设备类型】,变量名可以作为【设备类型】图片,这个值是瞎写的,没什么特殊意义</para>
			/// </summary>
			public enum DeviceConcreteType
			{
			//定义规则：【设备类型】图片名字=LocalDevice里面dicDeviceModelIdEnum所指定的值

			/// <summary>
			/// 未知设备
			/// </summary>
			@@ -2304,6 +3392,46 @@
			/// 简约2按键面板镜像id：222
			/// </summary>
			ButtonPanel_SimpleTwo = 222,
			/// <summary>
			/// 简约4按键场景面板镜像id：224
			/// </summary>
			ButtonPanel_FourButtonScene = 224,
			/// <summary>
			/// 简约2路窗帘面板镜像id：226
			/// </summary>
			ButtonPanel_TwoButtonCurtain = 226,
			/// <summary>
			/// 方悦2按键轻触式面板镜像id：240
			/// </summary>
			ButtonPanel_FangyueTwo = 240,
			/// <summary>
			/// 方悦4按键轻触式面板镜像id：241
			/// </summary>
			ButtonPanel_FangyueFour = 241,
			/// <summary>
			/// 方悦8按键轻触式面板镜像id：242
			/// </summary>
			ButtonPanel_FangyueEight = 242,
			/// <summary>
			/// 方悦新风面板镜像id：250
			/// </summary>
			ButtonPanel_FangyueFreshAir = 250,
			/// <summary>
			/// 方悦环境面板镜像id：253
			/// </summary>
			ButtonPanel_FangyueEnvironment = 253,
			/// <summary>
			/// 窗帘面板镜像id：256
			/// </summary>
			ButtonPanel_Curtain = 256,
			/// <summary>
			/// 简约多功能面板镜像ID：212
			/// </summary>
			ButtonPanel_SimpleMultifunction = 212,
			/// <summary>
			/// 简约环境面板
			/// </summary>
			ButtonPanel_SimpleEnvironment = 230,

			//=========★★PIR传感器类(1200-1299)★★=========
			/// <summary>
			@@ -2314,6 +3442,10 @@
			/// pir传感器220 镜像id：1200
			/// </summary>
			Sensor_Pir = 1200,
			/// <summary>
			/// 球形移动传感器镜像id：1205
			/// </summary>
			Sensor_SphericalMotion = 1205,

			//=========★★安防类传感器类(1300-2299)★★=========
			/// <summary>
			@@ -2341,6 +3473,19 @@
			/// </summary>
			Sensor_EmergencyButton = 1305,
			/// <summary>
			/// 吸顶燃气传感器
			/// </summary>
			Sensor_CeilingGas = 1306,
			/// <summary>
			/// PM2.5空气质量传感器
			/// </summary>
			Sensor_PMTwoPointFive = 1307,
			/// <summary>
			/// 温湿度传感器(这个单词拼错了,但是错了就错了呗,就这样了)
			/// </summary>
			Sensor_TemperatureHumidity = 1308,

			/// <summary>
			/// 运动传感器
			/// </summary>
			Sensor_Motion = -1306,
			@@ -2349,11 +3494,7 @@
			/// </summary>
			Sensor_Keyfob = -1307,
			/// <summary>
			/// 温湿度传感器
			/// </summary>
			Sensor_TemperatureHumidity = -1308,
			/// <summary>
			/// 温度传感器
			/// 温度传感器(这个单词拼错了,但是错了就错了呗,就这样了)
			/// </summary>
			Sensor_Temperature = -1309,
			/// <summary>
			@@ -2370,6 +3511,22 @@
			/// 三路继电器镜像id：2300
			/// </summary>
			Relay_ThreeLoad = 2300,
			/// <summary>
			/// 方悦新风小模块镜像id：2310
			/// </summary>
			Relay_FangyueFreshAirModul = 2310,
			/// <summary>
			/// 国标3路10A继电器小模块镜像id：2311(临时)
			/// </summary>
			Relay_NationalThreeLoadTenA = 2311,
			/// <summary>
			/// 欧标2路5A继电器小模块镜像id：2312(临时)
			/// </summary>
			Relay_EuropeanTwoLoadFiveA = 2312,
			/// <summary>
			/// 欧标14路干接点小模块镜像id：2313(临时)
			/// </summary>
			Relay_EuropeanFourteenLoadDryContact = 2313,

			//=========★★调光器类(2500-2799)★★=========
			/// <summary>
			@@ -2390,12 +3547,20 @@
			/// H06C
			/// </summary>
			IntelligentLocks_H06C = 2800,
			/// <summary>
			/// S-one
			/// </summary>
			IntelligentLocks_Sone = 2802,

			//=========★★彩灯类(????-????)★★=========
			/// <summary>
			/// 彩灯
			/// </summary>
			ColorLight = -10,
			/// <summary>
			/// 色温灯(它的镜像ID未定,暂定20000)
			/// </summary>
			ColorLight_Temperature = 20000,

			//=========★★空调(3600-3899)★★=========
			/// <summary>
			@@ -2443,26 +3608,25 @@

			//=========★★其他类(????-????)★★=========
			/// <summary>
			/// 干接点
			/// 干接点(注意,它属于其他类,不是设备类型)
			/// </summary>
			DryContact = -10000,
			/// <summary>
			/// 灯光(注意,它输入其他类,不是设备类型)
			/// 灯光(注意,它属于其他类,不是设备类型)
			/// </summary>
			Light = -10001,
			/// <summary>
			/// 插座
			/// 插座(注意,它属于其他类,不是设备类型)
			/// </summary>
			Socket1 = -10002,
			/// <summary>
			/// 开关
			/// 开关(注意,它属于其他类,不是设备类型)
			/// </summary>
			Switch = -10003,
			}

			/// <summary>
			/// <para>仅限底层使用：设备所属的【设备种类】,自定义与模块id关联的枚举(值为LocalDevice里面dicDeviceModelIdEnum所指定的值)</para>
			/// <para>这个值是瞎写的,没什么特殊意义</para>
			/// <para>设备所属枚举,这个值是瞎写的,没什么特殊意义</para>
			/// </summary>
			public enum DeviceBeloneType
			{
			@@ -2483,9 +3647,17 @@
			/// </summary>
			A传感器 = 1200,
			/// <summary>
			/// PM2.5空气质量传感器
			/// </summary>
			APM2点5空气质量传感器 = 1307,
			/// <summary>
			/// 继电器(2300-2499)
			/// </summary>
			A继电器 = 2300,
			/// <summary>
			/// 新风
			/// </summary>
			A新风 = 2310,
			/// <summary>
			/// 调光器(2500-2799)
			/// </summary>
			@@ -2541,7 +3713,7 @@
			/// <summary>
			/// 干接点
			/// </summary>
			A干接点 = 16
			A干接点 = 16,
			}

			#endregion