新版本

黄学彪

2020-09-18 c7df85937f73fb347ee0b19e9c052d2d00a6df6c

 ZigbeeApp/Shared/Phone/UserCenter/CommonBase/Logic/HdlGatewayLogic.cs

@@ -69,8 +69,7 @@
                        continue;

                    }

                    //添加缓存

                    string gwID = HdlGatewayLogic.Current.GetGatewayId(gateway);

                    dicGateway[gwID] = gateway;

                    dicGateway[gateway.GwId] = gateway;

                }

            }

        }
@@ -83,7 +82,7 @@
            GatewayResourse.AppOldSelectGatewayId = string.Empty;



            //从文件中获取上一次选择的网关id

            byte[] data = Global.ReadFileByDirectory(DirNameResourse.LocalMemoryDirectory, DirNameResourse.AppOldSelectGatewayFile);

            byte[] data = HdlFileLogic.Current.ReadFileByteContent(DirNameResourse.AppOldSelectGatewayFile);

            if (data != null)

            {

                string strvalue = System.Text.Encoding.UTF8.GetString(data);

@@ -119,7 +118,7 @@
            }



            List<string> listBackupGwId = new List<string>();

            var fileData = Global.ReadFileByDirectory(DirNameResourse.LocalMemoryDirectory, DirNameResourse.BackupGatewayIdFile);

            var fileData = HdlFileLogic.Current.ReadFileByteContent(DirNameResourse.BackupGatewayIdFile);

            if (fileData != null)

            {

                //新增：虽然概率低，但是确实发生了。如果有网络时，App重新绑定记录的网关失败的话

@@ -150,26 +149,10 @@
                //删除网关文件

                this.DeleteGatewayFile(gatewayId);

            }

            //LOG输出

            if (listDelete.Count > 0)

            //如果网关都没了的话,把场景全部删了

            if (listDelete.Count > 0 && this.GetAllLocalGateway().Count == 0)

            {

                string msg = "本地拥有的网关：";

                foreach (var gatewayId in this.dicGateway.Keys)

                {

                    msg += gatewayId + ",";

                }

                msg += "\r\n被删除的网关：";

                foreach (var gatewayId in listDelete)

                {

                    msg += gatewayId + ",";

                }

                msg += "\r\n此时云端返回当前账号所绑定有的网关：";

                foreach (var gatewayId in result.Keys)

                {

                    msg += gatewayId + ",";

                }

                var bytes = System.Text.Encoding.UTF8.GetBytes(msg);

                Common.Global.WriteFileByBytesByHomeId("GatewayDeleteLog.txt", bytes);

                HdlSceneLogic.Current.DeleteAllLocalScene();

            }

        }

@@ -185,6 +168,20 @@
                byte[] filebyte = Global.ReadFileByHomeId(file);

                string strvalue = System.Text.Encoding.UTF8.GetString(filebyte);

                var gateway = JsonConvert.DeserializeObject<ZbGateway>(strvalue);

                if (gateway.GwId == string.Empty)

                {

                    //这是旧数据,需要特殊处理

                    var jobject = Newtonsoft.Json.Linq.JObject.Parse(strvalue);

                    string gwInfo = jobject["getGwInfo"].ToString();



                    var result = JsonConvert.DeserializeObject<ZbGatewayData.GetGwData>(gwInfo);

                    //将网关的数据设置到本地缓存中

                    this.SetGatewayDataToLocalMemmory(gateway, result);

                }

                if (gateway.HomeId == string.Empty)

                {

                    gateway.HomeId = Config.Instance.Home.Id;

                }

                return gateway;

            }

            catch (Exception ex)

@@ -203,7 +200,7 @@
        /// </summary>
        /// <param name="zbGateway">网关</param>
        /// <param name="mode">是否显示错误</param>
        public async Task<bool> AddNewGateway(ZbGateway zbGateway, ShowErrorMode mode)
        public bool AddNewGateway(ZbGateway zbGateway, ShowErrorMode mode)
        {

            //设置网关的经纬度

            bool falge = this.SetGatewaySite(zbGateway, Common.Config.Instance.Home.Longitude, Common.Config.Instance.Home.Latitude, ShowErrorMode.NO);
@@ -212,7 +209,7 @@
                return falge;

            }
            //执行添加网关到内存
            var result = await this.DoAddGatewayToMemory(zbGateway, mode);
            var result = this.DoAddGatewayToMemory(zbGateway, mode);
            //前的网关绑定在了当前账号下的不同住宅里面

            if (result == 0)

            {

@@ -232,6 +229,9 @@
            {

                return false;

            }
            //添加网关的话,强制主页刷新
            UserView.UserPage.Instance.RefreshAllForm = true;

            return true;
        }



@@ -242,8 +242,8 @@
        public void AddVirtualGateway(string gatewayId)

        {

            var gateWay = new ZbGateway { IsVirtual = true };

            gateWay.getGatewayBaseInfo.gwID = gatewayId;

            gateWay.getGatewayBaseInfo.HomeId = Shared.Common.Config.Instance.HomeId;

            gateWay.GwId = gatewayId;

            gateWay.HomeId = Shared.Common.Config.Instance.HomeId;

            gateWay.ReSave();

            this.dicGateway[gatewayId] = gateWay;

        }

@@ -254,7 +254,7 @@
        /// <param name="zbGateway">网关对象</param>

        /// <param name="mode">是否显示错误</param>

        /// <returns></returns>

        private async Task<int> DoAddGatewayToMemory(ZbGateway zbGateway, ShowErrorMode mode)

        private int DoAddGatewayToMemory(ZbGateway zbGateway, ShowErrorMode mode)

        {

            if (zbGateway == null)

            {

@@ -267,18 +267,7 @@
                return -1;

            }

            //获取网关的信息

            var result = await zbGateway.GetZbGwInfoAsync();

            //检测网关返回的共通错误状态码

            string error = HdlCheckLogic.Current.CheckCommonErrorCode(result);

            if (error != null)

            {

                if (mode == ShowErrorMode.YES)

                {

                    this.ShowTipMsg(error);

                }

                return -1;

            }



            var result = this.GetGatewayInfo(zbGateway, true, mode);

            if (result == null)

            {

                if (mode == ShowErrorMode.YES)

@@ -290,32 +279,24 @@
                return -1;

            }



            if (result.getGwData == null)

            {

                if (mode == ShowErrorMode.YES)

                {

                    //获取网关信息失败

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

                    this.ShowTipMsg(msg);

                }

                return -1;

            }



            //设置住宅ID到网关

            bool flage2 = await this.SetHomeIdToGateway(zbGateway, Common.Config.Instance.HomeId);

            if (flage2 == false)

            if (result.HomeId != Common.Config.Instance.HomeId)

            {

                if (mode == ShowErrorMode.YES)

                bool flage2 = this.SetHomeIdToGateway(zbGateway, Common.Config.Instance.HomeId, mode);

                if (flage2 == false)

                {

                    //向网关设置住宅ID失败

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

                    this.ShowTipMsg(msg);

                    if (mode == ShowErrorMode.YES)

                    {

                        //向网关设置住宅ID失败

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

                        this.ShowTipMsg(msg);

                    }

                    return -1;

                }

                return -1;

            }



            //更新云端数据库

            int flage1 = await this.SetGatewayIdToDataBase(zbGateway);

            int flage1 = this.SetGatewayIdToDataBase(zbGateway);

            //异常也不鸟它,0是特殊含义

            if (flage1 == 0)

            {

@@ -324,12 +305,12 @@
            if (flage1 == -1)

            {

                //备份失败的网关ID

                HdlGatewayLogic.Current.BackupGatewayIdOnNotNetwork(zbGateway);

                this.BackupGatewayIdOnNotNetwork(zbGateway);

            }



            //是否已经存在

            string gwID = HdlGatewayLogic.Current.GetGatewayId(zbGateway);

            bool isEsist = HdlGatewayLogic.Current.IsGatewayExist(zbGateway);
            string gwID = zbGateway.GwId;

            bool isEsist = this.IsGatewayExist(zbGateway);
            if (isEsist == false)

            {

                //新建一个虚拟的网关出来

@@ -340,11 +321,11 @@


            //刷新的是缓存,不刷新真实物理网关

            this.dicGateway[gwID].GatewayOnlineFlage = zbGateway.GatewayOnlineFlage;

            this.dicGateway[gwID].getGwInfo = result.getGwData;

            this.dicGateway[gwID].getGatewayBaseInfo.GwName = result.getGwData.GwName;

            this.dicGateway[gwID].getGatewayBaseInfo.IpAddress = result.getGwData.GwIP;

            this.dicGateway[gwID].getGatewayBaseInfo.HomeId = Common.Config.Instance.HomeId;

            this.dicGateway[gwID].ReSave();

            //将网关的数据设置到本地缓存中

            this.SetGatewayDataToLocalMemmory(this.dicGateway[gwID], result);

            //顺便这个变量也设置一下

            this.SetGatewayDataToLocalMemmory(zbGateway, result, false);



            if (isEsist == false)

            {

                //添加备份

@@ -360,14 +341,42 @@
        /// <param name="zbGateway"></param>

        /// <param name="HomeId"></param>

        /// <returns></returns>
        public async Task<bool> SetHomeIdToGateway(ZbGateway zbGateway, string HomeId)

        public bool SetHomeIdToGateway(ZbGateway zbGateway, string HomeId, ShowErrorMode mode)

        {

            var info = await zbGateway.GwSetHomeIdAsync(HomeId);

            if (info != null && info.gwSetHomeIdData != null)

            //账号ID

            string accountId = string.Empty;

            if (HomeId != string.Empty)

            {

                return true;

                if (UserCenterResourse.UserInfo.AuthorityNo == 1)

                {

                    //主账号

                    accountId = Config.Instance.Guid;

                }

                else

                {

                    accountId = Config.Instance.Home.MainUserDistributedMark;

                }

            }

            return false;

            var jObject = new Newtonsoft.Json.Linq.JObject { { "Cluster_ID", 0 }, { "Command", 82 } };

            var data = new Newtonsoft.Json.Linq.JObject { { "HomeId", HomeId }, { "AccountId", accountId } };

            jObject.Add("Data", data);

            //住宅ID的设置,固定使用局域网,不存在远程的说法

            var result = this.SendJobjectDataToGateway(zbGateway, "GwSetHomeId", jObject.ToString(), "GwSetHomeId_Respon", 5, true);

            if (result.ErrorMsgDiv == -1)

            {

                if (mode == ShowErrorMode.YES)

                {

                    //错误:网关对象丢失

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

                    this.ShowTipMsg(msg);

                }

                return false;

            }

            if (result.ErrorMsgDiv == 0)

            {

                return false;

            }

            return true;

        }



        /// <summary>

@@ -375,19 +384,16 @@
        /// </summary>

        /// <param name="zbGateway">网关对象</param>

        /// <returns></returns>
        private async Task<int> SetGatewayIdToDataBase(ZbGateway zbGateway)
        private int SetGatewayIdToDataBase(ZbGateway zbGateway)
        {

            //调用接口，绑定网关(即使失败，也返回true往下走)

            var bindGateway = new BindGatewayPra();

            string gwID = this.GetGatewayId(zbGateway);
            bindGateway.BindGateways.Add(gwID);

            bindGateway.BindGateways.Add(zbGateway.GwId);

            //获取控制主人账号的Token

            bindGateway.LoginAccessToken = UserCenterLogic.GetConnectMainToken();

            //不显示已经被绑定过的信息,NotSetAgain:假如断网时,不二次发送
            List<string> listNotShow = new List<string>() { "NotSetAgain" };
            var result = await UserCenterLogic.GetResultCodeByRequestHttps("App/BindGatewayToHome", true, bindGateway, listNotShow);
            if (result == "Error" || result == "ErrorEx")

            var result = UserCenterLogic.GetResultCodeByRequestHttps("App/BindGatewayToHome", true, bindGateway, new List<string> { "NotCheck" }, false);
            if (result == "Error")

            {

                return -1;

            }
@@ -406,7 +412,7 @@
        /// <returns></returns>

        public bool HomeIdIsEmpty(ZbGateway zbGateway)

        {

            return this.HomeIdIsEmpty(zbGateway.getGatewayBaseInfo.HomeId);

            return this.HomeIdIsEmpty(zbGateway.HomeId);

        }

        /// <summary>

@@ -432,7 +438,7 @@
        /// </summary>
        /// <param name="zbGateway">网关</param>
        /// <param name="btnMsg">消息控件</param>
        public async Task<int> ReBindNewGateway(ZbGateway zbGateway, NormalViewControl btnMsg = null)
        public int ReBindNewGateway(ZbGateway zbGateway, NormalViewControl btnMsg = null)
        {

            if (zbGateway == null)

            {

@@ -449,7 +455,7 @@
            }



            //设置住宅ID到网关

            bool flage2 = await this.SetHomeIdToGateway(zbGateway, Common.Config.Instance.HomeId);

            bool flage2 = this.SetHomeIdToGateway(zbGateway, Common.Config.Instance.HomeId, ShowErrorMode.YES);

            if (flage2 == false)

            {

                //向网关设置住宅ID失败

@@ -459,7 +465,7 @@
            }



            //更新云端数据库

            int flage1 = await this.SetGatewayIdToDataBase(zbGateway);

            int flage1 = this.SetGatewayIdToDataBase(zbGateway);

            //异常也不鸟它,0是特殊含义

            if (flage1 == 0)

            {

@@ -484,19 +490,23 @@
                    btnMsg.TextID = R.MyInternationalizationString.uGatewayDataIsChangingPleaseWhait;

                });

            }

            await Task.Delay(8000);

            System.Threading.Thread.Sleep(8000);



            //获取网关的信息

            var result = await zbGateway.GetZbGwInfoAsync();

            //检测网关返回的共通错误状态码

            string error = HdlCheckLogic.Current.CheckCommonErrorCode(result);

            if (error != null)

            ZbGatewayData.GetGwData result = null;

            int count = 5;

            while (count >= 0)

            {

                this.ShowTipMsg(error);

                return -1;

                result = this.GetGatewayInfo(zbGateway, true, ShowErrorMode.NO);

                if (result != null)

                {

                    break;

                }

                count--;

                //最多再等20秒

                System.Threading.Thread.Sleep(4000);

            }



            if (result == null || result.getGwData == null)

            if (result == null)

            {

                //获取网关信息失败

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

@@ -505,7 +515,7 @@
            }



            //是否已经存在

            string gwID = HdlGatewayLogic.Current.GetGatewayId(zbGateway);

            string gwID = zbGateway.GwId;

            bool isEsist = HdlGatewayLogic.Current.IsGatewayExist(zbGateway);
            if (isEsist == false)

            {

@@ -517,16 +527,20 @@


            //刷新的是缓存,不刷新真实物理网关

            this.dicGateway[gwID].GatewayOnlineFlage = zbGateway.GatewayOnlineFlage;

            this.dicGateway[gwID].getGwInfo = result.getGwData;

            this.dicGateway[gwID].getGatewayBaseInfo.GwName = result.getGwData.GwName;

            this.dicGateway[gwID].getGatewayBaseInfo.IpAddress = result.getGwData.GwIP;

            this.dicGateway[gwID].getGatewayBaseInfo.HomeId = Common.Config.Instance.HomeId;

            this.dicGateway[gwID].ReSave();

            //将网关的数据设置到本地缓存中

            this.SetGatewayDataToLocalMemmory(this.dicGateway[gwID], result);

            //顺便这个变量也设置一下

            this.SetGatewayDataToLocalMemmory(zbGateway, result, false);



            if (isEsist == false)

            {

                //添加备份

                HdlAutoBackupLogic.AddOrEditorFile(this.dicGateway[gwID].FilePath);

            }



            //添加网关的话,强制主页刷新

            UserView.UserPage.Instance.RefreshAllForm = true;



            return 1;
        }

@@ -539,48 +553,36 @@
        /// </summary>
        /// <param name="zbGateway">网关对象</param>
        /// <param name="gatewayName">网关名</param>
        public async Task<bool> ReName(ZbGateway zbGateway, string gatewayName)
        public bool ReName(ZbGateway zbGateway, string gatewayName)
        {

            ZbGateway realWay = null;

            if (this.GetRealGateway(ref realWay, zbGateway) == false)

            //只取32个byte

            var bytes = new byte[32];

            var reamarkGwBytes = System.Text.Encoding.UTF8.GetBytes(gatewayName);

            System.Array.Copy(reamarkGwBytes, 0, bytes, 0, 32 < reamarkGwBytes.Length ? 32 : reamarkGwBytes.Length);

            gatewayName = System.Text.Encoding.UTF8.GetString(bytes);



            var jObject = new Newtonsoft.Json.Linq.JObject { { "Cluster_ID", 0 }, { "Command", 91 } };

            var data = new Newtonsoft.Json.Linq.JObject { { "GwName", gatewayName } };

            jObject.Add("Data", data);

            var result = this.SendJobjectDataToGateway(zbGateway, "GwReName", jObject.ToString(), "GwReName_Respon");

            if (result.ErrorMsg != null)

            {

                //获取网关对象失败

                string msg = Language.StringByID(R.MyInternationalizationString.uGetGatewayTagartFail);
                this.ShowErrorMsg(msg);

                this.ShowTipMsg(result.ErrorMsg);

                return false;

            }



            var result = await realWay.GwReNameAsync(gatewayName);

            //检测网关返回的共通错误状态码

            string error = HdlCheckLogic.Current.CheckCommonErrorCode(result);

            if (error != null)

            {

                this.ShowErrorMsg(error);

                return false;

            }



            if (result == null)

            if (result.ErrorMsgDiv == 0)

            {

                //网关名称修改失败

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


                this.ShowErrorMsg(msg);
                return false;

            }

            //网关修改失败
            if (result.gwReNameData == null)
            {
                //网关名称修改失败
                string msg = Language.StringByID(R.MyInternationalizationString.uGatewayReNameFail);


                this.ShowErrorMsg(msg);
                //网关回复超时
                msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, null, "回复超时");

                this.ShowTipMsg(msg);
                return false;
            }



            //修改缓存

            string gwID = this.GetGatewayId(zbGateway);
            this.dicGateway[gwID].getGatewayBaseInfo.GwName = gatewayName;
            string gwID = zbGateway.GwId;
            this.dicGateway[gwID].GwName = gatewayName;
            this.dicGateway[gwID].ReSave();



            //添加自动备份

@@ -597,22 +599,19 @@
        /// 执行切换网关操作

        /// </summary>

        /// <param name="gatewayId"></param>

        public async Task<bool> DoSwitchGateway(string gatewayId)

        public bool DoSwitchGateway(string gatewayId)

        {

            var zbGateway = this.GetLocalGateway(gatewayId);

            if (this.CheckGatewayOnlineByFlag(zbGateway) == true)

            //重新获取在线网关的信息

            var result = this.GetOnlineGatewayInfo(gatewayId);

            if (result == false)

            {

                //重新获取在线网关的信息

                var result = await this.GetOnlineGatewayInfo(gatewayId);

                if (result == false)

                {

                    return false;

                }

                return false;

            }



            //切换网关,保存缓存

            this.SaveGatewayIdToLocation(gatewayId);

            //切换网关的话,主页需要重新刷新

            UserView.UserPage.Instance.RefreshForm = true;

            UserView.UserPage.Instance.RefreshAllForm = true;



            return true;

        }

@@ -622,7 +621,7 @@
        /// </summary>

        /// <param name="gatewayId"></param>

        /// <returns></returns>

        private async Task<bool> GetOnlineGatewayInfo(string gatewayId)

        private bool GetOnlineGatewayInfo(string gatewayId)

        {

            //显示进度条

            ProgressBar.Show();

@@ -633,9 +632,9 @@
            if (this.GetRealGateway(ref realWay, gatewayId) == true)

            {

                //重新设置住宅ID(这个应该是不经过APP,直接把网关恢复了出厂设置)

                if (this.HomeIdIsEmpty(realWay.getGatewayBaseInfo.HomeId) == true)

                if (this.HomeIdIsEmpty(realWay.HomeId) == true)

                {

                    int result2 = await this.ReBindNewGateway(realWay);

                    int result2 = this.ReBindNewGateway(realWay);

                    if (result2 == 0)

                    {

                        //出现未知错误,请稍后再试

@@ -657,7 +656,7 @@
            if (getGatewayInfo == true)

            {

                //获取网关信息

                var info = await this.GetGatewayNewInfoAsync(realWay);

                var info = this.GetGatewayInfo(realWay, false);

                if (info == null)

                {

                    //关闭进度条

@@ -665,9 +664,14 @@
                    return false;

                }

            }

            //刷新全部场景

            if (this.IsMainGateway(realWay) == 1)

            {

                HdlSceneLogic.Current.RefreshSceneUIList(false);

            }



            //获取全部设备

            int result = LocalDevice.Current.SetDeviceToMemmoryByGateway(realWay);

            int result = LocalDevice.Current.SetDeviceToMemmoryByGateway(realWay, false);

            //关闭进度条

            ProgressBar.Close();

            if (result == -1)

@@ -684,8 +688,7 @@
        public void SaveGatewayIdToLocation(string gatewayId)

        {

            GatewayResourse.AppOldSelectGatewayId = gatewayId;

            byte[] data = System.Text.Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(GatewayResourse.AppOldSelectGatewayId));

            Global.WriteFileToDirectoryByBytes(DirNameResourse.LocalMemoryDirectory, DirNameResourse.AppOldSelectGatewayFile, data);

            HdlFileLogic.Current.SaveFileContent(DirNameResourse.AppOldSelectGatewayFile, GatewayResourse.AppOldSelectGatewayId);

        }



        #endregion
@@ -695,47 +698,30 @@
        /// <summary>
        /// 删除网关，包括云端和本地(失败时不会显示信息，并且会返回true)
        /// </summary>
        /// <param name="zbGateway"></param>
        public async Task<bool> DeleteGateway(ZbGateway zbGateway)
        {
            string gwID = this.GetGatewayId(zbGateway);
            //移除本地网关信息
            return await this.DeleteGateway(gwID);
        }

        /// <summary>
        /// 删除网关，包括云端和本地(失败时不会显示信息，并且会返回true)
        /// </summary>
        /// <param name="zbGatewayID"></param>
        public async Task<bool> DeleteGateway(string zbGatewayID)
        public bool DeleteGateway(string zbGatewayID)
        {

            ZbGateway realWay = null;

            bool hadReal = this.GetRealGateway(ref realWay, zbGatewayID);



            //暂不支持分享

            if (hadReal == true && realWay.GatewayOnlineFlage == true)

            this.GetRealGateway(ref realWay, zbGatewayID);

            //清空网关的住宅ID 网关解绑失败  不理它,因为网关可以按按键强制搜索得到

            if (realWay != null)

            {

                //清空网关的住宅ID

                bool result = await this.SetHomeIdToGateway(realWay, string.Empty);

                if (result == false)

                {

                    //网关解绑失败  不理它,因为网关可以按按键强制搜索得到

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

                    //this.ShowErrorMsg(msg);

                    //return false;

                }

                this.SetHomeIdToGateway(realWay, string.Empty, ShowErrorMode.NO);

            }



            //删除云端的网关

            await this.DeleteDataBaseGateway(zbGatewayID);

            this.DeleteDataBaseGateway(zbGatewayID);



            //删除网关文件
            this.DeleteGatewayFile(zbGatewayID);

            //移除
            ZbGateway.GateWayList.RemoveAll((obj) => this.GetGatewayId(obj) == zbGatewayID);
            ZbGateway.GateWayList.RemoveAll((obj) => obj.GwId == zbGatewayID);
            //断开mqtt连接
            realWay.DisConnectLocalMqttClient("GD");
            if (realWay != null)

            {

                realWay.DisConnectLocalMqttClient("GD");

            }

            return true;
        }

@@ -830,7 +816,7 @@
            //刷新缓存的在线标识

            foreach (var zbway in listRealWay)

            {

                string gwID = this.GetGatewayId(zbway);

                string gwID = zbway.GwId;

                if (this.dicGateway.ContainsKey(gwID) == false)

                {

                    continue;

@@ -872,11 +858,11 @@
            }

            foreach (var way in listGateway)

            {

                if (way == null || way.getGatewayBaseInfo == null)

                if (way == null)

                {

                    continue;

                }

                string strId = this.GetGatewayId(way);

                string strId = way.GwId;

                if (dicDbGateway.ContainsKey(strId) == true) //如果云端上面有这个网关

                {

                    way.GatewayOnlineFlage = dicDbGateway[strId].MqttOnlineStatus;

@@ -896,7 +882,7 @@
                return false;

            }

            //使用缓存的，因为刷新在线状态的时候，刷新的就是缓存，而不是真实物理网关

            string gwID = this.GetGatewayId(zbGateway);

            string gwID = zbGateway.GwId;

            if (this.dicGateway.ContainsKey(gwID) == true)

            {

                return this.dicGateway[gwID].GatewayOnlineFlage;

@@ -922,12 +908,12 @@
            List<ZbGateway> newlist = new List<ZbGateway>();

            foreach (var way in list)

            {

                if (Config.Instance.HomeId != way.getGatewayBaseInfo.HomeId)

                if (Config.Instance.HomeId != way.HomeId)

                {

                    //如果不是当前住宅

                    continue;

                }

                string gwID = this.GetGatewayId(way);

                string gwID = way.GwId;

                if (this.dicGateway.ContainsKey(gwID) == false)

                {

                    //如果本地并没有这个网关

@@ -976,7 +962,7 @@
        public List<string> GetAllGatewayFile()

        {

            List<string> list = new List<string>();

            List<string> listFile = Global.FileListByHomeId();

            List<string> listFile = HdlFileLogic.Current.GetRootPathListFile();

            foreach (string file in listFile)

            {

                //只获取网关设备

@@ -997,11 +983,11 @@
        /// <returns></returns>
        public bool GetRealGateway(ref ZbGateway zbGateway, ZbGateway tagartWay)

        {

            if (tagartWay == null || tagartWay.getGatewayBaseInfo == null)

            if (tagartWay == null)

            {

                return false;

            }

            return this.GetRealGateway(ref zbGateway, this.GetGatewayId(tagartWay));

            return this.GetRealGateway(ref zbGateway, tagartWay.GwId);

        }

        /// <summary>

@@ -1014,14 +1000,14 @@
        {

            var realWay = ZbGateway.GateWayList.Find((obj) =>

            {

                return this.GetGatewayId(obj) == gwId;

                return obj.GwId == gwId;

            });

            if (realWay == null)

            {

                //如果网关对象丢失了,则创建个新的

                realWay = new ZbGateway { IsVirtual = true, };
                realWay.getGatewayBaseInfo.gwID = gwId;
                realWay.getGatewayBaseInfo.HomeId = Shared.Common.Config.Instance.HomeId;
                realWay.GwId = gwId;
                realWay.HomeId = Shared.Common.Config.Instance.HomeId;
                ZbGateway.GateWayList.Add(realWay);
            }

            zbGateway = realWay;

@@ -1292,77 +1278,21 @@


        #endregion



        #region ■ 获取网关GwInfo里面的属性___________



        /// <summary>

        /// 获取网关GwInfo里面的属性

        /// </summary>

        /// <param name="zbGateway">网关对象</param>

        /// <param name="attributeName">getGwInfo里面属性的名字</param>

        /// <param name="defult">如果获取不到时，设置的默认值</param>

        /// <returns></returns>

        public object GetGwInfoAttribute(ZbGateway zbGateway, string attributeName, string defult = "")

        {

            string gwID = this.GetGatewayId(zbGateway);

            var localWay = this.GetLocalGateway(gwID);



            object objValue = null;

            if (localWay == null || localWay.getGwInfo == null)

            {

                //本地没有记录有这个东西,则直接返回参数的数据

                if (zbGateway.getGwInfo != null)

                {

                    objValue = zbGateway.getGwInfo.GetType().InvokeMember(attributeName, System.Reflection.BindingFlags.GetField, null, zbGateway.getGwInfo, null);

                }

                else

                {

                    return defult;

                }

            }

            else

            {

                //获取本地的属性 
                objValue = localWay.getGwInfo.GetType().InvokeMember(attributeName, System.Reflection.BindingFlags.GetField, null, localWay.getGwInfo, null);

            }



            if (objValue == null)

            {

                return defult;

            }

            return objValue;

        }



        #endregion



        #region ■ 获取网关ID(有特殊意义)_____________



        /// <summary>

        /// 获取网关对象里面的网关ID(封装这个方法有特殊意义)

        /// </summary>

        /// <param name="zbGateway">网关对象</param>

        /// <returns></returns>

        public string GetGatewayId(ZbGateway zbGateway)

        {

            //这个东西不会为空

            return zbGateway.getGatewayBaseInfo.gwID;

        }



        #endregion



        #region ■ 获取名称___________________________



        /// <summary>

        /// 获取网关加特效的名称

        /// </summary>

        /// <param name="zbGateway"></param>

        /// <param name="mode"></param>

        /// <returns></returns>

        public string GetGatewayName(ZbGateway zbGateway, GetNameMode mode = GetNameMode.SpecialGateway)

        public string GetGatewayName(ZbGateway zbGateway)

        {

            string gwId = this.GetGatewayId(zbGateway);

            if (zbGateway == null) { return string.Empty; }



            string gwId = zbGateway.GwId;

            if (this.dicGateway.ContainsKey(gwId) == false)

            {

                return zbGateway.getGatewayBaseInfo.GwName == null ? string.Empty : zbGateway.getGatewayBaseInfo.GwName;

                return zbGateway.GwName;

            }

            var localWay = this.dicGateway[gwId];



@@ -1372,14 +1302,10 @@
                return name;

            }



            if (mode == GetNameMode.SpecialGateway && localWay.getGwInfo != null)

            var nameContent = LocalDevice.Current.GetDeviceModelIdNameInfo(localWay.LinuxImageType.ToString());

            if (nameContent != null)

            {

                string keyName = Common.LocalDevice.deviceModelIdName + this.GetGwInfoAttribute(localWay, "LinuxImageType").ToString();

                if (LocalDevice.Current.dicDeviceAllNameID.ContainsKey(keyName) == true)

                {

                    //没有名称时，则使用R文件里面设置的默认设备名称

                    return Language.StringByID(LocalDevice.Current.dicDeviceAllNameID[keyName] + 20000);

                }

                return nameContent.A备注名字;

            }



            return string.Empty;

@@ -1396,7 +1322,7 @@
            {

                return string.Empty;

            }

            return zbGateway.getGatewayBaseInfo.GwName;

            return zbGateway.GwName;

        }



        /// <summary>

@@ -1410,35 +1336,35 @@
            //初始值:无法识别的网关设备

            button.TextID = R.MyInternationalizationString.uUnDistinguishTheGatewayDevice;



            string gwId = this.GetGatewayId(zbGateway);

            if (this.dicGateway.ContainsKey(gwId) == false || this.dicGateway[gwId].getGwInfo == null)

            string gwId = zbGateway.GwId;

            if (this.dicGateway.ContainsKey(gwId) == false)

            {

                //如果这个网关没有信息，则从新获取

                if (zbGateway.getGwInfo != null && zbGateway.getGwInfo.LinuxImageType != 0)

                if (zbGateway.LinuxImageType != -1)

                {

                    string keyName = Common.LocalDevice.deviceModelIdName + zbGateway.getGwInfo.LinuxImageType;

                    if (Common.LocalDevice.Current.dicDeviceAllNameID.ContainsKey(keyName) == true)

                    var nameContent = LocalDevice.Current.GetDeviceModelIdNameInfo(zbGateway.LinuxImageType.ToString());

                    if (nameContent != null)

                    {

                        //使用R文件里面设置的东西

                        button.TextID = LocalDevice.Current.dicDeviceAllNameID[keyName];

                        button.Text = nameContent.A官方名字;

                    }

                }

                else

                {

                    //给一个线程去获取它的镜像类型

                    HdlThreadLogic.Current.RunThread(async () =>

                    HdlThreadLogic.Current.RunThread(() =>

                    {

                        var result = await this.GetGatewayNewInfoAsync(zbGateway, ShowErrorMode.NO);

                        var result = this.GetGatewayInfo(zbGateway, false, ShowErrorMode.NO);

                        if (result != null)

                        {

                            zbGateway.getGwInfo = result;

                            //将网关的数据设置到本地缓存中

                            this.SetGatewayDataToLocalMemmory(zbGateway, result, false);



                            HdlThreadLogic.Current.RunMain(() =>

                            {

                                string keyName = Common.LocalDevice.deviceModelIdName + zbGateway.getGwInfo.LinuxImageType;

                                if (Common.LocalDevice.Current.dicDeviceAllNameID.ContainsKey(keyName) == true)

                                var nameContent = LocalDevice.Current.GetDeviceModelIdNameInfo(zbGateway.LinuxImageType.ToString());

                                if (nameContent != null)

                                {

                                    //使用R文件里面设置的东西

                                    button.TextID = LocalDevice.Current.dicDeviceAllNameID[keyName];

                                    button.Text = nameContent.A官方名字;

                                }

                            });

                        }

@@ -1447,11 +1373,10 @@
            }

            else

            {

                string keyName = Common.LocalDevice.deviceModelIdName + this.dicGateway[gwId].getGwInfo.LinuxImageType;

                if (Common.LocalDevice.Current.dicDeviceAllNameID.ContainsKey(keyName) == true)

                var nameContent = LocalDevice.Current.GetDeviceModelIdNameInfo(zbGateway.LinuxImageType.ToString());

                if (nameContent != null)

                {

                    //使用R文件里面设置的东西

                    button.TextID = Common.LocalDevice.Current.dicDeviceAllNameID[keyName];

                    button.Text = nameContent.A官方名字;

                }

            }

        }

@@ -1464,34 +1389,16 @@
        /// 获取网关信息(版本信息,镜像类型,基本信息等。只刷新本地网关的缓存)

        /// </summary>

        /// <param name="zbGateway"></param>

        /// <param name="useLocalConnect">是否强制使用本地连接发送</param>

        /// <param name="mode"></param>

        /// <returns></returns>

        public async Task<ZbGatewayData.GetGwData> GetGatewayNewInfoAsync(ZbGateway zbGateway, ShowErrorMode mode = ShowErrorMode.YES)

        public ZbGatewayData.GetGwData GetGatewayInfo(ZbGateway zbGateway, bool useLocalConnect, ShowErrorMode mode = ShowErrorMode.YES)

        {

            ZbGateway realWay = null;

            if (this.GetRealGateway(ref realWay, zbGateway) == false)

            {

                if (mode == ShowErrorMode.YES)

                {

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

                    this.ShowTipMsg(msg);

                }

                return null;

            }

            //获取网关版本信息

            var imageTypeResult = await realWay.GetZbGwInfoAsync();

            //检测网关返回的共通错误状态码

            string error = HdlCheckLogic.Current.CheckCommonErrorCode(imageTypeResult);

            if (error != null)

            {

                if (mode == ShowErrorMode.YES)

                {

                    this.ShowTipMsg(error);

                }

                return null;

            }

            var jObject = new Newtonsoft.Json.Linq.JObject { { "Cluster_ID", 0 }, { "Command", 95 } };

            var result = this.SendJobjectDataToGateway(zbGateway, "GetZbGwInfo", jObject.ToString(), "GetZbGwInfo_Respon", 5, useLocalConnect);



            if (imageTypeResult == null || imageTypeResult.getGwData == null)

            if (result.ErrorMsgDiv != 1)

            {

                if (mode == ShowErrorMode.YES)

                {

@@ -1503,43 +1410,46 @@
                }

                return null;

            }



            string gwID = this.GetGatewayId(zbGateway);

            var getGwInfo = Newtonsoft.Json.JsonConvert.DeserializeObject<ZbGatewayData.GetGwData>(result.ReceiptData);

            string gwID = zbGateway.GwId;

            if (this.dicGateway.ContainsKey(gwID) == true)

            {

                //刷新缓存

                ZbGateway localWay = this.dicGateway[gwID];

                localWay.getGwInfo = imageTypeResult.getGwData;

                localWay.getGatewayBaseInfo.GwName = imageTypeResult.getGwData.GwName;

                localWay.getGatewayBaseInfo.IpAddress = imageTypeResult.getGwData.GwIP;



                localWay.ReSave();

                //将网关的数据设置到本地缓存中

                this.SetGatewayDataToLocalMemmory(localWay, getGwInfo);

            }

            //顺便这个变量也设置一下

            this.SetGatewayDataToLocalMemmory(zbGateway, getGwInfo, false);



            return imageTypeResult.getGwData;

            return getGwInfo;

        }



        /// <summary>

        /// 获取网关信息,非异步,会等待(版本信息,镜像类型,基本信息等。只刷新本地网关的缓存)

        /// 将网关的数据设置到本地缓存中

        /// </summary>

        /// <param name="zbGateway"></param>

        /// <param name="mode"></param>

        /// <returns></returns>

        public ZbGatewayData.GetGwData GetGatewayNewInfo(ZbGateway zbGateway, ShowErrorMode mode = ShowErrorMode.YES)

        /// <param name="localWay">本地网关</param>

        /// <param name="data">网关数据</param>

        /// <param name="saveFile">是否保存文件</param>

        private void SetGatewayDataToLocalMemmory(ZbGateway localWay, ZbGatewayData.GetGwData data, bool saveFile = true)

        {

            bool bolBreak = false;

            ZbGatewayData.GetGwData result = null;

            HdlThreadLogic.Current.RunThread(async () =>

            localWay.GwId = data.GwId;

            localWay.GwName = data.GwName;

            localWay.GwSerialNum = data.GWSN;

            localWay.IsMainGateWay = data.IsDominant == 1 ? true : false;

            localWay.GwIP = data.GwIP;

            localWay.LinuxImageType = data.LinuxImageType;

            localWay.LinuxHardVersion = data.LinuxHWVersion;

            localWay.LinuxFirmwareVersion = data.LinuxFWVersion;

            localWay.CoordinatorHardVersion = data.ZbHWVersion;

            localWay.CoordinatorFirmwareVersion = data.ZbFWVersion;

            localWay.CoordinatorImageId = data.ZbImageType;

            localWay.DriveCodeList = data.DriveCodeList;

            localWay.GwVersionDate = data.AppVersion;

            if (saveFile == true)

            {

                result = await this.GetGatewayNewInfoAsync(zbGateway, mode);

                bolBreak = true;

            });



            while (bolBreak == false)

            {

                System.Threading.Thread.Sleep(500);

                localWay.ReSave();

            }

            return result;

        }



        #endregion

@@ -1553,8 +1463,7 @@
        /// <returns></returns>

        public Room GetRoomByGateway(ZbGateway zbGateway)

        {

            var gatewayId = this.GetGatewayId(zbGateway);

            return this.GetRoomByGateway(gatewayId);

            return this.GetRoomByGateway(zbGateway.GwId);

        }



        /// <summary>

@@ -1575,12 +1484,11 @@
        /// <summary>

        /// 变更网关房间

        /// </summary>

        /// <param name="zbGateway">网关对象</param>

        /// <param name="gwId">网关Id</param>

        /// <param name="roomId">房间ID</param>

        public void ChangedGatewayRoom(ZbGateway zbGateway, string roomId)

        public void ChangedGatewayRoom(string gwId, string roomId)

        {

            var gatewayId = this.GetGatewayId(zbGateway);

            var localGateway = this.GetLocalGateway(gatewayId);

            var localGateway = this.GetLocalGateway(gwId);

            if (localGateway != null)

            {

                localGateway.RoomId = roomId;

@@ -1592,24 +1500,39 @@


        #endregion



        #region ■ 清空真实网关列表___________________

        #region ■ 清空真实网关链接___________________



        /// <summary>

        /// 清空全部的真实物理网关对象

        /// 清空全部的真实物理网关的链接

        /// </summary>

        public void ClearAllRealGateway()

        /// <param name="roadGateway">是否加载本地的网关对象到真实列表中</param>

        public void ClearAllRealGatewayConection(bool roadGateway)

        {

            //因为那一瞬间，有可能mqtt会加回来,所以先加缓存

            var list = new List<ZbGateway>();

            list.AddRange(ZbGateway.GateWayList);

            //然后清空掉

            ZbGateway.GateWayList.Clear();

            //最后再断开mqtt连接

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

            //断开mqtt连接(即使保存在内存当中也没问题,因为如果广播不到,则它不会建立链接)

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

            {

                list[i].DisConnectLocalMqttClient("G");

                ZbGateway.GateWayList[i].DisConnectLocalMqttClient("G");

            }

            list.Clear();

            //加载本地网关对象

            if (roadGateway == true)

            {

                List<string> listFile = this.GetAllGatewayFile();

                //反序列化添加到缓存

                foreach (string file in listFile)

                {

                    //从文件中反序列化出网关对象

                    var gateway = this.GetGatewayFromFile(file);

                    if (gateway == null)

                    {

                        continue;

                    }

                    var tempWay = ZbGateway.GateWayList.Find(obj => (obj != null) && (obj.GwId == gateway.GwId));
                    if (tempWay == null)
                    {
                        ZbGateway.GateWayList.Add(gateway);
                    }

                }

            }

        }



        #endregion

@@ -1622,74 +1545,80 @@
        /// <param name="zbGateway">网关对象</param>

        /// <param name="mode">错误时，是否显示错误</param>

        /// <returns></returns>

        public async Task<List<FirmwareVersionInfo>> GetGatewayAllNewVersion(ZbGateway zbGateway, ShowErrorMode mode = ShowErrorMode.YES)

        public List<FirmwareVersionInfo> GetGatewayAllNewVersion(ZbGateway zbGateway, ShowErrorMode mode = ShowErrorMode.YES)

        {

            //如果是展示模板,或者是虚拟住宅的话,没有什么新版本的说法

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

            {

                return new List<FirmwareVersionInfo> { null, null, null };

            }

            //获取网关版本信息

            var result = await HdlGatewayLogic.Current.GetGatewayNewInfoAsync(zbGateway, mode);

            var result = this.GetGatewayInfo(zbGateway, false, mode);

            if (result == null)

            {

                return null;

            }

            //使用本地缓存对象

            string gwID = this.GetGatewayId(zbGateway);

            var localWay = this.GetLocalGateway(gwID);

            var localWay = this.GetLocalGateway(zbGateway.GwId);

            if (localWay == null)

            {

                return null;

            }

            //添加网关的升级固件(成不成功都无所谓)
            var flage = await HdlFirmwareUpdateLogic.AddFirmwareVersionInfo(FirmwareLevelType.Linux,

                this.GetGwInfoAttribute(localWay, "LinuxHWVersion").ToString(),

                this.GetGwInfoAttribute(localWay, "LinuxImageType").ToString());

            var flage = HdlFirmwareUpdateLogic.AddFirmwareVersionInfo(FirmwareLevelType.Linux,

                localWay.LinuxHardVersion.ToString(),

                localWay.LinuxImageType.ToString());



            //添加协调器的升级固件(成不成功都无所谓)

            flage = await HdlFirmwareUpdateLogic.AddFirmwareVersionInfo(FirmwareLevelType.Coordinator,

                this.GetGwInfoAttribute(localWay, "ZbHWVersion").ToString(),

                this.GetGwInfoAttribute(localWay, "ZbImageType").ToString());

            //添加协调器的升级固件(成不成功都无所谓) 必须能够联网才行

            if (flage == 1)

            {

                //没网的时候不再处理

                HdlFirmwareUpdateLogic.AddFirmwareVersionInfo(FirmwareLevelType.A协调器,

                    localWay.CoordinatorHardVersion.ToString(),

                    localWay.CoordinatorImageId.ToString());

            }



            //网关的版本

            var gatewayFirmware = HdlFirmwareUpdateLogic.GetFirmwareMostVersionInfo(FirmwareLevelType.Linux,

                this.GetGwInfoAttribute(localWay, "LinuxHWVersion").ToString(),

                this.GetGwInfoAttribute(localWay, "LinuxImageType").ToString(),

                Convert.ToInt32(this.GetGwInfoAttribute(localWay, "LinuxFWVersion")));

                localWay.LinuxHardVersion.ToString(),

                localWay.LinuxImageType.ToString(),

                localWay.LinuxFirmwareVersion);



            //协调器版本

            var coordinatorFirmware = HdlFirmwareUpdateLogic.GetFirmwareMostVersionInfo(FirmwareLevelType.Coordinator,

                this.GetGwInfoAttribute(localWay, "ZbHWVersion").ToString(),

                this.GetGwInfoAttribute(localWay, "ZbImageType").ToString(),

                Convert.ToInt32(this.GetGwInfoAttribute(localWay, "ZbFWVersion")));

            var coordinatorFirmware = HdlFirmwareUpdateLogic.GetFirmwareMostVersionInfo(FirmwareLevelType.A协调器,

                localWay.CoordinatorHardVersion.ToString(),

                localWay.CoordinatorImageId.ToString(),

                localWay.CoordinatorFirmwareVersion);



            var list = new List<FirmwareVersionInfo>();

            list.Add(gatewayFirmware);

            list.Add(coordinatorFirmware);



            //这个网关需要有虚拟驱动这个东西才行

            string linImage = this.GetGwInfoAttribute(localWay, "LinuxImageType").ToString();

            if (linImage != "6")

            if (localWay.LinuxImageType != 6)

            {

                //虚拟驱动号

                var listvVode = await HdlGatewayLogic.Current.GetListVDDriveCode(localWay);

                if (listvVode != null && listvVode.Count > 0)

                foreach (var data in localWay.DriveCodeList)

                {

                    foreach (var data in listvVode)

                    //添加虚拟驱动的升级固件(成不成功都无所谓) 必须能够联网才行

                    if (flage == 1)

                    {

                        //添加虚拟驱动的升级固件(成不成功都无所谓)

                        flage = await HdlFirmwareUpdateLogic.AddFirmwareVersionInfo(FirmwareLevelType.VirtualDevice,

                            data.DriveHwVersion.ToString(),

                            data.DriveImageType.ToString());

                        HdlFirmwareUpdateLogic.AddFirmwareVersionInfo(FirmwareLevelType.A虚拟驱动,

                           data.DriveHwVersion.ToString(),

                           data.DriveImageType.ToString());

                    }



                        //虚拟驱动

                        var virtualFirmware = HdlFirmwareUpdateLogic.GetFirmwareMostVersionInfo(FirmwareLevelType.VirtualDevice,

                            data.DriveHwVersion.ToString(),

                            data.DriveImageType.ToString(),

                            data.DriveFwVersion);

                    //虚拟驱动

                    var virtualFirmware = HdlFirmwareUpdateLogic.GetFirmwareMostVersionInfo(FirmwareLevelType.A虚拟驱动,

                        data.DriveHwVersion.ToString(),

                        data.DriveImageType.ToString(),

                        data.DriveFwVersion);



                        if (virtualFirmware != null)

                        {

                            virtualFirmware.VirtualCode = data.DriveCode;

                            list.Add(virtualFirmware);

                        }

                    if (virtualFirmware != null)

                    {

                        virtualFirmware.VirtualCode = data.DriveCode;

                        list.Add(virtualFirmware);

                    }

                }

            }

@@ -1706,31 +1635,27 @@
        /// </summary>

        /// <param name="zbGateway"></param>

        /// <returns></returns>

        public async Task<List<ZbGatewayData.DriveCodeObj>> GetListVDDriveCode(ZbGateway zbGateway)

        public List<ZbGatewayData.DriveCodeObj> GetListVDDriveCode(ZbGateway zbGateway)

        {

            ZbGateway zbTemp = null;

            if (this.GetRealGateway(ref zbTemp, zbGateway) == false)

            //如果是展示模板,或者是虚拟住宅的话,直接取缓存

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

            {

                //取本地对象

                var localgw = this.GetLocalGateway(zbGateway.GwId);

                return localgw != null ? zbGateway.DriveCodeList : zbGateway.DriveCodeList;

            }

            var jObject = new Newtonsoft.Json.Linq.JObject { { "Cluster_ID", 0 }, { "Command", 505 } };

            var result = this.SendJobjectDataToGateway(zbGateway, "VirtualDrive/CatDriveCode", jObject.ToString(), "VirtualDrive/CatDriveCode_Respon");

            if (result.ErrorMsg != null)

            {

                this.ShowTipMsg(result.ErrorMsg);

            }

            if (result.ErrorMsgDiv == 0)

            {

                return null;

            }

            var result = await zbTemp.CheckVDDriveCodeAsync();

            //检测网关返回的共通错误状态码

            string error = HdlCheckLogic.Current.CheckCommonErrorCode(result);

            if (error != null)

            {

                this.ShowTipMsg(error);

                return null;

            }



            if (result == null || result.vDriveDriveCodeResponData == null || result.vDriveDriveCodeResponData.DriveCodeList == null)

            {

                return null;

            }

            if (result.vDriveDriveCodeResponData.DriveCodeList.Count > 0)

            {

                return result.vDriveDriveCodeResponData.DriveCodeList;

            }

            return null;

            var dataInfo = JsonConvert.DeserializeObject<ZbGatewayData.VDriveDriveCodeResponData>(result.ReceiptData);

            return dataInfo.DriveCodeList;

        }



        #endregion

@@ -1744,8 +1669,7 @@
        /// <returns></returns>

        public int IsMainGateway(ZbGateway zbGateway)

        {

            string gwID = this.GetGatewayId(zbGateway);

            return this.IsMainGateway(gwID);

            return this.IsMainGateway(zbGateway.GwId);

        }



        /// <summary>

@@ -1755,12 +1679,16 @@
        /// <returns></returns>

        public int IsMainGateway(string waiID)

        {

            ZbGateway zbGateway = null;

            if (this.GetRealGateway(ref zbGateway, waiID) == false)

            var realWay = ZbGateway.GateWayList.Find((obj) =>

            {

                return obj.GwId == waiID;

            });

            //虚拟网关也返回 0

            if (realWay == null || realWay.IsVirtual == true)

            {

                return 0;

            }

            return zbGateway.IsMainGateWay == true ? 1 : 2;

            return realWay.IsMainGateWay == true ? 1 : 2;

        }



        #endregion

@@ -1774,23 +1702,23 @@
        /// <param name="zbGateway"></param>

        public void SetRealGatewayPictrue(Button button, ZbGateway zbGateway)

        {

            string gwID = this.GetGatewayId(zbGateway);

            var localWay = this.GetLocalGateway(gwID);

            if (localWay == null || localWay.getGwInfo == null)

            var localWay = this.GetLocalGateway(zbGateway.GwId);

            if (localWay == null)

            {

                if (zbGateway.getGwInfo != null && zbGateway.getGwInfo.LinuxImageType != 0)

                if (zbGateway.LinuxImageType != -1)

                {

                    button.UnSelectedImagePath = "Gateway/RealGateway" + zbGateway.getGwInfo.LinuxImageType + ".png";

                    button.UnSelectedImagePath = "Gateway/RealGateway" + zbGateway.LinuxImageType + ".png";

                }

                else

                {

                    //给一个线程去获取它的镜像类型

                    HdlThreadLogic.Current.RunThread(async () =>

                    HdlThreadLogic.Current.RunThread(() =>

                    {

                        var result = await this.GetGatewayNewInfoAsync(zbGateway, ShowErrorMode.NO);

                        var result = this.GetGatewayInfo(zbGateway, true, ShowErrorMode.NO);

                        if (result != null)

                        {

                            zbGateway.getGwInfo = result;

                            //将网关的数据设置到本地缓存中

                            this.SetGatewayDataToLocalMemmory(zbGateway, result, false);

                            HdlThreadLogic.Current.RunMain(() =>

                            {

                                button.UnSelectedImagePath = "Gateway/RealGateway" + result.LinuxImageType + ".png";

@@ -1801,7 +1729,7 @@
            }

            else

            {

                button.UnSelectedImagePath = "Gateway/RealGateway" + localWay.getGwInfo.LinuxImageType + ".png";

                button.UnSelectedImagePath = "Gateway/RealGateway" + localWay.LinuxImageType + ".png";

            }

        }



@@ -1812,23 +1740,23 @@
        /// <param name="zbGateway"></param>

        public void SetGatewayIcon(Button button, ZbGateway zbGateway)

        {

            string gwID = this.GetGatewayId(zbGateway);

            var localWay = this.GetLocalGateway(gwID);

            if (localWay == null || localWay.getGwInfo == null)

            var localWay = this.GetLocalGateway(zbGateway.GwId);

            if (localWay == null)

            {

                if (zbGateway.getGwInfo != null && zbGateway.getGwInfo.LinuxImageType != 0)

                if (zbGateway.LinuxImageType != -1)

                {

                    button.UnSelectedImagePath = "Gateway/GatewayIcon" + zbGateway.getGwInfo.LinuxImageType + ".png";

                    button.UnSelectedImagePath = "Gateway/GatewayIcon" + zbGateway.LinuxImageType + ".png";

                }

                else

                {

                    //给一个线程去获取它的镜像类型

                    HdlThreadLogic.Current.RunThread(async () =>

                    HdlThreadLogic.Current.RunThread(() =>

                    {

                        var result = await this.GetGatewayNewInfoAsync(zbGateway, ShowErrorMode.NO);

                        var result = this.GetGatewayInfo(zbGateway, true, ShowErrorMode.NO);

                        if (result != null)

                        {

                            zbGateway.getGwInfo = result;

                            //将网关的数据设置到本地缓存中

                            this.SetGatewayDataToLocalMemmory(zbGateway, result, false);

                            HdlThreadLogic.Current.RunMain(() =>

                            {

                                button.UnSelectedImagePath = "Gateway/GatewayIcon" + result.LinuxImageType + ".png";

@@ -1839,7 +1767,7 @@
            }

            else

            {

                button.UnSelectedImagePath = "Gateway/GatewayIcon" + localWay.getGwInfo.LinuxImageType + ".png";

                button.UnSelectedImagePath = "Gateway/GatewayIcon" + localWay.LinuxImageType + ".png";

            }

        }



@@ -1854,8 +1782,7 @@
        /// <returns></returns>

        public bool IsGatewayExist(ZbGateway zbGateway)

        {

            string gwID = this.GetGatewayId(zbGateway);

            return this.IsGatewayExist(gwID);

            return this.IsGatewayExist(zbGateway.GwId);

        }



        /// <summary>

@@ -1917,9 +1844,9 @@
            }



            bool canBreak = false;

            HdlThreadLogic.Current.RunThread(async () =>

            HdlThreadLogic.Current.RunThread(() =>

            {

                List<string> list = new List<string>() { "NotSetAgain", "NotCheck" };

                List<string> list = new List<string>() { "NotCheck" };



                //设置访问接口的参数

                var pra = new GetGatewayPra();

@@ -1928,7 +1855,7 @@
                //获取控制主人账号的Token

                pra.ReqDto.LoginAccessToken = UserCenterLogic.GetConnectMainToken();



                var result = await UserCenterLogic.GetResponseDataByRequestHttps("App/GetSingleHomeGatewayPagger", true, pra, list);

                var result = UserCenterLogic.GetResponseDataByRequestHttps("App/GetSingleHomeGatewayPagger", true, pra, list, false);

                if (string.IsNullOrEmpty(result) == true)

                {

                    canBreak = true;

@@ -1984,6 +1911,11 @@
                    this.ShowTipMsg(msg);

                }

                return false;

            }

            if (((decimal)Longitude) == 0 && ((decimal)Latitude) == 0)

            {

                //没有配置过经纬度

                return true;

            }



            int result = -1;

@@ -2051,16 +1983,16 @@
        /// 解绑云端绑定的网关

        /// </summary>

        /// <param name="strWayId"></param>
        public async Task<bool> DeleteDataBaseGateway(string strWayId)

        public bool DeleteDataBaseGateway(string strWayId)

        {

            var Pra = new DeleteGatewayPra();

            Pra.BindGateways.Add(strWayId);

            //获取控制主人账号的Token

            Pra.LoginAccessToken = UserCenterLogic.GetConnectMainToken();



            List<string> listNotShowError = new List<string>() { "NoExist", "NoBind", "NoRecord", "NotSetAgain" };

            List<string> listNotShowError = new List<string>() { "NoExist", "NoBind", "NoRecord", "NotCheck" };



            bool result = await UserCenterLogic.GetResultStatuByRequestHttps("App/ReleaseGatewayToHome", true, Pra, listNotShowError);

            bool result = UserCenterLogic.GetResultStatuByRequestHttps("App/ReleaseGatewayToHome", true, Pra, listNotShowError, false);

            if (result == false)

            {

                return false;

@@ -2078,15 +2010,13 @@
        /// <param name="zbGateway"></param>

        public void BackupGatewayIdOnNotNetwork(ZbGateway zbGateway)

        {

            var strId = HdlGatewayLogic.Current.GetGatewayId(zbGateway);

            var strId = zbGateway.GwId;

            if (listBackupGwId.Contains(strId) == false)

            {

                listBackupGwId.Add(strId);



                //备份

                var strData = Newtonsoft.Json.JsonConvert.SerializeObject(listBackupGwId);

                var byteData = System.Text.Encoding.UTF8.GetBytes(strData);

                Global.WriteFileToDirectoryByBytes(DirNameResourse.LocalMemoryDirectory, DirNameResourse.BackupGatewayIdFile, byteData);

                HdlFileLogic.Current.SaveFileContent(DirNameResourse.BackupGatewayIdFile, listBackupGwId);

            }

        }



@@ -2095,9 +2025,9 @@
        /// </summary>

        public void ResetComandToBindBackupGateway()

        {

            HdlThreadLogic.Current.RunThread(async () =>

            HdlThreadLogic.Current.RunThread(() =>

            {

                var fileData = Global.ReadFileByDirectory(DirNameResourse.LocalMemoryDirectory, DirNameResourse.BackupGatewayIdFile);

                var fileData = HdlFileLogic.Current.ReadFileByteContent(DirNameResourse.BackupGatewayIdFile);

                if (fileData == null)

                {

                    return;

@@ -2106,8 +2036,6 @@
                var listTempId = new List<string>();

                listTempId.AddRange(this.listBackupGwId);



                //不显示已经被绑定过的信息,NotSetAgain:假如断网时,不二次发送

                List<string> listNotShow = new List<string>() { "NotSetAgain" };

                //调用接口，绑定网关

                var bindGateway = new BindGatewayPra();

                //获取控制主人账号的Token

@@ -2117,12 +2045,12 @@
                {

                    bindGateway.BindGateways.Clear();

                    bindGateway.BindGateways.Add(gwId);

                    var result = await UserCenterLogic.GetResultCodeByRequestHttps("App/BindGatewayToHome", true, bindGateway, listNotShow);

                    var result = UserCenterLogic.GetResultCodeByRequestHttps("App/BindGatewayToHome", true, bindGateway, new List<string> { "NotCheck" }, false);

                    if (result == "Success")

                    {

                        this.listBackupGwId.Remove(gwId);

                    }

                    if (result == "Error" || result == "ErrorEx")

                    if (result == "Error")

                    {

                        break;

                    }

@@ -2131,7 +2059,7 @@
                if (this.listBackupGwId.Count == 0)

                {

                    //如果没有了内容,则删除文件

                    string file = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.BackupGatewayIdFile);

                    string file = DirNameResourse.BackupGatewayIdFile;

                    if (System.IO.File.Exists(file) == true)

                    {

                        System.IO.File.Delete(file);

@@ -2140,48 +2068,88 @@
                else

                {

                    //备份

                    var strData = Newtonsoft.Json.JsonConvert.SerializeObject(listBackupGwId);

                    var byteData = System.Text.Encoding.UTF8.GetBytes(strData);

                    Global.WriteFileToDirectoryByBytes(DirNameResourse.LocalMemoryDirectory, DirNameResourse.BackupGatewayIdFile, byteData);

                    HdlFileLogic.Current.SaveFileContent(DirNameResourse.BackupGatewayIdFile, listBackupGwId);

                }

            });

        }



        #endregion



        #region ■ 上传设备备份到网关_________________

        #region ■ 发送网关命令给网关_________________



        /// <summary>

        /// 上传设备备份到网关(废弃)

        /// 发送数据到网关，并接受网关返回的数据(ReceiptData为返回值)

        /// </summary>

        /// <param name="device">设备对象</param>

        /// <param name="backupEnum">备份类型</param>

        /// <param name="upLaodData">备份的数据</param>

        /// <returns></returns>

        public async Task<bool> UpLoadDeviceBackupDataToGateway(CommonDevice device, object upLaodData)

        /// <param name="gateway">网关对象</param>

        /// <param name="sendTopic">发送的主题</param>

        /// <param name="sendData">需要发送的数据  JObject.ToString()的东西</param>

        /// <param name="receiptTopic">指定接收哪个主题</param>

        /// <param name="waitTime">超时时间(秒)</param>

        /// <param name="useLocalConnect">是否强制使用本地连接发送</param>

        /// <returns>网关返回的数据</returns>

        public ReceiptGatewayResult SendJobjectDataToGateway(ZbGateway gateway, string sendTopic, string sendData, string receiptTopic, int waitTime = 5, bool useLocalConnect = false)

        {

            //ZbGateway realWay = null;

            //if (HdlGatewayLogic.Current.GetRealGateway(ref realWay, device.CurrentGateWayId) == false)

            //{

            //    //没有找到真实物理网关

            //    return false;

            //}

            //string fileName = device.FilePath + ((int)backupEnum).ToString().PadLeft(5, '0');

            ////创建文件对象

            //var result = await realWay.CreateFileAsync(fileName);

            //if (result == null || result.Result != 0)

            //{

            //    return false;

            //}

            ////发送数据流

            //var data = Newtonsoft.Json.JsonConvert.SerializeObject(upLaodData);

            //var byteData = System.Text.Encoding.UTF8.GetBytes(data);

            //var result2 = await realWay.SendFileAsync(byteData);

            //if (result2 == null || result2.Result != 0)

            //{

            //    return false;

            //}

            return true;

            var reResult = new ReceiptGatewayResult();



            ZbGateway myGateway = null;

            if (this.GetRealGateway(ref myGateway, gateway) == false)

            {

                //获取网关对象失败

                reResult.ErrorMsg = Language.StringByID(R.MyInternationalizationString.uGetGatewayTagartFail);

                reResult.ErrorMsgDiv = -1;

                return reResult;

            }

            //网关ID

            string gatewayID = gateway.GwId;

            //错误主题

            string errorTopic = gatewayID + "/" + "Error_Respon";

            //检测对象的主题

            string checkTopic = gatewayID + "/" + receiptTopic;



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

                }

                //如果是指定的主题

                if (topic == checkTopic)

                {

                    reResult.ReceiptData = jobject["Data"].ToString();

                }

            };

            myGateway.Actions += receiptAction;

            //发送数据

            if (useLocalConnect == false)

            {

                myGateway.Send(sendTopic, sendData);

            }

            else

            {

                myGateway.SendLocation(sendTopic, System.Text.Encoding.UTF8.GetBytes(sendData));

            }



            //超时时间

            int TimeOut = 0;

            waitTime = 20 * waitTime;

            while (reResult.ReceiptData == null && TimeOut < waitTime)

            {

                //全部接收才退出

                System.Threading.Thread.Sleep(50);

                TimeOut++;

            }

            myGateway.Actions -= receiptAction;

            receiptAction = null;

            if (reResult.ReceiptData == null)

            {

                reResult.ErrorMsgDiv = 0;

            }



            return reResult;

        }



        #endregion

@@ -2216,7 +2184,7 @@
            {

                int waitCount = 0;

                //如果住宅ID变更了,则不再处理

                while (frameLayout.Parent != null)

                while (frameLayout.Parent != null && Config.Instance.HomeId != string.Empty)

                {

                    System.Threading.Thread.Sleep(1000);

                    if (this.hadGatewayUpdate == true)

@@ -2276,18 +2244,33 @@
            //等个2秒

            System.Threading.Thread.Sleep(2000);



            //2020.05.25追加:此住宅是否拥有网关在线

            var hadGwOnline = false;

            foreach (var way in list)

            {

                string gwId = this.GetGatewayId(way);

                if (dicOldOnline.ContainsKey(way.GwId) == true)

                {

                    if (way.GatewayOnlineFlage == true)

                    {

                        //有一个网关在线,即在线

                        hadGwOnline = true;

                        break;

                    }

                }

            }



            foreach (var way in list)

            {

                string gwId = way.GwId;

                if (dicOldOnline.ContainsKey(gwId) == true)

                {

                    //网关也不多,直接推送吧

                    this.PushGatewayOnlineStatuToForm(gwId, way.GatewayOnlineFlage);

                    this.PushGatewayOnlineStatuToForm(gwId, way.GatewayOnlineFlage, hadGwOnline);

                }

                else

                {

                    //没有包含,默认为false

                    this.PushGatewayOnlineStatuToForm(gwId, false);

                    this.PushGatewayOnlineStatuToForm(gwId, false, hadGwOnline);

                }

            }

        }

@@ -2305,22 +2288,34 @@
                dicDbGateway = new Dictionary<string, GatewayResult>();

            }



            //2020.05.25追加:此住宅是否拥有网关在线

            var hadGwOnline = false;

            foreach (var gwId in dicOldOnline.Keys)

            {

                //如果云端上面有这个网关

                if (dicDbGateway.ContainsKey(gwId) == true

                    && dicDbGateway[gwId].MqttOnlineStatus == true)

                {

                    //有一个网关在线,即在线

                    hadGwOnline = true;

                    break;

                }

            }



            foreach (var gwId in dicOldOnline.Keys)

            {

                //如果云端上面有这个网关

                if (dicDbGateway.ContainsKey(gwId) == true)

                {

                    //网关也不多,直接推送

                    this.PushGatewayOnlineStatuToForm(gwId, dicDbGateway[gwId].MqttOnlineStatus);

                    this.PushGatewayOnlineStatuToForm(gwId, dicDbGateway[gwId].MqttOnlineStatus, hadGwOnline);

                }

                else

                {

                    //云端不包含的,当不在线处理

                    this.PushGatewayOnlineStatuToForm(gwId, false);

                    this.PushGatewayOnlineStatuToForm(gwId, false, hadGwOnline);

                }

            }



           
        }



        /// <summary>

@@ -2342,8 +2337,7 @@
                foreach (var zbway in this.dicGateway.Values)

                {

                    //获取前回的在线状态

                    string gwId = this.GetGatewayId(zbway);

                    dicOldOnline[gwId] = zbway.GatewayOnlineFlage;

                    dicOldOnline[zbway.GwId] = zbway.GatewayOnlineFlage;

                }

                return dicOldOnline;

            }

@@ -2355,7 +2349,8 @@
        /// </summary>

        /// <param name="gwId"></param>

        /// <param name="online"></param>

        private void PushGatewayOnlineStatuToForm(string gwId, bool online)

        /// <param name="hadGwOnline">2020.05.25追加:此住宅是否拥有网关在线</param>

        private void PushGatewayOnlineStatuToForm(string gwId, bool online, bool hadGwOnline)

        {

            try

            {

@@ -2368,9 +2363,12 @@
                    }

                    //网关在线推送

                    var zbway = this.GetLocalGateway(gwId);

                    zbway.GatewayOnlineFlage = online;



                    UserCenterResourse.DicActionForm[formId]?.GatewayOnlinePush(zbway, online);

                    if (zbway != null)

                    {

                        //切换住宅时,这个东西有可能是null

                        zbway.GatewayOnlineFlage = online;

                        UserCenterResourse.DicActionForm[formId]?.GatewayOnlinePush(zbway, online, hadGwOnline);

                    }

                }

            }

            catch { }