~xm/HomeApp.git

old mode 100755 new mode 100644

			@@ -1,321 +1,803 @@
			using System;
			using System.Collections.Generic;
			using System.Text;
			using ZigBee.Device;
			using System.Threading.Tasks;

			namespace Shared.Phone.UserCenter
			{
			/// <summary>
			/// 设备绑定的逻辑
			/// </summary>
			public class HdlDeviceBindLogic
			{
			#region ■ 变量声明___________________________

			/// <summary>
			/// 设备绑定的逻辑
			using System;
			using System.Collections.Generic;
			using System.Text;
			using ZigBee.Device;
			using System.Threading.Tasks;
			using Newtonsoft.Json.Linq;

			namespace Shared.Phone.UserCenter
			{
			/// <summary>
			/// 设备绑定的逻辑
			/// </summary>
			public class HdlDeviceBindLogic
			{
			#region ■ 变量声明___________________________

			/// <summary>
			/// 设备绑定的逻辑
			/// </summary>
			private static HdlDeviceBindLogic m_Current = null;
			/// <summary>
			/// 设备绑定的逻辑
			/// </summary>
			public static HdlDeviceBindLogic Current
			{
			get
			{
			if (m_Current == null)
			{
			m_Current = new HdlDeviceBindLogic();
			}
			return m_Current;
			}
			}

			#endregion

			#region ■ 获取设备下面绑定的设备_____________

			/// <summary>
			/// 获取设备下面绑定的设备(错误时返回null)
			/// </summary>
			/// <param name="mainDevice">设备对象</param>
			/// <returns></returns>
			public async Task<List<CommonDevice>> GetBindTargetDevice(CommonDevice mainDevice)
			{
			var result = (BindObj.GetDeviceBindResponseAllData)await this.LoadDeviceMethodByNameAsync(mainDevice, "GetDeviceBindAsync");
			if (result == null \|\| result.getAllBindResponseData == null)
			{
			//获取设备的绑定目标失败
			string msg = Language.StringByID(R.MyInternationalizationString.uGetDeviceBindTargetFail);
			//拼接上【网关回复超时】的Msg
			msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result);

			this.ShowErrorMsg(msg);
			return null;
			}
			var listDevice = new List<CommonDevice>();
			foreach (var data in result.getAllBindResponseData.BindList)
			{
			CommonDevice deviceTemp = Common.LocalDevice.Current.GetDevice(data.BindMacAddr, data.BindEpoint);
			if (deviceTemp == null)
			{
			continue;
			}
			listDevice.Add(deviceTemp);
			}
			return listDevice;
			}

			#endregion

			#region ■ 执行绑定设备目标___________________

			/// <summary>
			/// 绑定设备的目标(返回成功设置的设备,错误时，返回null)
			/// </summary>
			/// <param name="mainDevice">设备对象</param>
			/// <param name="listDevice">要绑定的目标设备</param>
			/// <param name="BindCluster">要绑定的目标设备</param>
			/// <returns></returns>
			public async Task<List<CommonDevice>> BindDeviceTarget(CommonDevice mainDevice, List<CommonDevice> listDevice, int BindCluster = 6)
			{
			if (listDevice.Count == 0)
			{
			return new List<CommonDevice>();
			}

			var dicDevice = new Dictionary<string, CommonDevice>();

			//组装数据
			var addData = new IASZone.AddBindData();
			addData.DeviceAddr = mainDevice.DeviceAddr;
			addData.Epoint = mainDevice.DeviceEpoint;
			foreach (var device in listDevice)
			{
			var info = new IASZone.AddBindListObj();
			info.BindCluster = BindCluster;
			info.BindMacAddr = device.DeviceAddr;
			info.BindEpoint = device.DeviceEpoint;
			info.BindType = 0;

			addData.BindList.Add(info);

			//返回成功设备的时候使用
			string mainkeys = Common.LocalDevice.Current.GetDeviceMainKeys(device);
			dicDevice[mainkeys] = device;
			}

			var result = (BindObj.AddedDeviceBindResponseAllData)await this.LoadDeviceMethodByNameAsync(mainDevice, "AddDeviceBindAsync", addData);
			if (result == null \|\| result.addedDeviceBindResponseData == null)
			{
			//绑定目标设置失败
			string msg = Language.StringByID(R.MyInternationalizationString.uSetBindTargetsFail);
			//拼接上【网关回复超时】的Msg
			msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result);

			this.ShowErrorMsg(msg);
			return null;
			}

			var listSuccess = new List<CommonDevice>();
			foreach (var data in result.addedDeviceBindResponseData.BindList)
			{
			string mainkeys = Common.LocalDevice.Current.GetDeviceMainKeys(data.BindMacAddr, data.BindEpoint);
			//0:添加成功 3:已经存在，也可以代表成功
			if (data.Result == 0 \|\| data.Result == 3)
			{
			if (dicDevice.ContainsKey(mainkeys) == true)
			{
			listSuccess.Add(dicDevice[mainkeys]);
			}
			}
			//1：失败，节点设备或场景不存在
			else if (data.Result == 1)
			{
			if (dicDevice.ContainsKey(mainkeys) == true)
			{
			//设备名称绑定失败
			string msg = Common.LocalDevice.Current.GetDeviceEpointName(dicDevice[mainkeys]) + "\r\n";
			msg += Language.StringByID(R.MyInternationalizationString.BindFailed);
			this.ShowTipMsg(msg);
			}
			}
			//2：未知，由节点设备反馈发送“Bind/BindResult”主题消息确定是否成功
			else if (data.Result == 2)
			{
			if (result.addBindResultResponseData == null)
			{
			//设备名称绑定失败
			string msg = Common.LocalDevice.Current.GetDeviceEpointName(dicDevice[mainkeys]) + "\r\n";
			msg += Language.StringByID(R.MyInternationalizationString.BindFailed);
			this.ShowTipMsg(msg);
			}
			else
			{
			//添加成功
			if (result.addBindResultResponseData.Result == 0)
			{
			if (dicDevice.ContainsKey(mainkeys) == true)
			{
			listSuccess.Add(dicDevice[mainkeys]);
			}
			}
			//设备名称绑定列表已满
			else if (result.addBindResultResponseData.Result == 140)
			{
			string msg = Common.LocalDevice.Current.GetDeviceEpointName(dicDevice[mainkeys]) + "\r\n";
			msg += Language.StringByID(R.MyInternationalizationString.uBindListIsFull);
			this.ShowTipMsg(msg);
			}
			else
			{
			//设备名称绑定失败
			string msg = Common.LocalDevice.Current.GetDeviceEpointName(dicDevice[mainkeys]) + "\r\n";
			msg += Language.StringByID(R.MyInternationalizationString.BindFailed);
			this.ShowTipMsg(msg);
			}
			}
			}
			}

			return listSuccess;
			}

			#endregion

			#region ■ 删除设备绑定的目标_________________

			/// <summary>
			/// 删除设备绑定的目标
			/// </summary>
			/// <param name="mainDevice">设备对象</param>
			/// <param name="deleteDevice">要删除的绑定目标设备</param>
			/// <param name="BindCluster">要绑定的目标设备</param>
			/// <returns></returns>
			public async Task<bool> DeleteDeviceTarget(CommonDevice mainDevice, CommonDevice deleteDevice, int BindCluster = 6)
			{
			//组装数据
			var deleteData = new IASZone.DelDeviceBindData();
			deleteData.DeviceAddr = mainDevice.DeviceAddr;
			deleteData.Epoint = mainDevice.DeviceEpoint;

			var info = new IASZone.RemoveBindListObj();
			info.BindCluster = 6;
			info.BindMacAddr = deleteDevice.DeviceAddr;
			info.BindEpoint = deleteDevice.DeviceEpoint;
			info.BindType = 0;

			deleteData.RemoveBindList.Add(info);

			var result = (BindObj.DelDeviceBindResponseAllData)await this.LoadDeviceMethodByNameAsync(mainDevice, "DelDeviceBindAsync", deleteData);
			if (result == null \|\| result.delDeviceBindResponseData == null)
			{
			//删除绑定目标失败
			string msg = Language.StringByID(R.MyInternationalizationString.uDeleteBindTargetsFail);
			//拼接上【网关回复超时】的Msg
			msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result);

			this.ShowErrorMsg(msg);
			return false;
			}

			foreach (var data in result.delDeviceBindResponseData.RemoveBindList)
			{
			//0:成功 1:设备不在绑定列表中，也可以代表成功
			if (data.Result == 0 \|\| data.Result == 1)
			{
			return true;
			}
			//3:失败，在等待节点设备确认是否解除绑定成功
			else if (data.Result == 3)
			{
			//其他绑定目标正在删除中，请稍后再试
			string msg = Language.StringByID(R.MyInternationalizationString.uOtherBindTargetsIsDelettingPleaseWait);
			this.ShowErrorMsg(msg);
			return false;
			}
			//4：未知，由节点设备反馈发送“Bind/BindResult”主题消息确定是否成功
			else if (data.Result == 4)
			{
			if (result.removeBindResultResponseData == null)
			{
			//删除绑定目标失败
			string msg = Language.StringByID(R.MyInternationalizationString.uDeleteBindTargetsFail);
			this.ShowErrorMsg(msg);
			return false;
			}
			else
			{
			//成功
			if (result.removeBindResultResponseData.Result == 0)
			{
			return true;
			}
			//136：控制设备本地绑定列表中无此绑定
			else if (result.removeBindResultResponseData.Result == 136)
			{
			//这个可以当做成功
			return true;
			}
			else
			{
			//删除绑定目标失败
			string msg = Language.StringByID(R.MyInternationalizationString.uDeleteBindTargetsFail);
			this.ShowErrorMsg(msg);
			return false;
			}
			}
			}
			}
			return false;
			}

			#endregion

			#region ■ 一般方法___________________________

			/// <summary>
			/// 执行指定设备对象类里面的方法(注意：这个是专门调用异步，并且等待异步完成的高科技函数,不调用异步的情况，别使用此函数)
			/// 设备绑定的逻辑
			/// </summary>
			/// <param name="device">需要执行的设备的设备对象</param>
			/// <param name="method">指定要加载的方法名</param>
			/// <param name="parameter">启动参数</param>
			private async Task<object> LoadDeviceMethodByNameAsync(CommonDevice device, string method, params object[] parameter)
			{
			var task = device.GetType().InvokeMember(method, System.Reflection.BindingFlags.InvokeMethod, null, device, parameter) as Task;
			await task;
			public static HdlDeviceBindLogic Current
			{
			get
			{
			if (m_Current == null)
			{
			m_Current = new HdlDeviceBindLogic();
			}
			return m_Current;
			}
			}

			var result = task.GetType().GetProperty("Result").GetValue(task, null);
			return result;
			}

			/// <summary>
			/// 显示错误信息窗口
			/// </summary>
			/// <param name="msg"></param>
			private void ShowErrorMsg(string msg)
			{
			Application.RunOnMainThread(() =>
			{
			var contr = new ShowMsgControl(ShowMsgType.Error, msg);
			contr.Show();
			});
			}

			/// <summary>
			/// 显示Tip信息窗口
			/// </summary>
			/// <param name="msg"></param>
			private void ShowTipMsg(string msg)
			{
			Application.RunOnMainThread(() =>
			{
			var contr = new UserCenter.ShowMsgControl(ShowMsgType.Tip, msg);
			contr.Show();
			});
			}

			#endregion
			}
			}
			#endregion

			#region ■ 获取设备下面绑定的设备_____________

			/// <summary>
			/// 获取设备下面绑定的设备(错误时返回null),这个是给pir传感器用的
			/// </summary>
			/// <param name="mainDevice">设备对象</param>
			/// <returns></returns>
			public List<CommonDevice> GetBindTargetDevice(CommonDevice mainDevice)
			{
			var result = this.GetDeviceBindAsync(mainDevice);
			if (result == null \|\| result.getAllBindResponseData == null)
			{
			//获取设备的绑定目标失败
			string msg = Language.StringByID(R.MyInternationalizationString.uGetDeviceBindTargetFail);
			//拼接上【网关回复超时】的Msg
			msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result);

			this.ShowErrorMsg(msg);
			return null;
			}
			var listDevice = new List<CommonDevice>();
			foreach (var data in result.getAllBindResponseData.BindList)
			{
			CommonDevice deviceTemp = Common.LocalDevice.Current.GetDevice(data.BindMacAddr, data.BindEpoint);
			if (deviceTemp == null)
			{
			continue;
			}
			listDevice.Add(deviceTemp);
			}
			return listDevice;
			}

			/// <summary>
			///获取所有绑定
			/// </summary>
			public BindObj.GetDeviceBindResponseAllData GetDeviceBindAsync(CommonDevice device)
			{
			//如果当前住宅是虚拟住宅
			if (Common.Config.Instance.Home.IsVirtually == true)
			{
			var listBind = TemplateData.TemplateDeviceDataLogic.Current.GetDeviceBindList(device);
			return new BindObj.GetDeviceBindResponseAllData()
			{
			getAllBindResponseData = new BindObj.GetDeviceBindResponseData
			{
			Result = 0,
			BindList = listBind
			}
			};
			}

			var jObject = new JObject { { "DeviceAddr", device.DeviceAddr }, { "Epoint", device.DeviceEpoint }, { "Cluster_ID", 0 }, { "Command", 5007 } };
			string sendData = jObject.ToString();
			//发送
			var result = HdlDeviceCommonLogic.Current.SendJobjectDataToGateway(device, "Bind/GetDeviceBind", sendData, "Bind/GetDeviceBind_Respon", 6);
			if (result.ErrorMsg != null \|\| result.ErrorMsgDiv == 0)
			{
			return null;
			}
			var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<BindObj.GetDeviceBindResponseData>(result.ReceiptData);
			return new BindObj.GetDeviceBindResponseAllData() { getAllBindResponseData = tempData };
			}

			#endregion

			#region ■ 执行绑定设备目标___________________

			/// <summary>
			/// 绑定设备的目标(返回成功设置的设备,错误时，返回null)
			/// </summary>
			/// <param name="mainDevice">设备对象</param>
			/// <param name="listDevice">要绑定的目标设备</param>
			/// <param name="BindCluster">BindCluster</param>
			/// <returns></returns>
			public List<CommonDevice> BindDeviceTarget(CommonDevice mainDevice, List<CommonDevice> listDevice, int BindCluster = 6)
			{
			if (listDevice.Count == 0)
			{
			return new List<CommonDevice>();
			}

			var dicDevice = new Dictionary<string, CommonDevice>();

			//组装数据
			var addData = new IASZone.AddBindData();
			addData.DeviceAddr = mainDevice.DeviceAddr;
			addData.Epoint = mainDevice.DeviceEpoint;
			foreach (var device in listDevice)
			{
			var info = new IASZone.AddBindListObj();
			info.BindCluster = BindCluster;
			info.BindMacAddr = device.DeviceAddr;
			info.BindEpoint = device.DeviceEpoint;
			info.BindType = 0;

			addData.BindList.Add(info);

			//返回成功设备的时候使用
			string mainkeys = Common.LocalDevice.Current.GetDeviceMainKeys(device);
			dicDevice[mainkeys] = device;
			}
			//执行绑定
			var result = this.AddDeviceBindAsync(addData);
			if (result == null \|\| result.addedDeviceBindResponseData == null)
			{
			//绑定目标设置失败
			string msg = Language.StringByID(R.MyInternationalizationString.uSetBindTargetsFail);
			//拼接上【网关回复超时】的Msg
			msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result);

			this.ShowErrorMsg(msg);
			return null;
			}

			var listSuccess = new List<CommonDevice>();
			foreach (var data in result.addedDeviceBindResponseData.BindList)
			{
			string mainkeys = Common.LocalDevice.Current.GetDeviceMainKeys(data.BindMacAddr, data.BindEpoint);
			if (dicDevice.ContainsKey(mainkeys) == true)
			{
			listSuccess.Add(dicDevice[mainkeys]);
			}
			}

			if (listSuccess.Count == 0)
			{
			//绑定目标设置失败
			string msg = Language.StringByID(R.MyInternationalizationString.uSetBindTargetsFail);
			this.ShowTipMsg(msg);
			}
			return listSuccess;
			}

			/// <summary>
			///设备绑定
			/// </summary>
			public BindObj.AddedDeviceBindResponseAllData AddDeviceBindAsync(BindObj.AddBindData addBindData)
			{
			//如果当前住宅是虚拟住宅
			if (Common.Config.Instance.Home.IsVirtually == true)
			{
			return TemplateData.TemplateDeviceDataLogic.Current.AddDeviceBindList(addBindData, null);
			}

			var device = Common.LocalDevice.Current.GetDevice(addBindData.DeviceAddr, addBindData.Epoint);
			//获取发送的命令字符
			var sendData = this.GetAddDeviceListBindCommandText(addBindData);
			//发送
			var result = HdlDeviceCommonLogic.Current.SendJobjectDataToGateway(device, "Bind/SetBind", sendData, "Bind/SetBind_Respon", 20);
			if (result.ErrorMsg != null \|\| result.ErrorMsgDiv == 0)
			{
			return null;
			}

			//修改缓存
			TemplateData.TemplateDeviceDataLogic.Current.AddDeviceBindList(addBindData, result.JsonData[0]);
			var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<BindObj.AddedDeviceBindResponseData>(result.ReceiptData);
			return new BindObj.AddedDeviceBindResponseAllData() { addedDeviceBindResponseData = tempData };
			}

			/// <summary>
			/// 获取添加设备绑定的命令字符
			/// </summary>
			/// <param name="addBindData"></param>
			/// <returns></returns>
			public string GetAddDeviceListBindCommandText(BindObj.AddBindData addBindData)
			{
			var jObject = new JObject { { "DeviceAddr", addBindData.DeviceAddr }, { "Epoint", addBindData.Epoint }, { "Cluster_ID", 0 }, { "Command", 5001 } };
			var bindList = new JArray { };
			foreach (var bindInfo in addBindData.BindList)
			{
			if (bindInfo.BindType == 0)
			{
			var dInfo = new JObject{{ "BindMacAddr",bindInfo.BindMacAddr},{ "BindEpoint", bindInfo.BindEpoint} ,
			{ "BindCluster", bindInfo.BindCluster} ,{ "BindType",bindInfo.BindType}};
			bindList.Add(dInfo);
			}
			else if (bindInfo.BindType == 1)
			{
			var dInfo = new JObject{{ "BindCluster", bindInfo.BindCluster} ,{ "BindType",bindInfo.BindType},
			{ "BindScenesId", bindInfo.BindScenesId}};
			bindList.Add(dInfo);
			}
			}
			var data = new JObject { { "BindName", addBindData.BindName }, { "BindList", bindList } };
			jObject.Add("Data", data);
			return jObject.ToString();
			}

			/// <summary>
			///设备绑定【一对一绑定，一个按键回路只能绑定一个设备】
			/// </summary>
			public BindObj.AddedDeviceSingleBindResponseAllData AddDeviceSingleBindAsync(BindObj.AddSingleBindData addSingleBindData)
			{
			var device = Common.LocalDevice.Current.GetDevice(addSingleBindData.DeviceAddr, addSingleBindData.Epoint);
			//获取发送的命令字符
			var sendData = this.GetAddDeviceListSingleBindCommandText(addSingleBindData);
			//发送
			var result = HdlDeviceCommonLogic.Current.SendJobjectDataToGateway(device, "Bind/SetSingleBind", sendData, "Bind/SetSingleBind_Respon", 20);
			if (result.ErrorMsg != null \|\| result.ErrorMsgDiv == 0)
			{
			return null;
			}

			var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<BindObj.AddedDeviceSingleBindResponseData>(result.ReceiptData);
			return new BindObj.AddedDeviceSingleBindResponseAllData() { addedDeviceSingleBindResponseData = tempData };
			}

			/// <summary>
			/// 获取添加设备绑定的命令字符
			/// </summary>
			/// <param name="addBindData"></param>
			/// <returns></returns>
			public string GetAddDeviceListSingleBindCommandText(BindObj.AddSingleBindData addSingleBindData)
			{
			var jObject = new JObject { { "DeviceAddr", addSingleBindData.DeviceAddr }, { "Epoint", addSingleBindData.Epoint }, { "Cluster_ID", 0 }, { "Command", 5020 } };
			var data = new JObject { };
			var bindClusterList = new JArray { };
			foreach (var cluster in addSingleBindData.BindClusterList)
			{
			bindClusterList.Add(cluster);
			}
			if (addSingleBindData.BindType == 0)
			{
			data = new JObject { { "BindName", addSingleBindData.BindName }, { "BindType", addSingleBindData.BindType }, { "BindClusterList", bindClusterList }, { "BindMacAddr", addSingleBindData.BindMacAddr }, { "BindEpoint", addSingleBindData.BindEpoint } };
			}
			else if (addSingleBindData.BindType == 1)
			{
			data = new JObject { { "BindName", addSingleBindData.BindName }, { "BindType", addSingleBindData.BindType }, { "BindClusterList", bindClusterList }, { "BindScenesId", addSingleBindData.BindScenesId } };

			}
			jObject.Add("Data", data);
			return jObject.ToString();
			}


			#endregion

			#region ■ 删除设备绑定的目标_________________

			/// <summary>
			/// 删除设备绑定的目标
			/// </summary>
			/// <param name="mainDevice">设备对象</param>
			/// <param name="deleteDevice">要删除的绑定目标设备</param>
			/// <param name="BindCluster">BindCluster</param>
			/// <returns></returns>
			public bool DeleteDeviceTarget(CommonDevice mainDevice, CommonDevice deleteDevice, int BindCluster = 6)
			{
			//组装数据
			var deleteData = new IASZone.DelDeviceBindData();
			deleteData.DeviceAddr = mainDevice.DeviceAddr;
			deleteData.Epoint = mainDevice.DeviceEpoint;

			var info = new IASZone.RemoveBindListObj();
			info.BindCluster = BindCluster;
			info.BindMacAddr = deleteDevice.DeviceAddr;
			info.BindEpoint = deleteDevice.DeviceEpoint;
			info.BindType = 0;

			deleteData.RemoveBindList.Add(info);

			//执行删除
			var result = this.DelDeviceBindAsync(deleteData);
			if (result == null \|\| result.delDeviceBindResponseData == null)
			{
			//删除绑定目标失败
			string msg = Language.StringByID(R.MyInternationalizationString.uDeleteBindTargetsFail);
			//拼接上【网关回复超时】的Msg
			msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result);

			this.ShowErrorMsg(msg);
			return false;
			}

			foreach (var data in result.delDeviceBindResponseData.RemoveBindList)
			{
			//0:成功 1:设备不在绑定列表中，也可以代表成功
			if (data.Result == 0 \|\| data.Result == 1 \|\| data.Result == 5)
			{
			return true;
			}
			//3:失败，在等待节点设备确认是否解除绑定成功
			else if (data.Result == 3)
			{
			//其他绑定目标正在删除中，请稍后再试
			string msg = Language.StringByID(R.MyInternationalizationString.uOtherBindTargetsIsDelettingPleaseWait);
			this.ShowErrorMsg(msg);
			return false;
			}
			//2：未知，由节点设备反馈发送“Bind/BindResult”主题消息确定是否成功
			else if (data.Result == 2)
			{
			if (result.removeBindResultResponseData == null)
			{
			//删除绑定目标失败
			string msg = Language.StringByID(R.MyInternationalizationString.uDeleteBindTargetsFail);
			this.ShowErrorMsg(msg);
			return false;
			}
			else
			{
			//成功
			if (result.removeBindResultResponseData.Result == 0)
			{
			return true;
			}
			//136：控制设备本地绑定列表中无此绑定
			else if (result.removeBindResultResponseData.Result == 136)
			{
			//这个可以当做成功
			return true;
			}
			else
			{
			//删除绑定目标失败
			string msg = Language.StringByID(R.MyInternationalizationString.uDeleteBindTargetsFail);
			this.ShowErrorMsg(msg);
			return false;
			}
			}
			}
			}
			return false;
			}

			/// <summary>
			/// 删除设备绑定的目标
			/// </summary>
			/// <param name="mainDevice">设备对象</param>
			/// <param name="listDeleteDevice">要删除的绑定目标设备</param>
			/// <param name="BindCluster">BindCluster</param>
			/// <returns>返回的是成功删除的设备</returns>
			public List<CommonDevice> DeleteDeviceTarget(CommonDevice mainDevice, List<CommonDevice> listDeleteDevice, int BindCluster = 6)
			{
			//组装数据
			var deleteData = new IASZone.DelDeviceBindData();
			deleteData.DeviceAddr = mainDevice.DeviceAddr;
			deleteData.Epoint = mainDevice.DeviceEpoint;

			var dicDevice = new Dictionary<string, CommonDevice>();
			foreach (var device in listDeleteDevice)
			{
			var info = new IASZone.RemoveBindListObj();
			info.BindCluster = BindCluster;
			info.BindMacAddr = device.DeviceAddr;
			info.BindEpoint = device.DeviceEpoint;
			info.BindType = 0;

			deleteData.RemoveBindList.Add(info);
			//返回成功设备的时候使用
			string mainkeys = Common.LocalDevice.Current.GetDeviceMainKeys(device);
			dicDevice[mainkeys] = device;
			}
			var listSuccess = new List<CommonDevice>();

			var result = this.DelDeviceBindAsync(deleteData);
			if (result == null \|\| result.delDeviceBindResponseData == null)
			{
			//删除绑定目标失败
			string msg = Language.StringByID(R.MyInternationalizationString.uDeleteBindTargetsFail);
			//拼接上【网关回复超时】的Msg
			msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result);

			this.ShowErrorMsg(msg);
			return listSuccess;
			}

			foreach (var data in result.delDeviceBindResponseData.RemoveBindList)
			{
			string mainkeys = Common.LocalDevice.Current.GetDeviceMainKeys(data.BindMacAddr, data.BindEpoint);
			//0:成功 1:设备不在绑定列表中，也可以代表成功
			if (data.Result == 0 \|\| data.Result == 1)
			{
			listSuccess.Add(dicDevice[mainkeys]);
			}
			//3:失败，在等待节点设备确认是否解除绑定成功
			else if (data.Result == 3)
			{
			//设备名称其他绑定目标正在删除中，请稍后再试
			string msg = Common.LocalDevice.Current.GetDeviceEpointName(dicDevice[mainkeys]) + "\r\n";
			msg += Language.StringByID(R.MyInternationalizationString.uOtherBindTargetsIsDelettingPleaseWait);
			this.ShowErrorMsg(msg);
			}
			//2：未知，由节点设备反馈发送“Bind/BindResult”主题消息确定是否成功
			else if (data.Result == 2)
			{
			if (result.removeBindResultResponseData == null)
			{
			//设备名称删除绑定目标失败
			string msg = Common.LocalDevice.Current.GetDeviceEpointName(dicDevice[mainkeys]) + "\r\n";
			msg += Language.StringByID(R.MyInternationalizationString.uDeleteBindTargetsFail);
			this.ShowErrorMsg(msg);
			}
			else
			{
			//成功
			if (result.removeBindResultResponseData.Result == 0)
			{
			listSuccess.Add(dicDevice[mainkeys]);
			}
			//136：控制设备本地绑定列表中无此绑定
			else if (result.removeBindResultResponseData.Result == 136)
			{
			//这个可以当做成功
			listSuccess.Add(dicDevice[mainkeys]);
			}
			else
			{
			//设备名称删除绑定目标失败
			string msg = Common.LocalDevice.Current.GetDeviceEpointName(dicDevice[mainkeys]) + "\r\n";
			msg += Language.StringByID(R.MyInternationalizationString.uDeleteBindTargetsFail);
			this.ShowErrorMsg(msg);
			}
			}
			}
			}
			return listSuccess;
			}

			/// <summary>
			/// 删除设备的绑定目标
			/// </summary>
			/// <param name="delDeviceBindData"></param>
			/// <returns></returns>
			public BindObj.DelDeviceBindResponseAllData DelDeviceBindAsync(BindObj.DelDeviceBindData delDeviceBindData)
			{
			//如果当前住宅是虚拟住宅
			if (Common.Config.Instance.Home.IsVirtually == true)
			{
			return TemplateData.TemplateDeviceDataLogic.Current.DeleteDeviceBindList(delDeviceBindData);
			}
			var device = Common.LocalDevice.Current.GetDevice(delDeviceBindData.DeviceAddr, delDeviceBindData.Epoint);
			//获取需要发送的数据
			var sendData = this.GetDeleteDeviceBindCommandText(delDeviceBindData);
			//发送命令
			var result = this.SendDeleteBindJobjectDataToGateway(device, "Bind/RemoveBind",
			sendData, new List<string>() { "Bind/RemoveBind_Respon", "Bind/RemoveBindResult" }, 6);

			if (result.ErrorMsg != null \|\| result.ErrorMsgDiv == 0)
			{
			return null;
			}
			var responseData = new BindObj.DelDeviceBindResponseAllData();
			if (result.listReceiptData[0] != null)
			{
			var tempData1 = Newtonsoft.Json.JsonConvert.DeserializeObject<BindObj.DelDeviceBindResponseData>(result.listReceiptData[0]);
			responseData.delDeviceBindResponseData = tempData1;
			}

			if (result.listReceiptData[1] != null)
			{
			var tempData2 = Newtonsoft.Json.JsonConvert.DeserializeObject<BindObj.RemoveBindResultResponseData>(result.listReceiptData[1]);
			responseData.removeBindResultResponseData = tempData2;
			}

			//修改缓存
			TemplateData.TemplateDeviceDataLogic.Current.DeleteDeviceBindList(delDeviceBindData);

			return responseData;
			}

			/// <summary>
			///删除一个控制设备所有绑定信息
			/// </summary>
			public BindObj.ClearBindInfoResponseAllData ClearBindInfoAsync(CommonDevice device)
			{
			//如果当前住宅是虚拟住宅
			if (Common.Config.Instance.Home.IsVirtually == true)
			{
			return TemplateData.TemplateDeviceDataLogic.Current.ClearDeviceAllBind(device);
			}

			var jObject = new JObject { { "DeviceAddr", device.DeviceAddr }, { "Epoint", device.DeviceEpoint }, { "Cluster_ID", 0 }, { "Command", 5006 } };
			var sendData = jObject.ToString();
			var result = HdlDeviceCommonLogic.Current.SendJobjectDataToGateway(device, "Bind/ClearBindInfo", sendData, "Bind/ClearBindInfo_Respon", 25);
			if (result.ErrorMsg != null \|\| result.ErrorMsgDiv == 0)
			{
			return null;
			}

			//修改缓存
			TemplateData.TemplateDeviceDataLogic.Current.ClearDeviceAllBind(device);

			var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<BindObj.ClearBindInfoResponseData>(result.ReceiptData);
			return new BindObj.ClearBindInfoResponseAllData { clearBindInfoResponseData = tempData };
			}


			/// <summary>
			/// 获取删除设备绑定列表的命令字符
			/// </summary>
			/// <param name="delDeviceBindData"></param>
			/// <returns></returns>
			public string GetDeleteDeviceBindCommandText(BindObj.DelDeviceBindData delDeviceBindData)
			{
			var jObject = new JObject { { "DeviceAddr", delDeviceBindData.DeviceAddr }, { "Epoint", delDeviceBindData.Epoint }, { "Cluster_ID", 0 }, { "Command", 5003 } };
			var removeBindList = new JArray { };
			foreach (var removeBindInfo in delDeviceBindData.RemoveBindList)
			{
			//删除设备
			if (removeBindInfo.BindType == 0)
			{
			var dInfo = new JObject{{ "BindMacAddr",removeBindInfo.BindMacAddr},{ "BindEpoint", removeBindInfo.BindEpoint} ,
			{ "BindCluster", removeBindInfo.BindCluster} ,{ "BindType",removeBindInfo.BindType}};
			removeBindList.Add(dInfo);
			}
			//删除场景
			else if (removeBindInfo.BindType == 1)
			{
			var dInfo = new JObject{{ "BindCluster", removeBindInfo.BindCluster} ,{ "BindType",removeBindInfo.BindType},
			{ "BindScenesId", removeBindInfo.BindScenesId}};
			removeBindList.Add(dInfo);
			}
			}
			var data = new JObject { { "RemoveBindList", removeBindList } };
			jObject.Add("Data", data);

			return jObject.ToString();
			}

			/// <summary>
			/// 发送删除绑定的数据到网关，并接受网关返回的数据,listReceiptData为返回值(删除绑定的接口很特殊,需要独立出来)
			/// </summary>
			/// <param name="device">设备对象</param>
			/// <param name="sendTopic">发送的主题</param>
			/// <param name="sendData">需要发送的数据 JObject.ToString()的东西</param>
			/// <param name="listReceiptTopic">指定接收哪些主题</param>
			/// <param name="waitTime">超时时间(秒)</param>
			/// <returns>网关返回的数据</returns>
			private ReceiptGatewayResult SendDeleteBindJobjectDataToGateway(CommonDevice device, string sendTopic, string sendData, List<string> listReceiptTopic, int waitTime = 3)
			{
			var reResult = new ReceiptGatewayResult();
			reResult.listReceiptData = new string[listReceiptTopic.Count];
			var myGateway = device.Gateway;
			if (myGateway == null)
			{
			//获取网关对象失败
			reResult.ErrorMsg = Language.StringByID(R.MyInternationalizationString.uGetGatewayTagartFail);
			reResult.ErrorMsgDiv = -1;
			return reResult;
			}
			//网关ID
			string gatewayID = device.Gateway.GwId;
			//错误主题
			string errorTopic = gatewayID + "/" + "Error_Respon";
			//检测对象的主题
			for (int i = 0; i < listReceiptTopic.Count; i++)
			{
			listReceiptTopic[i] = gatewayID + "/" + listReceiptTopic[i];
			}

			bool canbreak = false;
			BindObj.DelDeviceBindResponseData delDeviceBindData = null;
			BindObj.RemoveBindResultResponseData removeBindResult = null;

			Action<string, string> receiptAction = (topic, message) =>
			{
			var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);

			//网关回复错误
			if (topic == errorTopic)
			{
			var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
			reResult.ErrorMsg = HdlCheckLogic.Current.CheckCommonErrorCode(temp.Error);
			}
			//如果是指定的主题
			for (int i = 0; i < listReceiptTopic.Count; i++)
			{
			if (topic == listReceiptTopic[i])
			{
			string deviceMac = jobject["DeviceAddr"].ToString();
			int deviceEpoint = Convert.ToInt32(jobject["Epoint"].ToString());
			if (device.DeviceAddr != deviceMac)
			{
			//不是同一个东西Mac
			return;
			}
			if (device.DeviceEpoint != deviceEpoint && deviceEpoint != 200)
			{
			//不是同一个东西,这里应该需要特殊处理200端点
			return;
			}
			reResult.listReceiptData[i] = jobject["Data"].ToString();

			if (i == 0)
			{
			//"Bind/RemoveBind_Respon"主题
			delDeviceBindData = Newtonsoft.Json.JsonConvert.DeserializeObject<BindObj.DelDeviceBindResponseData>(reResult.listReceiptData[i]);
			}
			else if (i == 1)
			{
			//"Bind/RemoveBindResult"主题
			removeBindResult = Newtonsoft.Json.JsonConvert.DeserializeObject<BindObj.RemoveBindResultResponseData>(reResult.listReceiptData[i]);
			}

			if (0 < delDeviceBindData.RemoveBindList.FindAll((obj) => obj.BindType == 0 && obj.Result == 1).Count)
			{
			canbreak = true;
			}
			else if (0 < delDeviceBindData.RemoveBindList.FindAll((obj) => obj.BindType == 0 && obj.Result == 3).Count)
			{
			if (removeBindResult != null)
			{
			canbreak = true;
			}
			}
			else if (0 < delDeviceBindData.RemoveBindList.FindAll((obj) => obj.BindType == 0 && obj.Result == 2).Count)
			{
			if (removeBindResult != null)
			{
			canbreak = true;
			}
			}
			else
			{
			canbreak = true;
			}
			}
			}

			};
			myGateway.Actions += receiptAction;
			//发送数据
			myGateway.Send(sendTopic, sendData);

			//超时时间
			int TimeOut = 0;
			waitTime = 20 * waitTime;
			while (canbreak == false && TimeOut < waitTime)
			{
			//全部接收才退出
			System.Threading.Thread.Sleep(50);
			TimeOut++;
			}
			myGateway.Actions -= receiptAction;
			receiptAction = null;
			if (canbreak == false)
			{
			//超时
			reResult.ErrorMsgDiv = 0;
			}
			else
			{
			//正常接收到网关返回的数据
			if (reResult.listReceiptData.Length == 1)
			{
			//如果只有一个主题,则替换变量
			reResult.ReceiptData = reResult.listReceiptData[0];
			reResult.listReceiptData = null;
			}
			}

			return reResult;
			}


			#endregion

			#region ■ 配置面板功能_______________________

			///<summary >
			///配置面板功能
			///<para>value:给面板配置的模式</para>
			/// </summary>
			public CommonDevice.SetWritableValueResponAllData ConfigureHdlKeyValueAsync(CommonDevice device, Panel.KeyMode value, int clusterID = 6)
			{
			//如果当前住宅是虚拟住宅
			if (Common.Config.Instance.Home.IsVirtually == true)
			{
			return TemplateData.TemplateDeviceDataLogic.Current.ConfigurePanelKeyModel(device, value, clusterID, null);
			}
			//获取发送数据
			var sendData = this.GetConfigureHdlKeyCommandText(device.DeviceAddr, device.DeviceEpoint, value, clusterID);
			var result = HdlDeviceCommonLogic.Current.SendJobjectDataToGateway(device, "SetWritableValue", sendData, "SetWritableValue_Respon");
			if (result.ErrorMsg != null \|\| result.ErrorMsgDiv == 0)
			{
			return null;
			}

			//修改缓存
			TemplateData.TemplateDeviceDataLogic.Current.ConfigurePanelKeyModel(device, value, clusterID, result.JsonData[0]);

			var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.SetWritableValueResponData>(result.ReceiptData);
			return new CommonDevice.SetWritableValueResponAllData { setWritableValueResponData = tempData };
			}

			/// <summary>
			/// 读取面板的配置信息
			/// </summary>
			public Panel.PanelConfigureInfoResponAllData ReadPanelConfigureInfoAsync(CommonDevice device)
			{
			//如果当前住宅是虚拟住宅
			if (Common.Config.Instance.Home.IsVirtually == true \|\| Common.Config.Instance.Home.IsShowTemplate == true)
			{
			return TemplateData.TemplateDeviceDataLogic.Current.ReadPanelConfigureKeyModel(device);
			}

			var JObject = new JObject {{ "DeviceAddr",device.DeviceAddr },{ "Epoint", device.DeviceEpoint },
			{ "Cluster_ID", (int)Cluster_ID.HdlKey },{ "Command", 108 }};
			var attriBute = new JArray { new JObject { { "AttriButeId", (int)AttriButeId.HdlKey } } };
			var data = new JObject { { "AttriBute", attriBute } };
			JObject.Add("Data", data);

			//发送数据
			var sendData = JObject.ToString();
			string receiptTopic = "DeviceStatusReport/" + device.DeviceAddr + "/" + device.DeviceEpoint + "/" + (int)Cluster_ID.HdlKey + "/" + (int)AttriButeId.HdlKey;
			var result = HdlDeviceCommonLogic.Current.SendJobjectDataToGateway(device, "GetDeviceStatus", sendData, receiptTopic);
			if (result.ErrorMsg != null \|\| result.ErrorMsgDiv == 0)
			{
			return null;
			}

			var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<Panel.DeviceStatusReportData>(result.ReceiptData);
			return new Panel.PanelConfigureInfoResponAllData { deviceStatusReportData = tempData };
			}

			/// <summary>
			/// 获取配置面板功能的命令字符
			/// </summary>
			/// <param name="device">设备对象</param>
			/// <param name="value">键值</param>
			/// <param name="clusterID">镞ID</param>
			/// <returns></returns>
			public string GetConfigureHdlKeyCommandText(string DeviceAddr, int DeviceEpoint, Panel.KeyMode value, int clusterID = 6)
			{
			var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", DeviceEpoint }, { "Cluster_ID", clusterID }, { "Command", 120 } };
			var data = new JObject { { "Undivided", 0 }, { "AttributeId", 6533 }, { "AttributeDataType", 33 }, { "AttributeData", (int)value } };
			jObject.Add("Data", data);
			return jObject.ToString();
			}

			#endregion

			#region ■ 一般方法___________________________

			/// <summary>
			/// 显示错误信息窗口
			/// </summary>
			/// <param name="msg"></param>
			private void ShowErrorMsg(string msg)
			{
			Application.RunOnMainThread(() =>
			{
			var contr = new ShowMsgControl(ShowMsgType.Error, msg);
			contr.Show();
			});
			}

			/// <summary>
			/// 显示Tip信息窗口
			/// </summary>
			/// <param name="msg"></param>
			private void ShowTipMsg(string msg)
			{
			Application.RunOnMainThread(() =>
			{
			var contr = new UserCenter.ShowMsgControl(ShowMsgType.Tip, msg);
			contr.Show();
			});
			}

			#endregion
			}
			}