请合并代码：新增多功能面板一对一绑定机制

xm

2020-08-12 617a02739b82ae30772de25b4f9a8f6e9460f468

请合并代码：新增多功能面板一对一绑定机制

 ZigbeeApp20200810/Shared/Phone/UserCenter/CommonBase/Logic/HdlDeviceBindLogic.cs~HEAD

New file
@@ -0,0 +1,798 @@
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),这个是给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 = ModelData.DeviceModelDataLogic.Current.GetDeviceBindList(device, "Bind/GetDeviceBind");

                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 ModelData.DeviceModelDataLogic.Current.AddDeviceBindList(addBindData, "Bind/GetDeviceBind");

            }



            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;

            }



            //修改缓存

<<<<<<< HEAD:ZigbeeApp20200810/Shared/Phone/UserCenter/CommonBase/Logic/HdlDeviceBindLogic.cs

            ModelData.DeviceModelDataLogic.Current.AddDeviceBindList(addBindData, "Bind/GetDeviceBind");



            var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<BindObj.AddedDeviceBindResponseData>(result.ReceiptData);

            return new BindObj.AddedDeviceBindResponseAllData() { addedDeviceBindResponseData = tempData };

        }

=======

            TemplateData.TemplateDeviceDataLogic.Current.AddDeviceBindList(addBindData, result.JsonData[0]);

            var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<BindObj.AddedDeviceBindResponseData>(result.ReceiptData);

            return new BindObj.AddedDeviceBindResponseAllData() { addedDeviceBindResponseData = tempData };

        }



>>>>>>> dev-tzy:ZigbeeApp/Shared/Phone/UserCenter/CommonBase/Logic/HdlDeviceBindLogic.cs

        /// <summary>

        ///设备绑定【一对一 绑定，一个按键回路只能绑定一个设备】

        /// </summary>

        public BindObj.AddedDeviceBindResponseAllData AddDeviceSingleBindAsync(BindObj.AddBindData addBindData)

        {

            //如果当前住宅是虚拟住宅

            if (Common.Config.Instance.Home.IsVirtually == true)

            {

                return ModelData.DeviceModelDataLogic.Current.AddDeviceBindList(addBindData, "Bind/GetDeviceBind");

            }



            var device = Common.LocalDevice.Current.GetDevice(addBindData.DeviceAddr, addBindData.Epoint);

            //获取发送的命令字符

            var sendData = this.GetAddDeviceListBindCommandText(addBindData);

            //发送 
            var result = HdlDeviceCommonLogic.Current.SendJobjectDataToGateway(device, "Bind/SetSingleBind", sendData, "Bind/SetSingleBind_Respon", 20);

            if (result.ErrorMsg != null || result.ErrorMsgDiv == 0)

            {

                return null;

            }

<<<<<<< HEAD:ZigbeeApp20200810/Shared/Phone/UserCenter/CommonBase/Logic/HdlDeviceBindLogic.cs



            //修改缓存

            ModelData.DeviceModelDataLogic.Current.AddDeviceBindList(addBindData, "Bind/GetDeviceBind");

=======

            //修改缓存

            TemplateData.TemplateDeviceDataLogic.Current.AddDeviceBindList(addBindData, result.JsonData[0]);

>>>>>>> dev-tzy:ZigbeeApp/Shared/Phone/UserCenter/CommonBase/Logic/HdlDeviceBindLogic.cs



            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();

        }



        #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 ModelData.DeviceModelDataLogic.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;

            }



            //修改缓存

            ModelData.DeviceModelDataLogic.Current.DeleteDeviceBindList(delDeviceBindData);



            return responseData;

        }



        /// <summary>

        ///删除一个控制设备所有绑定信息

        /// </summary>

        public BindObj.ClearBindInfoResponseAllData ClearBindInfoAsync(CommonDevice device)

        {

            //如果当前住宅是虚拟住宅

            if (Common.Config.Instance.Home.IsVirtually == true)

            {

                return ModelData.DeviceModelDataLogic.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;

            }



            //修改缓存

            ModelData.DeviceModelDataLogic.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 ModelData.DeviceModelDataLogic.Current.ConfigurePanelKeyModel(device, value, clusterID, "SetWritableValue");

            }

            //获取发送数据

            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;

            }



            //修改缓存

            ModelData.DeviceModelDataLogic.Current.ConfigurePanelKeyModel(device, value, clusterID, "SetWritableValue");



            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)

            {

                return ModelData.DeviceModelDataLogic.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

    }

}


 ZigbeeApp20200810/Shared/Phone/UserCenter/Device/DeviceMacInfoEditorForm.cs~HEAD

New file
@@ -0,0 +1,1731 @@
using System;

using System.Collections.Generic;

using System.Threading.Tasks;

using Shared.Common;

using Shared.Phone.UserCenter.Device.Bind;

using Shared.Phone.UserCenter.DeviceBind;

using ZigBee.Device;



namespace Shared.Phone.UserCenter.Device

{

    /// <summary>

    /// 编辑设备的信息(这里修改的是MAC名,这个画面会更改MAC的物理名字)

    /// </summary>

    public class DeviceMacInfoEditorForm : EditorCommonForm

    {

        #region ■ 变量声明___________________________



        /// <summary>

        /// 设备对象

        /// </summary>

        private List<CommonDevice> listNewDevice = null;

        /// <summary>

        /// 列表控件

        /// </summary>

        private FrameListControl listview = null;

        /// <summary>

        /// 设备的设备类型

        /// </summary>

        private HashSet<DeviceType> listDeviceType = new HashSet<DeviceType>();

        /// <summary>

        /// 设备具体类型的信息

        /// </summary>

        private DeviceEnumInfo deviceEnumInfo = null;

        /// <summary>

        /// 中央空调的版本控件

        /// </summary>

        private NormalViewControl btnAirConditionerVersion = null;

        /// <summary>

        /// 简约面板绑定的温度目标名字

        /// </summary>

        private string bindTemperatureName = string.Empty;

        /// <summary>

        /// 简约面板绑定的湿度目标名字

        /// </summary>

        private string bindHumidityName = string.Empty;

        /// <summary>

        /// 简约面板绑定被绑目标是温度

        /// </summary>

        private CommonDevice bindTemperatureDev;

        /// <summary>

        /// 简约面板绑定被绑目标是湿度

        /// </summary>

        private CommonDevice bindHumidityDev;

        /// <summary>

        ///  简约面板当前Mac

        /// </summary>

        private string deviceMacTemp = string.Empty;

        // <summary>

        /// 简约面板中被绑定的温湿度目标列表

        /// </summary>

        private List<BindObj.BindListResponseObj> bindList = new List<BindObj.BindListResponseObj>();

        #endregion



        #region ■ 初始化_____________________________



        /// <summary>

        /// 画面显示(底层会固定调用此方法，借以完成画面创建)

        /// </summary>

        /// <param name="deviceMac">设备mac地址</param>

        public void ShowForm(string deviceMac)

        {

            this.listNewDevice = Common.LocalDevice.Current.GetDevicesByMac(deviceMac);

            if (listNewDevice.Count == 0)

            {

                //针对单纯只有一个200端点的设备

                listNewDevice.Add(Common.LocalDevice.Current.GetOTADevice(deviceMac));

            }

            this.listDeviceType.Clear();

            deviceMacTemp = deviceMac;

            foreach (var device in listNewDevice)

            {

                //收集设备类型

                this.listDeviceType.Add(device.Type);

            }

            //获取这一堆设备时属于什么类型的

            this.deviceEnumInfo = Common.LocalDevice.Current.GetMyDeviceEnumInfo(listNewDevice);



            //设置标题信息

            base.SetTitleText(Language.StringByID(R.MyInternationalizationString.uDeviceSettion));



            //初始化右上角菜单

            this.InitTopRightMenu();



            //初始化中部控件

            this.InitMiddleFrame();



            //重新获取硬件信息

            this.RefreshHardFirmwareInfo();



            //简约多功能面板获取绑定目标的显示

            if (deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_SimpleMultifunction)

            {

                //简约面板随便一个回路来获取设备信息

                var dev = Common.LocalDevice.Current.GetDevice(deviceMac, 62);

                if (dev != null)

                {

                    var key = new ZigBee.Device.Panel();

                    key.DeviceAddr = deviceMac;

                    key.CurrentGateWayId = dev.CurrentGateWayId;

                    InitBindInfo(key);

                }

            }

        }



        /// <summary>

        /// 初始化中部控件

        /// </summary>

        private void InitMiddleFrame()

        {

            //清空bodyFrame

            this.ClearBodyFrame();



            var listBackControl = new VerticalFrameControl();

            listBackControl.Height = bodyFrameLayout.Height;

            bodyFrameLayout.AddChidren(listBackControl);



            //初始化桌布

            var tableContr = new InformationEditorControl();

            this.listview = tableContr.InitControl(listBackControl.frameTable, Language.StringByID(R.MyInternationalizationString.uInfoEditor), 1368);



            //图片

            var btnPic = new DeviceInfoIconControl();

            btnPic.Y = Application.GetRealHeight(92);

            btnPic.Gravity = Gravity.CenterHorizontal;

            listBackControl.frameTable.AddChidren(btnPic);

            btnPic.InitControl(listNewDevice[0]);



            //设备备注

            string caption = Language.StringByID(R.MyInternationalizationString.uDeviceNote);

            string deviceName = Common.LocalDevice.Current.GetDeviceMacName(listNewDevice[0]);

            var btnNote = new FrameCaptionInputControl(caption, deviceName, listview.rowSpace / 2);

            listview.AddChidren(btnNote);

            btnNote.InitControl();

            //划线

            btnNote.AddBottomLine();

            btnNote.txtInput.FinishInputEvent += () =>

            {

                string oldName = Common.LocalDevice.Current.GetDeviceMacName(listNewDevice[0]);

                if (btnNote.Text == string.Empty)

                {

                    btnNote.Text = oldName;

                }

                if (oldName != btnNote.Text)

                {

                    //修改名字

                    this.DeviceReName(btnNote.Text, false);

                }

            };



            //设备类型

            caption = Language.StringByID(R.MyInternationalizationString.uDeviceType);

            deviceName = Common.LocalDevice.Current.GetDeviceObjectText(listNewDevice);

            var btnType = new FrameCaptionViewControl(caption, deviceName, listview.rowSpace / 2);

            btnType.UseClickStatu = false;

            listview.AddChidren(btnType);

            btnType.InitControl();

            //划线

            btnType.AddBottomLine();



            //安装位置

            var rowBeloneArea = new BelongAreaControl(listview.rowSpace / 2);

            listview.AddChidren(rowBeloneArea);

            rowBeloneArea.InitControl(Language.StringByID(R.MyInternationalizationString.uInstallationLocation), this.listNewDevice);

            //底线

            rowBeloneArea.AddBottomLine();



            var listCheck = new List<string>();

            rowBeloneArea.SelectRoomEvent += (roomKeys) =>

            {

                //选择未分配时,清空

                if (roomKeys == string.Empty) { listCheck = new List<string>(); }

                foreach (var device in this.listNewDevice)

                {

                    if (device is OTADevice)

                    {

                        //针对单纯只有一个200端点的设备

                        continue;

                    }

                    if (roomKeys == string.Empty)

                    {

                        //如果选择的是未分配，则它的全部回路无条件全部清空房间

                        HdlRoomLogic.Current.ChangedRoom(device, roomKeys);

                        continue;

                    }

                    var room = HdlRoomLogic.Current.GetRoomByDevice(device);

                    string mainKeys = LocalDevice.Current.GetDeviceMainKeys(device);

                    if (room == null)

                    {

                        //这里有点特殊,如果回路没有设置有区域的时候,才设置

                        listCheck.Add(mainKeys);

                        HdlRoomLogic.Current.ChangedRoom(device, roomKeys);

                    }

                    else if (this.deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueFreshAir

                      && device.Type == DeviceType.FreshAir)

                    {

                        //新风面板的新风设备，则区域跟着模块一起

                        HdlRoomLogic.Current.ChangedRoom(device, roomKeys);

                    }

                    else if (listCheck.Contains(mainKeys) == true)

                    {

                        //如果这个回路之前都还没有区域,在本界面还没有关闭之前,可以无条件随便变更

                        HdlRoomLogic.Current.ChangedRoom(device, roomKeys);

                    }

                }

                //保存设备房间索引

                Common.LocalDevice.Current.SaveRealDeviceRoomId(this.listNewDevice, roomKeys);

            };



            //添加全部菜单

            this.AddAllMenuRow();



            //初始化桌布完成

            tableContr.FinishInitControl();

            tableContr = null;



            //保存

            var btnFinish = new BottomClickButton();

            btnFinish.TextID = R.MyInternationalizationString.uSave;

            bodyFrameLayout.AddChidren(btnFinish);

            btnFinish.ButtonClickEvent += (sender, e) =>

            {

                string oldName = Common.LocalDevice.Current.GetDeviceMacName(listNewDevice[0]);

                if (btnNote.Text.Trim() == string.Empty)

                {

                    btnNote.Text = oldName;

                }

                if (oldName != btnNote.Text.Trim())

                {

                    //修改名字

                    this.DeviceReName(btnNote.Text.Trim(), true);

                }

                else

                {

                    //关闭自身

                    this.CloseForm();

                }

            };

            //如果当前住宅是虚拟住宅的话,让所有菜单都不能点击

            if (Common.Config.Instance.Home.IsVirtually == true)

            {

                for (int i = 0; i < listview.ChildrenCount; i++)

                {

                    var myRow = listview.GetChildren(i) as FrameRowControl;

                    if (myRow != null)

                    {

                        myRow.UseClickStatu = false;

                        myRow.CanClick = false;

                    }

                }

            }

        }



        #endregion



        #region ■ 添加菜单___________________________



        /// <summary>

        /// 添加全部菜单

        /// </summary>

        private void AddAllMenuRow()

        {

            if (deviceEnumInfo.BeloneType == DeviceBeloneType.A智能门锁)

            {

                //只有是河东的设备的时候

                if (deviceEnumInfo.IsHdlDevice == true)

                {

                    //添加【用户管理】行

                    this.AddUserManageRow();

                    //添加【远程开锁】行

                    this.AddRemoteUnLocksRow();

                    //添加【门锁时间】行

                    this.AddDoorLocksTimeRow();

                }

            }

            else if (deviceEnumInfo.ConcreteType == DeviceConcreteType.AirConditioner_ZbGateway)

            {

                //添加【室内机设置】行(空调专用)

                this.AddIndoorUnitSettionRow();

            }

            else if (deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_SimpleMultifunction)

            {

                //简约多功能面板

                this.AddIBindRow(deviceMacTemp);

                this.AddFunctionSettionRow();

                this.AddHumiditySourceRow(deviceMacTemp);

                this.AddTemperatureSensorRow(deviceMacTemp);

            }

            else if (deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_SimpleEnvironment)

            {

                //添加【绑定目标】行(简约环境面板用) 
                this.AddSimplePanelSettionRow();

            }

            else

            {

                //添加【工作模式】行(pir传感器专用)

                this.AddPirSensorWorkModeRow();

                //添加【绑定目标】行(pir传感器专用)

                this.AddPirSensorBindRow();

                //添加【方向与限位】行(开合帘,卷帘专用)

                this.AddDirectionAndLimitRow();

                //添加【手拉控制】行(开合帘专用)

                this.AddHandPullControlRow();

                //添加【按键设置】行(方悦专用) --这个有可能和面板重叠

                if (this.AddFangyuePanelSettionRow() == false)

                {

                    //添加【按键设置】行(面板专用)

                    this.AddPanelSettionRow();

                }

                //检测能否显示功能设置的菜单

                if (this.CheckCanShowFunctionSettionRow() == true)

                {

                    //添加【功能设置】行

                    if (deviceEnumInfo.ConcreteType == DeviceConcreteType.Sensor_PMTwoPointFive)

                    {

                        //PM传感器

                        this.AddFunctionSettionRowPM();

                    }

                    else

                    {

                        this.AddFunctionSettionRow();

                    }



                }



                //添加【干接点设置】行

                this.AddDryContactSettionRow();

            }

            //添加【功能类型】行(空气开关专用)

            this.AddAirSwitchFunctionTypeRow();

            //添加【通用信息】行

            this.AddGeneralInformationRow();



            //添加【空调模块版本(空调专用)】行

            this.AddAirConditionerModelVersionRow();



            if (deviceEnumInfo.IsHdlDevice == true)

            {

                //添加【固件升级】行

                this.AddFirmwareUpdateRow();

            }

        }



        #endregion



        #region ■ 用户管理(门锁)_____________________



        /// <summary>

        /// 添加【用户管理】行（门锁专用）

        /// </summary>

        private void AddUserManageRow()

        {

            //如果是智能门锁

            if (deviceEnumInfo.BeloneType == DeviceBeloneType.A智能门锁)

            {

                //用户管理

                string caption = Language.StringByID(R.MyInternationalizationString.uUserManage);

                var btnRow = new FrameRowControl(listview.rowSpace / 2);

                listview.AddChidren(btnRow);

                btnRow.AddLeftCaption(caption, 600);

                //向右图标

                btnRow.AddRightArrow();

                //底线

                btnRow.AddBottomLine();

                var doorLock = this.listNewDevice[0] as ZigBee.Device.DoorLock;

                btnRow.ButtonClickEvent += async (sender, e) =>

                 {

                     if (UserCenterResourse.UserInfo.AuthorityNo == 1)

                     {

                         Action action = null;

                         Action actionNone = null;

                         action = () =>

                         {

                             var userManagement = new Shared.Phone.UserCenter.DoorLock.UserManagement(doorLock);

                             Shared.Phone.UserView.HomePage.Instance.AddChidren(userManagement);

                             Shared.Phone.UserView.HomePage.Instance.PageIndex += 1;

                             userManagement.Show();

                         };

                         actionNone = () =>

                         {

                             Shared.Phone.UserCenter.DoorLock.DoorLockCommonLayout.SecurityRequest(doorLock);

                         };

                         HdlCheckLogic.Current.CheckSecondarySecurity(action, actionNone);

                     }

                     else

                     {

                         CommonPage.Loading.Start("");

                         var result = await Shared.Phone.UserCenter.DoorLock.DoorLockCommonInfo.GetDoorLockOperateAccess(doorLock, Shared.Common.Config.Instance.Guid);

                         if (result == false)

                         {

                             Action action = null;

                             Action actionNone = null;

                             action = () =>

                             {

                                 var userManagement = new Shared.Phone.UserCenter.DoorLock.UserManagement(doorLock);

                                 Shared.Phone.UserView.HomePage.Instance.AddChidren(userManagement);

                                 Shared.Phone.UserView.HomePage.Instance.PageIndex += 1;

                                 userManagement.Show();

                             };

                             actionNone = () =>

                             {

                                 Shared.Phone.UserCenter.DoorLock.DoorLockCommonLayout.SecurityRequest(doorLock);

                             };

                             HdlCheckLogic.Current.CheckSecondarySecurity(action, actionNone);



                         }

                         else

                         {

                             this.ShowMassage(ShowMsgType.Tip, Language.StringByID(R.MyInternationalizationString.AccountIsFreezed));

                         }

                         CommonPage.Loading.Hide();

                     }

                 };

            }

        }



        #endregion



        #region ■ 远程开锁(门锁)_____________________



        /// <summary>

        /// 添加【远程开锁】行（门锁专用）

        /// </summary>

        private void AddRemoteUnLocksRow()

        {

            //如果是智能门锁

            if (deviceEnumInfo.BeloneType == DeviceBeloneType.A智能门锁)

            {

                //远程开锁

                string caption = Language.StringByID(R.MyInternationalizationString.uRemoteUnLocks);

                var btnRow = new FrameRowControl(listview.rowSpace / 2);

                btnRow.UseClickStatu = false;

                listview.AddChidren(btnRow);

                btnRow.AddLeftCaption(caption, 600);

                //开关图标

                var btnswitch = btnRow.AddMostRightSwitchIcon();

                //底线

                btnRow.AddBottomLine();



                var doorLock = (ZigBee.Device.DoorLock)listNewDevice[0];

                if (string.IsNullOrEmpty(doorLock.RemoteUnlockPassword) == false)

                {

                    btnswitch.IsSelected = true;

                }

                //如果当前住宅是虚拟住宅的话,让所有菜单都不能点击

                if (Common.Config.Instance.Home.IsVirtually == true)

                {

                    btnswitch.CanClick = false;

                }



                btnswitch.ButtonClickEvent += async (sender, e) =>

                 {

                     if (UserCenterResourse.UserInfo.AuthorityNo == 1)

                     {

                         if (btnswitch.IsSelected == true)

                         {

                             btnswitch.IsSelected = false;

                             doorLock.RemoteUnlockPassword = string.Empty;

                             return;

                         }

                         var frame = new DoorLock.DoorLockCommonLayout();

                         frame.RemotePasswordDialog((ZigBee.Device.DoorLock)listNewDevice[0], btnswitch.btnIcon);

                         frame = null;

                     }

                     else

                     {

                         var result = await Shared.Phone.UserCenter.DoorLock.DoorLockCommonInfo.GetDoorLockOperateAccess(doorLock, Shared.Common.Config.Instance.Guid);

                         if (result == false)

                         {

                             var result1 = await Shared.Phone.UserCenter.DoorLock.DoorLockCommonInfo.GetDoorLockUnlockAccess(doorLock, Shared.Common.Config.Instance.Guid);

                             if (result1 == true)

                             {

                                 if (btnswitch.IsSelected == true)

                                 {

                                     btnswitch.IsSelected = false;

                                     doorLock.RemoteUnlockPassword = string.Empty;

                                     return;

                                 }

                                 var frame = new DoorLock.DoorLockCommonLayout();

                                 frame.RemotePasswordDialog((ZigBee.Device.DoorLock)listNewDevice[0], btnswitch.btnIcon);

                                 frame = null;

                             }

                             else

                             {

                                 this.ShowMassage(ShowMsgType.Tip, Language.StringByID(R.MyInternationalizationString.NoAccess));

                             }

                         }

                         else

                         {

                             this.ShowMassage(ShowMsgType.Tip, Language.StringByID(R.MyInternationalizationString.AccountIsFreezed));

                         }

                     }

                 };

            }

        }



        #endregion



        #region ■ 门锁时间(门锁)_____________________



        /// <summary>

        /// 添加【门锁时间】行（门锁专用）

        /// </summary>

        private void AddDoorLocksTimeRow()

        {

            //如果是智能门锁

            if (deviceEnumInfo.BeloneType == DeviceBeloneType.A智能门锁)

            {

                //门锁时间

                string caption = Language.StringByID(R.MyInternationalizationString.uDoorLocksTime);

                var btnRow = new FrameRowControl(listview.rowSpace / 2);

                listview.AddChidren(btnRow);

                btnRow.AddLeftCaption(caption, 600);

                //向右图标

                btnRow.AddRightArrow();

                //底线

                btnRow.AddBottomLine();

                var doorLock = this.listNewDevice[0] as ZigBee.Device.DoorLock;

                btnRow.ButtonClickEvent += async (sender, e) =>

                 {

                     if (UserCenterResourse.UserInfo.AuthorityNo == 1)

                     {

                         var tempPage = new Shared.Phone.UserCenter.DoorLock.TimeSettignPage(doorLock, "DoorLockTime");

                         Shared.Phone.UserView.HomePage.Instance.AddChidren(tempPage);

                         Shared.Phone.UserView.HomePage.Instance.PageIndex += 1;

                         tempPage.Show();

                     }

                     else

                     {

                         var result = await Shared.Phone.UserCenter.DoorLock.DoorLockCommonInfo.GetDoorLockOperateAccess(doorLock, Shared.Common.Config.Instance.Guid);

                         if (result == false)

                         {

                             var tempPage = new Shared.Phone.UserCenter.DoorLock.TimeSettignPage(doorLock, "DoorLockTime");

                             Shared.Phone.UserView.HomePage.Instance.AddChidren(tempPage);

                             Shared.Phone.UserView.HomePage.Instance.PageIndex += 1;

                             tempPage.Show();

                         }

                         else

                         {

                             this.ShowMassage(ShowMsgType.Tip, Language.StringByID(R.MyInternationalizationString.AccountIsFreezed));

                         }

                     }

                 };

            }

        }



        #endregion



        #region ■ 按键设置(面板)_____________________



        /// <summary>

        /// 添加【按键设置】行(面板)

        /// </summary>

        private void AddPanelSettionRow()

        {

            //必须是河东设备,必须是面板，并且有干接点才行

            if (deviceEnumInfo.IsHdlDevice == false || deviceEnumInfo.BeloneType != DeviceBeloneType.A按键面板 || listDeviceType.Contains(DeviceType.OnOffSwitch) == false)

            {

                return;

            }

            //按键设置

            string caption = Language.StringByID(R.MyInternationalizationString.uPanelSettion);

            var btnFunction = new FrameRowControl(listview.rowSpace / 2);

            listview.AddChidren(btnFunction);

            btnFunction.AddLeftCaption(caption, 600);

            //向右图标

            btnFunction.AddRightArrow();

            //底线

            btnFunction.AddBottomLine();

            btnFunction.ButtonClickEvent += (sender, e) =>

            {

                var form = new DevicePanel.PanelButtonSettionForm();

                form.AddForm(listNewDevice[0]);

            };

        }



        #region ■ 简约环境(面板)_____________________



        /// <summary>

        /// 添加【按键设置】行简约环境(面板)

        /// </summary>

        private void AddSimplePanelSettionRow()

        {

            //按键设置

            string caption = Language.StringByID(R.MyInternationalizationString.uPanelSettion);

            var btnFunction = new FrameRowControl(listview.rowSpace / 2);

            listview.AddChidren(btnFunction);

            btnFunction.AddLeftCaption(caption, 600);

            //向右图标

            btnFunction.AddRightArrow();

            //底线

            btnFunction.AddBottomLine();

            btnFunction.ButtonClickEvent += (sender, e) =>

            {

                //简约环境面板的按键配置

                var form = new DevicePanel.PanelSettionWithSourceForm();

                form.AddForm(listNewDevice[0]);

            };

        }



        #endregion



        #endregion



        #region ■ 按键设置(方悦)_____________________



        /// <summary>

        /// 添加【按键设置】行(方悦)

        /// </summary>

        private bool AddFangyuePanelSettionRow()

        {

            if (deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueTwo

                || deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueFour

                || deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueEight

                || deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueEnvironment

                || deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueFreshAir)

            {

                //按键设置

                string caption = Language.StringByID(R.MyInternationalizationString.uPanelSettion);

                var btnFunction = new FrameRowControl(listview.rowSpace / 2);

                listview.AddChidren(btnFunction);

                btnFunction.AddLeftCaption(caption, 600);

                //向右图标

                btnFunction.AddRightArrow();

                //底线

                btnFunction.AddBottomLine();

                btnFunction.ButtonClickEvent += (sender, e) =>

                {

                    if (deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueTwo

                    || deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueFour

                    || deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueEight)

                    {

                        //方悦按键面板[单开双控/双开四控/四开八控]配置

                        var form = new DevicePanel.PanelFangyueButtonSettionForm();

                        form.AddForm(listNewDevice[0]);

                    }

                    else if (deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueEnvironment || deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueFreshAir)

                    {

                        //方悦环境面板的按键配置&方悦新风面板的按键配置

                        var form = new DevicePanel.PanelSettionWithSourceForm();

                        form.AddForm(listNewDevice[0]);

<<<<<<< HEAD:ZigbeeApp20200810/Shared/Phone/UserCenter/Device/DeviceMacInfoEditorForm.cs

                    }
=======

                    }

>>>>>>> dev-tzy:ZigbeeApp/Shared/Phone/UserCenter/Device/DeviceMacInfoEditorForm.cs

                    else

                    {

                        var form = new DevicePanel.PanelFangyueButtonSettionForm();

                        form.AddForm(listNewDevice[0]);

                    }

                };

                return true;

            }

            return false;

        }



        #endregion



        #region ■ 干接点设置(干接点)_________________



        /// <summary>

        /// 添加【干接点设置】行

        /// </summary>

        private void AddDryContactSettionRow()

        {

            if (this.listDeviceType.Contains(DeviceType.OnOffSwitch) == false)

            {

                //必须有一路回路是OnOffSwitch才行,面板的干接点的话，使用的是别的菜单

                return;

            }

            if (deviceEnumInfo.IsHdlDevice == true && deviceEnumInfo.BeloneType == DeviceBeloneType.A按键面板)

            {

                //河东的面板的话，它有自己的配置界面,

                //如果是第三方设备的话，使用普通干接点界面(它能使用绑定功能,无背光设置)

                return;

            }



            //干接点设置

            string caption = Language.StringByID(R.MyInternationalizationString.uDryContactSettion);

            var btnBackLight = new FrameRowControl(listview.rowSpace / 2);

            listview.AddChidren(btnBackLight);

            btnBackLight.AddLeftCaption(caption, 600);

            //向右图标

            btnBackLight.AddRightArrow();

            //底线

            btnBackLight.AddBottomLine();

            btnBackLight.ButtonClickEvent += (sender, e) =>

            {

                var form = new DeviceDryContactSettionForm();

                form.AddForm(listNewDevice[0]);

            };

        }



        #endregion



        #region ■ 工作模式(pir传感器专用)____________



        /// <summary>

        /// 添加【工作模式】行(pir传感器专用)

        /// </summary>

        private void AddPirSensorWorkModeRow()

        {

            if (this.deviceEnumInfo.ConcreteType != DeviceConcreteType.Sensor_Pir

                || deviceEnumInfo.IsHdlDevice == false)

            {

                return;

            }

            //工作模式

            string caption = Language.StringByID(R.MyInternationalizationString.uWorkMode);

            var btnFunction = new FrameRowControl(listview.rowSpace / 2);

            listview.AddChidren(btnFunction);

            btnFunction.AddLeftCaption(caption, 600);

            //向右图标

            btnFunction.AddRightArrow();

            //底线

            btnFunction.AddBottomLine();

            btnFunction.ButtonClickEvent += (sender, e) =>

            {

                var form = new DevicePirSensor.PirSensorWorkModeMenuForm();

                form.AddForm((IASZone)this.listNewDevice[0]);

            };

        }



        #endregion;



        #region ■ 绑定目标(pir传感器专用)____________



        /// <summary>

        /// 添加【绑定目标】行(pir传感器专用)

        /// </summary>

        private void AddPirSensorBindRow()

        {

            if (this.deviceEnumInfo.ConcreteType != DeviceConcreteType.Sensor_Pir)

            {

                return;

            }

            //绑定目标

            string caption = Language.StringByID(R.MyInternationalizationString.uBindTargets);

            var btnFunction = new FrameRowControl(listview.rowSpace / 2);

            listview.AddChidren(btnFunction);

            btnFunction.AddLeftCaption(caption, 600);

            //向右图标

            btnFunction.AddRightArrow();

            //底线

            btnFunction.AddBottomLine();

            btnFunction.ButtonClickEvent += (sender, e) =>

            {

                var form = new DevicePirSensor.PirSensorBindTargetSettionForm();

                form.AddForm((IASZone)this.listNewDevice[0]);

            };

        }



        #endregion;



        #region ■ 功能设置(通用)_____________________



        /// <summary>

        /// 添加【功能设置】行

        /// </summary>

        private void AddFunctionSettionRow()

        {

            //只有回路数大于1才能有这个菜单

            if (Common.LocalDevice.Current.GetDevicesCountByMac(listNewDevice[0].DeviceAddr) == 1)

            {

                //新风小模块只有一个回路，但要求新风小模块的新风有功能设置

                if (deviceEnumInfo.ConcreteType != DeviceConcreteType.Relay_FangyueFreshAirModul)

                {

                    return;

                }

            }

            if (deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueEnvironment

                || deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueFreshAir)

            {

                //环境面板没有功能设置

                return;

            }



            //2020.03.06新追加：如果全部都是干接点的话,也不能有这个东西

            int dryContactCount = 0;

            for (int i = 0; i < listNewDevice.Count; i++)

            {

                if (listNewDevice[i].Type == DeviceType.OnOffSwitch)

                {

                    dryContactCount++;

                }

            }

            if (listNewDevice.Count == dryContactCount)

            {

                //这个设备全是干接点

                return;

            }



            //功能设置

            string caption = Language.StringByID(R.MyInternationalizationString.uFunctionSettingUp);

            var btnFunction = new FrameRowControl(listview.rowSpace / 2);

            listview.AddChidren(btnFunction);

            btnFunction.AddLeftCaption(caption, 600);

            //向右图标

            btnFunction.AddRightArrow();

            //底线

            btnFunction.AddBottomLine();

            btnFunction.ButtonClickEvent += (sender, e) =>

            {

                //方悦面板

                if (deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueTwo

                    || deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueFour

                    || deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueEight)

                {

                    var form = new DevicePanel.PanelFangyueFunctionSettionForm();

                    form.AddForm(listNewDevice[0], deviceEnumInfo);

                }

                //简约环境面板的按键配置

                else if (deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_SimpleMultifunction)

                {

                    var form = new DeviceFunctionSettionForm();

                    if (listNewDevice.Count > 62)

                    {

                        form.AddForm(listNewDevice[62], true);

                    }

                }

                //河东的面板设备

                else if (deviceEnumInfo.BeloneType == DeviceBeloneType.A按键面板 && deviceEnumInfo.IsHdlDevice == true)

                {

                    var form = new DevicePanel.PanelFunctionSettionForm();

                    form.AddForm(listNewDevice[0]);

                }

                else

                {

                    var form = new DeviceFunctionSettionForm();

                    form.AddForm(listNewDevice[0], false);

                }

            };

        }



        /// <summary>

        /// 添加传感器【功能设置】行

        /// </summary>

        private void AddFunctionSettionRowPM()

        {

            //功能设置

            string caption = Language.StringByID(R.MyInternationalizationString.uFunctionSettingUp);

            var btnFunction = new FrameRowControl(listview.rowSpace / 2);

            listview.AddChidren(btnFunction);

            btnFunction.AddLeftCaption(caption, 600);

            //向右图标

            btnFunction.AddRightArrow();

            //底线

            btnFunction.AddBottomLine();

            btnFunction.ButtonClickEvent += (sender, e) =>

            {

                var form = new DeviceFunctionSettionForm();

                form.AddForm(listNewDevice[0], false);

            };

        }



        #endregion;



        #region ■ 方向与限位(窗帘)___________________



        /// <summary>

        /// 添加【方向与限位】行(窗帘专用)

        /// </summary>

        private void AddDirectionAndLimitRow()

        {

            if (deviceEnumInfo.BeloneType != DeviceBeloneType.A窗帘)

            {

                return;

            }

            var deviceCurtain = (Rollershade)this.listNewDevice[0];

            if (deviceCurtain.WcdType != 4 && deviceCurtain.WcdType != 0)

            {

                //开合帘,卷帘专用

                return;

            }



            //方向与限位

            string caption = Language.StringByID(R.MyInternationalizationString.uDirectionAndLimit);

            var btnFunction = new FrameRowControl(listview.rowSpace / 2);

            listview.AddChidren(btnFunction);

            btnFunction.AddLeftCaption(caption, 600);

            //向右图标

            btnFunction.AddRightArrow();

            //底线

            btnFunction.AddBottomLine();

            btnFunction.ButtonClickEvent += (sender, e) =>

            {

                if (deviceCurtain.WcdType == 4)

                {

                    var form = new DeviceCurtain.AutoOpenDirectionAndLimitSettionForm();

                    form.AddForm(deviceCurtain);

                }

                else if (deviceCurtain.WcdType == 0)

                {

                    var form = new DeviceCurtain.SiphonateDirectionAndLimitSettionForm();

                    form.AddForm(deviceCurtain);

                }

            };

        }



        #endregion;



        #region ■ 手拉控制(开合帘)___________________



        /// <summary>

        /// 添加【手拉控制】行(开合帘专用)

        /// </summary>

        private void AddHandPullControlRow()

        {

            if (deviceEnumInfo.BeloneType != DeviceBeloneType.A窗帘)

            {

                return;

            }

            var deviceCurtain = (Rollershade)this.listNewDevice[0];

            if (deviceCurtain.WcdType != 4)

            {

                //开合帘专用

                return;

            }



            //手拉控制

            string caption = Language.StringByID(R.MyInternationalizationString.uHandPullControl);

            var btnFunction = new FrameRowControl(listview.rowSpace / 2);

            btnFunction.UseClickStatu = false;

            listview.AddChidren(btnFunction);

            btnFunction.AddLeftCaption(caption, 600);

            //开关图标

            var btnSwitch = btnFunction.AddMostRightSwitchIcon();

            //底线

            btnFunction.AddBottomLine();

            btnSwitch.ButtonClickEvent += (sender, e) =>

            {

                //切换模式

                bool statu = !btnSwitch.IsSelected;

                var result = HdlDeviceCurtainLogic.Current.SetHandPullControl(deviceCurtain, statu);

                if (result == true)

                {

                    btnSwitch.IsSelected = statu;

                }

            };

            //如果是虚拟住宅

            if (Common.Config.Instance.Home.IsVirtually == true)

            {

                btnSwitch.IsSelected = ModelData.DeviceModelDataLogic.Current.GetCurtainHandPullControl(deviceCurtain);

                return;

            }



            //添加属性上报监听

            string mainkeys = LocalDevice.Current.GetDeviceMainKeys(this.listNewDevice[0]);

            HdlGatewayReceiveLogic.Current.AddAttributeEvent("HandPullControl", ReceiveComandDiv.A设备属性上报, (device) =>

            {

                string checkKey = LocalDevice.Current.GetDeviceMainKeys(device);

                if (mainkeys != checkKey || device.DeviceStatusReport.CluterID != 258)

                {

                    return;

                }

                foreach (var attriBute in device.DeviceStatusReport.AttriBute)

                {

                    if (attriBute.AttributeId == 23)

                    {

                        //手拉控制

                        if (0 < (attriBute.AttriButeData & 0x04))

                        {

                            HdlThreadLogic.Current.RunMain(() =>

                            {

                                btnSwitch.IsSelected = true;

                            });

                        }

                    }

                }

            });

            //发送命令

            deviceCurtain.ReadCurtainDirectionAndMode();

        }



        #endregion;



        #region ■ 室内机设置(空调)___________________



        /// <summary>

        /// 添加【室内机设置】行(空调专用)

        /// </summary>

        private void AddIndoorUnitSettionRow()

        {

            if (this.deviceEnumInfo.ConcreteType != DeviceConcreteType.AirConditioner_ZbGateway

                || this.listNewDevice[0] is OTADevice)//追加：单纯只有200端点的话，不显示这个菜单

            {

                return;

            }



            //室内机设置

            string caption = Language.StringByID(R.MyInternationalizationString.uIndoorUnitSettion);

            var btnFunction = new FrameRowControl(listview.rowSpace / 2);

            listview.AddChidren(btnFunction);

            btnFunction.AddLeftCaption(caption, 600);

            //向右图标

            btnFunction.AddRightArrow();

            //底线

            btnFunction.AddBottomLine();

            btnFunction.ButtonClickEvent += (sender, e) =>

            {

                var form = new DeviceAirConditioner.IndoorUnitListForm();

                form.AddForm(listNewDevice[0].DeviceAddr);

            };

        }

        #endregion



        #region ■  简约多功能面板用___________________

        /// <summary>

        /// 添加【绑定目标】行

        /// </summary>

        private void AddIBindRow(string deviceMac)

        {

            string bindTargets = Language.StringByID(R.MyInternationalizationString.uBindTargets);

            var btnBindTargets = new FrameRowControl(listview.rowSpace / 2);

            listview.AddChidren(btnBindTargets);

            btnBindTargets.AddLeftCaption(bindTargets, 600);

            //向右图标

            btnBindTargets.AddRightArrow();

            //底线

            btnBindTargets.AddBottomLine();

            btnBindTargets.ButtonClickEvent += (sender, e) =>

            {

                var simpleMutilfunctionTargetsPage = new Shared.Phone.UserCenter.DeviceBind.PanelSimpleMutilfunctionTargetsForm(deviceMac);

                Shared.Phone.UserView.HomePage.Instance.AddChidren(simpleMutilfunctionTargetsPage);

                Shared.Phone.UserView.HomePage.Instance.PageIndex += 1;

                simpleMutilfunctionTargetsPage.Show();

            };

        }



        /// <summary>

        ///  湿度来源行

        /// </summary>

        private void AddHumiditySourceRow(string deviceMac)

        {

            //湿度

            var rowHumidity = new FrameRowControl(listview.rowSpace / 2);

            listview.AddChidren(rowHumidity);

            rowHumidity.AddLeftCaption(Language.StringByID(R.MyInternationalizationString.HumiditySource), 600);

            //底线

            rowHumidity.AddBottomLine();

            //右箭头

            rowHumidity.AddRightArrow();

            var msg = Language.StringByID(R.MyInternationalizationString.nothing);

            if (!string.IsNullOrEmpty(bindHumidityName))

            {

                msg = bindHumidityName;

            }

            var btnHumidityStatu = rowHumidity.AddMostRightView(msg, 700);

            rowHumidity.ButtonClickEvent += (sender, e) =>

            {



                var dev = Common.LocalDevice.Current.GetDevice(deviceMac, 62);//简约面板随便一个回路来获取设备

                var device = new CommonDevice();

                if (dev != null)

                {

                    device.CurrentGateWayId = dev.CurrentGateWayId;

                }

                device.Type = DeviceType.OnOffSwitch;

                device.DeviceAddr = deviceMac;

                device.DeviceEpoint = 65;//能绑定湿度的回路

                var paneTargetsBaseFormp = new PaneTargetsBaseForm(device, bindHumidityDev, BindInfo.BindType.Humidity);

                Shared.Phone.UserView.HomePage.Instance.AddChidren(paneTargetsBaseFormp);

                Shared.Phone.UserView.HomePage.Instance.PageIndex += 1;

                paneTargetsBaseFormp.Show();

                paneTargetsBaseFormp.actionHumidityTarget += (bindName) =>

                {

                    HdlThreadLogic.Current.RunMain(() =>

                    {

                        if (string.IsNullOrEmpty(bindName))

                        {

                            btnHumidityStatu.Text = Language.StringByID(R.MyInternationalizationString.nothing);

                        }

                        else

                        {

                            btnHumidityStatu.Text = bindName;

                        }

                    });

                };

            };

        }



        /// <summary>

        ///  温度来源行

        /// </summary>

        private void AddTemperatureSensorRow(string deviceMac)

        {

            //温度来源

            var rowTemPerature = new FrameRowControl(listview.rowSpace / 2);

            listview.AddChidren(rowTemPerature);

            rowTemPerature.AddLeftCaption(Language.StringByID(R.MyInternationalizationString.TemperatureSource), 600);

            //底线

            rowTemPerature.AddBottomLine();

            //右箭头

            rowTemPerature.AddRightArrow();

            var msg = Language.StringByID(R.MyInternationalizationString.nothing);

            if (!string.IsNullOrEmpty(bindTemperatureName))

            {

                msg = bindTemperatureName;

            }

            var btnTemperatureStatu = rowTemPerature.AddMostRightView(msg, 700);

            rowTemPerature.ButtonClickEvent += (sender, e) =>

            {

                var dev = Common.LocalDevice.Current.GetDevice(deviceMac, 62);//简约面板随便一个回路来获取设备

                var device = new CommonDevice();

                if (dev != null)

                {

                    device.CurrentGateWayId = dev.CurrentGateWayId;

                }

                device.Type = DeviceType.OnOffSwitch;

                device.DeviceAddr = deviceMac;

                device.DeviceEpoint = 64;//能绑定温度的回路

                var paneTargetsBaseFormp = new PaneTargetsBaseForm(device, bindTemperatureDev, BindInfo.BindType.Temperature);

                Shared.Phone.UserView.HomePage.Instance.AddChidren(paneTargetsBaseFormp);

                Shared.Phone.UserView.HomePage.Instance.PageIndex += 1;

                paneTargetsBaseFormp.Show();

                paneTargetsBaseFormp.actionTemperatureTarget += (bindName) =>

                {

                    HdlThreadLogic.Current.RunMain(() =>

                    {

                        if (string.IsNullOrEmpty(bindName))

                        {

                            btnTemperatureStatu.Text = Language.StringByID(R.MyInternationalizationString.nothing);

                        }

                        else

                        {

                            btnTemperatureStatu.Text = bindName;

                        }

                    });

                };

            };

        }



        /// <summary>

        ///读温湿度数据

        /// </summary>

        void InitBindInfo(CommonDevice curControlDev)

        {

            System.Threading.Tasks.Task.Run(async () =>

            {

                try

                {

                    Application.RunOnMainThread(() =>

                    {

                        CommonPage.Loading.Start("");

                    });

                    //1、获去绑定的温度传感器

                    curControlDev.DeviceEpoint = 64;

                    var result = await GetBindName(curControlDev);

                    if (!result)

                    {

                        Application.RunOnMainThread(() =>

                        {

                            new Tip() { MaxWidth = 150, Text = Language.StringByID(R.MyInternationalizationString.GwResponseOvertime) + "(" + "5007_2" + ")", Direction = AMPopTipDirection.None, CloseTime = 1 }.Show(Common.CommonPage.Instance);

                        });

                        return;

                    }



                    //2、获去绑定的湿度度传感器

                    curControlDev.DeviceEpoint = 65;

                    var result2 = await GetBindName(curControlDev);

                    if (!result2)

                    {

                        Application.RunOnMainThread(() =>

                        {

                            new Tip() { MaxWidth = 150, Text = Language.StringByID(R.MyInternationalizationString.GwResponseOvertime) + "(" + "5007_3" + ")", Direction = AMPopTipDirection.None, CloseTime = 1 }.Show(Common.CommonPage.Instance);

                        });

                        return;

                    }

                }

                catch (Exception ex)

                {

                    var mess = ex.Message;

                }

                finally

                {

                    Application.RunOnMainThread(() =>

                    {

                        //初始化中部控件

                        this.InitMiddleFrame();

                        CommonPage.Loading.Hide();

                    });

                }

            });

        }



        /// <summary>

        /// 获取绑定的温湿度目标

        /// </summary>

        /// <param name="curControlDev"></param>

        /// <returns></returns>

        private async System.Threading.Tasks.Task<bool> GetBindName(CommonDevice curControlDev)

        {

            bool result = false;

            var panelBindListRes = HdlDeviceBindLogic.Current.GetDeviceBindAsync(curControlDev);

            if (panelBindListRes != null && panelBindListRes.getAllBindResponseData != null)

            {

                bindList = panelBindListRes.getAllBindResponseData.BindList;

                foreach (var bDev in bindList)

                {

                    var device = Common.LocalDevice.Current.GetDevice(bDev.BindMacAddr, bDev.BindEpoint);

                    if (device == null)

                    {

                        continue;

                    }

                    if (device.Type == DeviceType.TemperatureSensor)

                    {

                        var bD = device as TemperatureSensor;

                        if (bD.SensorDiv == 1 && bDev.BindCluster == 1026)

                        {

                            if (string.IsNullOrEmpty(bDev.ESName))

                            {

                                bindTemperatureName = Common.LocalDevice.Current.GetDeviceEpointName(device);

                            }

                            else

                            {

                                bindTemperatureName = bDev.ESName;

                            }

                            bindTemperatureDev = device;

                        }

                        if (bD.SensorDiv == 2 && bDev.BindCluster == 1029)

                        {

                            if (string.IsNullOrEmpty(bDev.ESName))

                            {

                                bindHumidityName = Common.LocalDevice.Current.GetDeviceEpointName(device);

                            }

                            else

                            {

                                bindHumidityName = bDev.ESName;

                            }



                            bindHumidityDev = device;

                        }

                    }

                    if (device.Type == DeviceType.FreshAirHumiditySensor)

                    {

                        if (string.IsNullOrEmpty(bDev.ESName))

                        {

                            bindHumidityName = Common.LocalDevice.Current.GetDeviceEpointName(device);

                        }

                        else

                        {

                            bindHumidityName = bDev.ESName;

                        }



                        bindHumidityDev = device;

                    }

                }

                result = true;

            }

            return result;

        }

        #endregion



        #region ■ 功能类型(空气开关专用)_____________



        /// <summary>

        /// 添加【功能类型】行(空气开关专用)

        /// </summary>

        private void AddAirSwitchFunctionTypeRow()

        {

            //2020.04.28变更:有个别设备它除了继电器回路，什么都没有了,

            //这个时候也要现实出来

            if (this.listNewDevice.Count != 1)

            {

                return;

            }

            if (this.listNewDevice[0].Type != DeviceType.OnOffOutput

                && this.listNewDevice[0].Type != DeviceType.AirSwitch)

            {

                return;

            }

            //自定义功能类型控件

            var rowFunction = new DeviceFunctionTypeRowControl(this.listNewDevice[0], listview.rowSpace / 2);

            listview.AddChidren(rowFunction);

            rowFunction.InitControl();

            //底线

            rowFunction.AddBottomLine();

        }



        #endregion



        #region ■ 通用信息___________________________



        /// <summary>

        /// 添加【通用信息】行

        /// </summary>

        private void AddGeneralInformationRow()

        {

            string caption = Language.StringByID(R.MyInternationalizationString.uGeneralInformation);

            var btnGeneral = new FrameRowControl(listview.rowSpace / 2);

            listview.AddChidren(btnGeneral);

            btnGeneral.AddLeftCaption(caption, 600);

            //向右图标

            btnGeneral.AddRightArrow();

            //底线

            btnGeneral.AddBottomLine();

            btnGeneral.ButtonClickEvent += (sender, e) =>

            {

                var form = new DeviceGeneralInformationForm();

                form.AddForm(listNewDevice[0].DeviceAddr);

            };

        }



        #endregion



        #region ■ 空调模块版本(空调专用)_____________



        /// <summary>

        /// 添加【空调模块版本】行(河东的中央空调)

        /// </summary>

        private void AddAirConditionerModelVersionRow()

        {

            if (this.deviceEnumInfo.ConcreteType != DeviceConcreteType.AirConditioner_ZbGateway)

            {

                //不是中央空调

                return;

            }

            string caption = Language.StringByID(R.MyInternationalizationString.uAirConditionerModelVersion);

            var rowVersion = new FrameRowControl(listview.rowSpace / 2);

            rowVersion.UseClickStatu = false;

            listview.AddChidren(rowVersion);

            rowVersion.AddLeftCaption(caption, 600);

            //版本

            this.btnAirConditionerVersion = rowVersion.AddMostRightView("", 800);

            //底线

            rowVersion.AddBottomLine();



            //获取中央空调模块的版本

            this.ReadAirConditionerVersion();

        }



        #endregion



        #region ■ 固件升级___________________________



        /// <summary>

        /// 添加【固件升级】行

        /// </summary>

        private void AddFirmwareUpdateRow()

        {

            //拥有200端口这个东西的时候，才会显示这一行

            var oTADevice = Common.LocalDevice.Current.GetOTADevice(listNewDevice[0].DeviceAddr);

            if (oTADevice == null)

            {

                return;

            }



            //固件升级

            string caption = Language.StringByID(R.MyInternationalizationString.uFirmwareUpdate);

            var rowUpDate = new FrameRowControl(listview.rowSpace / 2);

            listview.AddChidren(rowUpDate);

            rowUpDate.AddLeftCaption(caption, 600);

            //向右图标

            rowUpDate.AddRightArrow();

            //底线

            rowUpDate.AddBottomLine();



            //提示有新版本

            var btnNewVersion = new PicViewControl(78, 55);

            btnNewVersion.UnSelectedImagePath = "Item/NewVersion.png";

            btnNewVersion.Visible = false;

            btnNewVersion.X = Application.GetRealWidth(242);

            btnNewVersion.Y = Application.GetRealHeight(23);

            rowUpDate.AddChidren(btnNewVersion, ChidrenBindMode.BindEvent);



            rowUpDate.ButtonClickEvent += (sender, e) =>

            {

                if (this.deviceEnumInfo.ConcreteType != DeviceConcreteType.AirConditioner_ZbGateway)

                {

                    //这个是一般设备的升级

                    var form = new DeviceFirmwareUpdateForm();

                    form.AddForm(listNewDevice[0].DeviceAddr);

                }

                else

                {

                    //中央空调的升级的话，是特殊的

                    var form = new DeviceAirConditioner.ACZbGatewayUpdateMenuForm();

                    form.AddForm(listNewDevice[0], btnNewVersion.Visible);

                }

                btnNewVersion.Visible = false;

            };



            //如果当前住宅不是虚拟住宅

            if (Common.Config.Instance.Home.IsVirtually == false)

            {

                //设置设备的版本信息

                this.SetDeviceVersionInfo(btnNewVersion, oTADevice);

            }

        }



        /// <summary>

        /// 设置设备的版本信息

        /// </summary>

        /// <param name="btnNewVersion">有新版本的提示控件</param>

        /// <param name="oTADevice">ota设备</param>

        private void SetDeviceVersionInfo(PicViewControl btnNewVersion, OTADevice oTADevice)

        {

            HdlThreadLogic.Current.RunThread(() =>

            {

                bool receiveImageInfo = false;

                //设置设备全部的镜像信息

                HdlDeviceImageInfoLogic.Current.SetAllImageInfoToOtaDevice(oTADevice, (device, reportData) =>

                {

                    receiveImageInfo = true;

                });

                int count = 5;

                while (receiveImageInfo == false && count > 0)

                {

                    //等待设备镜像的反馈

                    System.Threading.Thread.Sleep(300);

                    count--;

                }

                //移除事件

                HdlDeviceImageInfoLogic.Current.RemoveDeviceFirmwareVersionThread(oTADevice);



                oTADevice = Common.LocalDevice.Current.GetOTADevice(listNewDevice[0].DeviceAddr);

                //添加升级固件信息(成不成功都无所谓)

                var result = HdlFirmwareUpdateLogic.AddFirmwareVersionInfo(FirmwareLevelType.ZigbeeDevice, oTADevice.HwVersion.ToString(), oTADevice.ImgTypeId.ToString());



                //获取设备最新版本

                var deviceFirmware = HdlFirmwareUpdateLogic.GetFirmwareMostVersionInfo(FirmwareLevelType.ZigbeeDevice,

                    oTADevice.HwVersion.ToString(),

                    oTADevice.ImgTypeId.ToString(),

                    oTADevice.ImgVersion);



                if (deviceFirmware != null && deviceFirmware.FirmwareVersion > oTADevice.ImgVersion)

                {

                    HdlThreadLogic.Current.RunMain(() =>

                    {

                        if (btnNewVersion != null)

                        {

                            btnNewVersion.Visible = true;

                        }

                    }, ShowErrorMode.NO);

                }

            });

        }



        #endregion



        #region ■ 修改名字___________________________



        /// <summary>

        /// 设备重命名

        /// </summary>

        /// <param name="i_deviceName">deviceName.</param>

        private void DeviceReName(string i_deviceName, bool closeForm)

        {

            //修改MAC名

            string deviceName = i_deviceName.Trim();

            var result = Common.LocalDevice.Current.ReMacName(this.listNewDevice, deviceName);

            if (result == false)

            {

                return;

            }

            if (closeForm == true)

            {

                //关闭界面

                this.CloseForm();

            }

            else

            {

                //设备备注修改成功!

                string msg = Language.StringByID(R.MyInternationalizationString.uDeviceReNoteSuccess);

                this.ShowMassage(ShowMsgType.Tip, msg);

            }

        }



        #endregion



        #region ■ 右上角菜单_________________________



        /// <summary>

        /// 初始化右上角菜单

        /// </summary>

        private void InitTopRightMenu()

        {

            var btnIcon = new MostRightIconControl(69, 69);

            btnIcon.UnSelectedImagePath = "Item/More.png";

            topFrameLayout.AddChidren(btnIcon);

            btnIcon.InitControl();

            btnIcon.ButtonClickEvent += ((sender, e) =>

            {

                //显示右上角菜单界面

                this.ShowTopRightMenu();

            });

        }



        /// <summary>

        /// 显示右上角菜单界面

        /// </summary>

        private void ShowTopRightMenu()

        {

            //检测此回路是否拥有定位功能(拿端点最小的那个回路去定位)

            bool canTest = Common.LocalDevice.Current.DeviceIsCanFixedPosition(listNewDevice[0]);



            TopRightMenuControl frame = null;



            if (deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_SimpleMultifunction)

            {

                frame = new TopRightMenuControl(3, 1);

            }

            else

            {

                frame = new TopRightMenuControl(canTest == true ? 2 : 1, 1);

            }



            string deviceMenu = string.Empty;

            if (canTest == true)

            {

                //定位

                deviceMenu = Language.StringByID(R.MyInternationalizationString.uFixedPosition);

                frame.AddRowMenu(deviceMenu, "Item/FixedPosition.png", "Item/FixedPositionSelected.png", () =>

                {

                    //发送定位功能

                    Common.LocalDevice.Current.SetFixedPositionCommand(listNewDevice[0]);

                });

            }



            //删除

            deviceMenu = Language.StringByID(R.MyInternationalizationString.uDelete);

            frame.AddRowMenu(deviceMenu, "Item/DeleteIcon2.png", "Item/DeleteIcon2Selected.png", () =>

            {

                //如果当前住宅是虚拟住宅,此功能无效

                if (Common.Config.Instance.Home.IsVirtually == true)

                {

                    return;

                }

                //确认删除该设备及功能？

                string msg = Language.StringByID(R.MyInternationalizationString.uDeleteDeviceMsg);

                this.ShowMassage(ShowMsgType.Confirm, msg, () =>

                {

                    //删除指定设备

                    this.DoDeleteDevice();

                });

            });



            //同步

            deviceMenu = Language.StringByID(R.MyInternationalizationString.Synchronization);

            if (Common.LocalDevice.Current.DeviceIsCanFixedPosition(listNewDevice[0]))

            {

                frame.AddRowMenu(deviceMenu, "", "Item/SynchronizationSelected.png", () =>

                {

                    //如果当前住宅是虚拟住宅,此功能无效

                    if (Common.Config.Instance.Home.IsVirtually == true)

                    {

                        return;

                    }



                    //同步指定设备

                    this.SynchronizationDevice();

                });

            }



        }



        /// <summary>

        /// 删除指定设备

        /// </summary>

        private void DoDeleteDevice()

        {

            HdlThreadLogic.Current.RunThread(async () =>

            {

                //打开进度条

                this.ShowProgressBar();



                //删除设备

                bool result = await Common.LocalDevice.Current.DeleteDevice(listNewDevice);

                //关闭进度条

                this.CloseProgressBar();

                if (result == false)

                {

                    return;

                }

                HdlThreadLogic.Current.RunMain(() =>

                {

                    //关闭界面

                    this.CloseForm();

                });

            });

        }



        /// <summary>

        /// 同步指定设备

        /// </summary>

        private void SynchronizationDevice()

        {

            HdlThreadLogic.Current.RunThread(async () =>

            {

                //打开进度条

                this.ShowProgressBar();



                //同步设备

                bool result = await Common.LocalDevice.Current.SynchronizationDevice(listNewDevice);

                //关闭进度条

                this.CloseProgressBar();

                if (result == false)

                {

                    return;

                }

            });

        }

        #endregion



        #region ■ 关闭界面___________________________



        /// <summary>

        /// 画面关闭

        /// </summary>

        public override void CloseFormBefore()

        {

            HdlGatewayReceiveLogic.Current.RemoveEvent("HandPullControl");

            //移除获取设备硬件信息的监听线程

            HdlDeviceHardInfoLogic.Current.RemoveDeviceHardInfoThread(listNewDevice[0]);



            //设备新入网

            if (UserCenterResourse.DicActionForm.ContainsKey("AddDeviceTypeListForm") == true)

            {

                this.LoadFormMethodByName("DeviceListMainForm", "RefreshDeviceRow", new object[] { listNewDevice[0].DeviceAddr });

            }



            base.CloseFormBefore();

        }



        #endregion



        #region ■ 硬件信息___________________________



        /// <summary>

        /// 重新获取硬件信息

        /// </summary>

        private void RefreshHardFirmwareInfo()

        {

            if (listNewDevice[0].DriveCode > 0)

            {

                //虚拟设备没有这种操作

                return;

            }

            //重新获取硬件信息

            HdlDeviceHardInfoLogic.Current.SetAllHardFirmwareInfoToDevice(listNewDevice[0], (device, reportData) =>

            {

                for (int i = 1; i < listNewDevice.Count; i++)

                {

                    //全部回路的信息都是一致的

                    HdlDeviceHardInfoLogic.Current.SetHardFirmwareInfo(device.DeviceStatusReport, listNewDevice[i]);

                    listNewDevice[i].ReSave();

                }

            });

        }



        #endregion



        #region ■ 界面重新激活事件___________________



        /// <summary>

        /// 自身的上层界面关闭后,它自身处于最上层时,触发的事件

        /// </summary>

        public override int FormActionAgainEvent()

        {

            //重新获取中央空调模块的版本

            this.ReadAirConditionerVersion();



            return 0;

        }



        #endregion



        #region ■ 一般方法___________________________



        /// <summary>

        /// 获取中央空调模块的版本

        /// </summary>

        private void ReadAirConditionerVersion()

        {

            if (this.btnAirConditionerVersion == null)

            {

                return;

            }

            //获取中....

            this.btnAirConditionerVersion.TextID = R.MyInternationalizationString.uGetting;

            HdlThreadLogic.Current.RunThread(async () =>

            {

                //读取空调模块版本

                var result = await HdlDeviceAirConditionerLogic.Current.ReadACFirewareVersionAsync(listNewDevice[0]);

                if (result == null || result.readACFirewareVersionResponData == null || result.readACFirewareVersionResponData.Status != 0)

                {

                    HdlThreadLogic.Current.RunMain(() =>

                    {

                        //获取失败

                        btnAirConditionerVersion.TextID = R.MyInternationalizationString.uGettingFail;

                    });

                }

                else

                {

                    HdlThreadLogic.Current.RunMain(() =>

                    {

                        btnAirConditionerVersion.Text = result.readACFirewareVersionResponData.FirewareVersion.Replace("-", string.Empty);

                    });

                }

            });

        }



        /// <summary>

        /// 检测能否显示功能设置的菜单

        /// </summary>

        /// <returns></returns>

        private bool CheckCanShowFunctionSettionRow()

        {

            //方悦新风面板没有功能设置

            if (deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FangyueFreshAir

                || deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_FourButtonScene

                || deviceEnumInfo.ConcreteType == DeviceConcreteType.ButtonPanel_TwoButtonCurtain)

            {

                return false;

            }

            return true;

        }



        #endregion

    }

}


 ZigbeeApp20200810/Shared/Phone/UserCenter/Device/Panel/PanelSimpleMutilfunctionAddTargetsForm.cs

@@ -1027,22 +1027,20 @@
                        for (int i = 0; i < targetScList.Count; i++)
                        {
                            //绑定新的数据
                            var addBindeDev = new AddBindData();
                            addBindeDev.DeviceAddr = curControlDev.DeviceAddr;
                            var addSingleBindData = new AddSingleBindData();
                            addSingleBindData.DeviceAddr = curControlDev.DeviceAddr;
                            for (int j = 0; j < curSupportBindEpointList.Count; j++)
                            {
                                curSendEpointList.Add(curSupportBindEpointList[0]);
                                addBindeDev.Epoint = curControlDev.DeviceEpoint = curSupportBindEpointList[0];
                                addSingleBindData.Epoint = curControlDev.DeviceEpoint = curSupportBindEpointList[0];
                                break;
                            }
                            var de = targetScList[i];
                            var addBindInfo = new AddBindListObj();
                            addBindInfo.BindType = 1;
                            addBindInfo.BindCluster = 6;
                            addBindInfo.BindScenesId = de.Id;
                            addBindeDev.BindList.Add(addBindInfo);
                            addSingleBindData.BindType = 1;
                            addSingleBindData.BindClusterList.Add(6);
                            addSingleBindData.BindScenesId = de.Id;

                            var resT = AddDeviceBind(addBindeDev, targetSendCount, ref targetRecCount);
                            var resT = AddDeviceBind(addSingleBindData, targetSendCount, ref targetRecCount);
                            if (!resT)
                            {
                                break;
@@ -1071,8 +1069,8 @@
                        foreach (var de in targetList)
                        {
                            //绑定新的数据
                            var addBindeDev = new AddBindData();
                            addBindeDev.DeviceAddr = curControlDev.DeviceAddr;
                            var addSingleBindData = new AddSingleBindData();
                            addSingleBindData.DeviceAddr = curControlDev.DeviceAddr;

                            if (curBindType == 3)
                            {
@@ -1081,7 +1079,7 @@
                                    for (int j = 0; j < curSupportDimmerEpointList.Count; j++)
                                    {
                                        curSendEpointList.Add(curSupportDimmerEpointList[0]);
                                        addBindeDev.Epoint = curControlDev.DeviceEpoint = curSupportDimmerEpointList[0];
                                        addSingleBindData.Epoint = curControlDev.DeviceEpoint = curSupportDimmerEpointList[0];
                                        break;
                                    }
                                }
@@ -1091,7 +1089,7 @@
                                    for (int j = 0; j < curSupportLightEpointList.Count; j++)
                                    {
                                        curSendEpointList.Add(curSupportLightEpointList[0]);
                                        addBindeDev.Epoint = curControlDev.DeviceEpoint = curSupportLightEpointList[0];
                                        addSingleBindData.Epoint = curControlDev.DeviceEpoint = curSupportLightEpointList[0];
                                        break;
                                    }
                                }
@@ -1101,68 +1099,48 @@
                                for (int j = 0; j < curSupportBindEpointList.Count; j++)
                                {
                                    curSendEpointList.Add(curSupportBindEpointList[0]);
                                    addBindeDev.Epoint = curControlDev.DeviceEpoint = curSupportBindEpointList[0];
                                    addSingleBindData.Epoint = curControlDev.DeviceEpoint = curSupportBindEpointList[0];
                                    break;
                                }
                            }

                            var addBindInfo = new AddBindListObj();
                            addBindInfo.BindType = 0;
                            addBindInfo.BindMacAddr = de.DeviceAddr;
                            addBindInfo.BindEpoint = de.DeviceEpoint;
                            addSingleBindData.BindType = 0;
                            addSingleBindData.BindMacAddr = de.DeviceAddr;
                            addSingleBindData.BindEpoint = de.DeviceEpoint;
                            switch (curBindType)
                            {
                                case 0:
                                    addBindInfo.BindCluster = 6;
                                    break;
                                case 1:
                                    addBindInfo.BindCluster = 6;
                                    break;
                                case 2:
                                    addBindInfo.BindCluster = 6;
                                    addSingleBindData.BindClusterList.Add(6);
                                    break;
                                case 3:
                                    addBindInfo.BindCluster = 6;
                                    break;
                                case 4:
                                    addBindInfo.BindCluster = 258;
                                    break;
                                case 5:
                                    addBindInfo.BindCluster = 513;
                                    break;
                                case 6:
                                    addBindInfo.BindCluster = 514;
                                    break;
                            }
                            addBindeDev.BindList.Add(addBindInfo);

                            //部分目标需要二次绑定第二种功能
                            var addBindInfo2 = new AddBindListObj();
                            addBindInfo2.BindType = 0;
                            addBindInfo2.BindMacAddr = de.DeviceAddr;
                            addBindInfo2.BindEpoint = de.DeviceEpoint;
                            switch (curBindType)
                            {
                                case 3:
                                    addSingleBindData.BindClusterList.Add(6);
                                    var device = LocalDevice.Current.GetDevice(de.DeviceAddr, de.DeviceEpoint);
                                    if (device != null)
                                    {
                                        if (device.Type == DeviceType.DimmableLight)
                                        {
                                            //灯光为调光时需要绑定6，8
                                            addBindInfo2.BindCluster = 8;
                                            addBindeDev.BindList.Add(addBindInfo2);
                                            addSingleBindData.BindClusterList.Add(8);
                                        }
                                    }
                                    break;
                                case 4:
                                    addSingleBindData.BindClusterList.Add(258);
                                    break;
                                case 5:
                                    //要绑定空调：需要绑定513，514
                                    addBindInfo2.BindCluster = 514;
                                    addBindeDev.BindList.Add(addBindInfo2);
                                    addSingleBindData.BindClusterList.Add(513);
                                    addSingleBindData.BindClusterList.Add(514);
                                    break;
                                case 6:
                                    addSingleBindData.BindClusterList.Add(514);
                                    break;
                            }

                            var resT = AddDeviceBind(addBindeDev, targetSendCount, ref targetRecCount);

                            var resT = AddDeviceBind(addSingleBindData, targetSendCount, ref targetRecCount);
                            if (!resT)
                            {
                                break;
@@ -1186,36 +1164,36 @@
        /// <summary>
        /// AddDeviceBind
        /// </summary>
        /// <param name="addBindeDev"></param>
        /// <param name="addSingleBindData"></param>
        /// <param name="targetSendCount"></param>
        /// <param name="targetRecCount"></param>
        /// <returns></returns>
        private bool AddDeviceBind(AddBindData addBindeDev, int targetSendCount, ref int targetRecCount)
        private bool AddDeviceBind(AddSingleBindData addSingleBindData, int targetSendCount, ref int targetRecCount)
        {
            var addSuccess = false;
            var dev = HdlDeviceBindLogic.Current.AddDeviceBindAsync(addBindeDev);
            if (dev != null && dev.addedDeviceBindResponseData != null)
            var dev = HdlDeviceBindLogic.Current.AddDeviceSingleBindAsync(addSingleBindData);
            if (dev != null && dev.addedDeviceSingleBindResponseData != null)
            {
                addSuccess = true;
                targetRecCount++;
                if (dev.addedDeviceBindResponseData.Result == 0)
                if (dev.addedDeviceSingleBindResponseData.Result == 0)
                {
                    var countTotal = targetRecCount;

                    var bList = new List<BindListAllInfo>();
                    foreach (var devB in dev.addedDeviceBindResponseData.BindList)
                    foreach (var cluster in dev.addedDeviceSingleBindResponseData.BindClusterList)
                    {
                        var curD = new BindListAllInfo();
                        curD.KeyMacAddr = curControlDev.DeviceAddr;
                        curD.KeyEpoint = curControlDev.DeviceEpoint;
                        curD.BindCluster = devB.BindCluster;
                        curD.BindScenesId = devB.BindScenesId;
                        curD.BindMacAddr = devB.BindMacAddr;
                        curD.BindEpoint = devB.BindEpoint;
                        curD.ESName = devB.ESName;
                        curD.BindType = devB.BindType;
                        curD.BindCluster = cluster;
                        curD.BindScenesId = dev.addedDeviceSingleBindResponseData.BindScenesId;
                        curD.BindMacAddr = dev.addedDeviceSingleBindResponseData.BindMacAddr;
                        curD.BindEpoint = dev.addedDeviceSingleBindResponseData.BindEpoint;
                        curD.ESName = dev.addedDeviceSingleBindResponseData.ESName;
                        curD.BindType = dev.addedDeviceSingleBindResponseData.BindType;
                        bList.Add(curD);
                    }

                    if (MutilfunctionPanelMethod.bindTargetsFromMutilfunctionPanelList.ContainsKey(curControlDev.DeviceAddr + curControlDev.DeviceEpoint))
                    {
                        MutilfunctionPanelMethod.bindTargetsFromMutilfunctionPanelList[curControlDev.DeviceAddr + curControlDev.DeviceEpoint] = bList;
@@ -1227,12 +1205,12 @@

                    if (curBindType == 3)
                    {
                        if (addBindeDev.Epoint >= 22 && addBindeDev.Epoint <= 28)
                        if (addSingleBindData.Epoint >= 22 && addSingleBindData.Epoint <= 28)
                        {
                            curSupportDimmerEpointList.RemoveAt(0);

                        }
                        if (addBindeDev.Epoint >= 52 && addBindeDev.Epoint <= 61)
                        if (addSingleBindData.Epoint >= 52 && addSingleBindData.Epoint <= 61)
                        {
                            curSupportLightEpointList.RemoveAt(0);
                        }
@@ -1257,7 +1235,7 @@
                        }
                    });
                }
                else if (dev.addedDeviceBindResponseData.Result == 1)
                else if (dev.addedDeviceSingleBindResponseData.Result == 1)
                {
                    Application.RunOnMainThread(() =>
                    {
@@ -1268,7 +1246,7 @@
                        new Tip()
                        {
                            MaxWidth = 150,
                            Text = Language.StringByID(R.MyInternationalizationString.BindFailed) + "(" + "5001_1" + ")",
                            Text = Language.StringByID(R.MyInternationalizationString.BindFailed) + "(" + "5020_1" + ")",
                            Direction = AMPopTipDirection.Up,
                            CloseTime = 1
                        }.Show(btnFinifh);
@@ -1285,7 +1263,7 @@
                        new Tip()
                        {
                            MaxWidth = 150,
                            Text = Language.StringByID(R.MyInternationalizationString.BindUnknownError) + "(" + "5001_2" + ")",
                            Text = Language.StringByID(R.MyInternationalizationString.BindUnknownError) + "(" + "5020_2" + ")",
                            Direction = AMPopTipDirection.Up,
                            CloseTime = 1
                        }.Show(btnFinifh);

 ZigbeeApp20200810/Shared/Phone/UserCenter/Device/Panel/PanelSimpleMutilfunctionTargetsForm.cs

@@ -546,7 +546,7 @@
                var btnDel = rowLayout.AddDeleteControl();
                btnDel.ButtonClickEvent += (sender, e) =>
                {
                    RemoveTargets(bindObj, btnDel);
                    ClearTargets(bindObj);
                };
                #endregion
            }
@@ -706,7 +706,7 @@
        /// <param name="bindDevice"></param>
        /// <param name="btnDel"></param>
        /// <returns></returns>
        private void RemoveTargets(BindListAllInfo bindDevice, Button btnDel)
        private void RemoveTargets(BindListAllInfo bindDevice)
        {
            var delDevice = new DelDeviceBindData();
            delDevice.DeviceAddr = bindDevice.KeyMacAddr;
@@ -857,7 +857,68 @@
            });
        }


        /// <summary>
        /// 清除多功能面板的目标
        /// </summary>
        /// <param name="bindDevice"></param>
        /// <param name="btnDel"></param>
        /// <returns></returns>
        private void ClearTargets(BindListAllInfo bindDevice)
        {
            System.Threading.Tasks.Task.Run(() =>
           {
               try
               {
                   Application.RunOnMainThread(() =>
                   {
                       CommonPage.Loading.Start("");
                   });
                   var currentKey = new Panel();
                   currentKey.DeviceAddr = bindDevice.KeyMacAddr;
                   currentKey.DeviceEpoint = bindDevice.KeyEpoint;
                   currentKey.CurrentGateWayId = curControlDev.CurrentGateWayId;
                   var bindResult = HdlDeviceBindLogic.Current.ClearBindInfoAsync(currentKey);
                   if (bindResult != null && bindResult.clearBindInfoResponseData != null)
                   {
                       if (bindResult.clearBindInfoResponseData.Result != 0)
                       {
                           Application.RunOnMainThread(() =>
                           {
                               new Tip() { MaxWidth = 150, Text = Language.StringByID(R.MyInternationalizationString.RemoveFailed), Direction = AMPopTipDirection.Up, CloseTime = 1 }.Show(CommonPage.Instance);
                               CommonPage.Loading.Hide();
                           });
                       }
                       else
                       {
                           if (MutilfunctionPanelMethod.bindTargetsFromMutilfunctionPanelList.ContainsKey(bindDevice.KeyMacAddr + bindDevice.KeyEpoint))
                           {
                               MutilfunctionPanelMethod.bindTargetsFromMutilfunctionPanelList.Remove(bindDevice.KeyMacAddr + bindDevice.KeyEpoint);
                           }
                           Application.RunOnMainThread(() =>
                           {
                               RefreshBindListUI();
                               CommonPage.Loading.Hide();
                           });
                       }
                   }
                   else
                   {
                       Application.RunOnMainThread(() =>
                       {
                           new Tip() { MaxWidth = 150, Text = Language.StringByID(R.MyInternationalizationString.GwResponseOvertime) + "(" + "5006" + ")", Direction = AMPopTipDirection.Up, CloseTime = 2 }.Show(CommonPage.Instance);
                       });
                   }
               }
               catch { }
               finally
               {
                   Application.RunOnMainThread(() =>
                   {
                       CommonPage.Loading.Hide();
                   });
               }
           });
        }

        /// <summary>
        /// 匹配的类型列表

 ZigbeeApp20200810/Shared/Phone/ZigBee/Device/BindObj.cs

@@ -19,6 +19,15 @@
        }

        [System.Serializable]
        public class AddedDeviceSingleBindResponseAllData : ErrorResponCommon
        {
            /// <summary>
            /// 网关直接反馈绑定设备信息
            /// </summary>
            public AddedDeviceSingleBindResponseData addedDeviceSingleBindResponseData;
        }

        [System.Serializable]
        public class AddedDeviceBindResponseData
        {
            /// <summary>
@@ -34,6 +43,55 @@
            ///<para>1：绑定目标失败，绑定设备目标有漏掉</para> 
            /// </summary>
            public int Result = -1;
        }

        [System.Serializable]
        public class AddedDeviceSingleBindResponseData
        {
            /// <summary>
            /// 控制设备节点的mac地址
            /// </summary>
            public string DeviceAddr;
            /// <summary>
            /// 控制设备节点的端口号 
            /// </summary>
            public int Epoint;
            /// <summary>
            ///绑定名称
            /// </summary>
            public string BindName;
            /// <summary>
            /// 0：成功，针对场景和跨网关绑定 
            ///<para>1：失败，节点设备或场景不存在。</para>
            ///<para>2：同网关设备绑定，等待控制源设备写入反馈结果；以下面主题结果为准</para> 
            /// </summary>
            public int Result = -1;
            /// <summary>
            /// 绑定类型
            ///<para>0：绑定设备 </para>
            ///<para>1：绑定场景</para>
            /// </summary>
            public int BindType;
            /// <summary>
            ///绑定的cluster数组
            /// </summary>
            public List<int> BindClusterList = new List<int>();
            /// <summary>
            /// 绑定设备Mac地址， 当BindType=0时存在
            /// </summary>
            public string BindMacAddr;
            /// <summary>
            /// 绑定设备的端口号，当BindType=0时存在
            /// </summary>
            public int BindEpoint;
            /// <summary>
            /// 绑定场景，当BindType=2时存在
            /// </summary>
            public int BindScenesId;
            /// <summary>
            ///绑定的设备或场景的名称
            /// </summary>
            public string ESName;
        }

        /// <summary>
@@ -97,7 +155,7 @@
            /// </summary>
            public string DeviceAddr;
            /// <summary>
            /// 错误信息
            /// 控制设备节点的端口号 
            /// </summary>
            public int Epoint;
            /// <summary>
@@ -166,10 +224,9 @@
            /// </summary>
            public int BindType;
            /// <summary>
            /// 绑定的cluster,需要控制设备的OutCluster列表中存在该cluster。
            ///如绑定某个设备的on/off，为6。
            ///绑定的clusters数组，需要控制设备的OutCluster列表中存在该cluster。如绑定某个设备的on/off，为6。如绑定场景，填族Id为6
            /// </summary>
            public int BindCluster;
            public List<int> BindClusterList = new List<int>();
            /// <summary>
            /// 绑定设备Mac地址， 当BindType=0时存在
            /// </summary>