Merge branch 'dev-tzy' into dev-2020xm

xm

2020-07-14 d87400af518ebc9274f4447f06476959c3aa5102

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

@@ -2,8 +2,6 @@
using Shared.Common;

using Newtonsoft.Json;

using Shared.Common.ResponseEntity;

using System.Threading.Tasks;

using System.Text.RegularExpressions;

using System.Collections.Generic;

using System.Text;



@@ -23,30 +21,28 @@
        /// <param name="RequestName">访问地址</param>

        /// <param name="checkAuthority">是否检测权限，该参数不能省略</param>

        /// <param name="obj">一个类</param>

        /// <param name="listNotShowError">

        /// <pra>不需要显示错误的错误类别(接口返回的错误类别),如果包含，则会返回【true】</pra>

        /// <pra>如果指定有NotSetAgain,则不二次发送(比如断网),然后返回【false】</pra>

        /// </param>

        public static async Task<bool> GetResultStatuByRequestHttps(string RequestName, bool checkAuthority, object obj, List<string> listNotShowError = null)

        /// <param name="listNotShowError">不需要显示错误的错误类别(接口返回的错误类别),如果包含，则会返回【true】</param>

        /// <param name="setAgain">当发送失败时,是否重发,默认不重发</param>

        public static bool GetResultStatuByRequestHttps(string RequestName, bool checkAuthority, object obj, List<string> listNotShowError = null, bool setAgain = false)

        {

            //检测是否已经完成账号信息初始化

            if (UserCenterResourse.UserInfo.InitUserInfoSuccess == false)

            if (HdlWifiLogic.Current.CanAccessHttp == false && setAgain == false)

            {

                //不管结果怎么样,如果调用了这个函数,需要重头获取Token,所以必须返回失败

                await ReInitUserAccoutInfo(listNotShowError);

                //当前无法访问网络(当需要重新发送时,跳过这个判断)

                ShowNotNetMsg(listNotShowError);

                return false;

            }

            //获取接口的连接模式

            var connectMode = GetHttpConnectMode(checkAuthority);

            //获取从接口那里取到的比特数据

            var byteData = await GettByteResponsePack(RequestName, connectMode, obj);

            if (byteData == null)

            var byteData = GettByteResponsePack(RequestName, connectMode, obj);

            if (byteData == null && setAgain == true)

            {

                if (listNotShowError != null && listNotShowError.Contains("NotSetAgain") == true)

                if (setAgain == false)

                {

                    //不指定重发

                    return false;

                }

                byteData = await ResetByteRequestHttps(RequestName, checkAuthority, obj);

                byteData = ResetByteRequestHttps(RequestName, checkAuthority, obj);

                if (byteData == null)

                {

                    return false;

@@ -64,31 +60,30 @@
        /// <param name="RequestName">访问地址</param>

        /// <param name="checkAuthority">是否检测权限，该参数不能省略</param>

        /// <param name="obj">一个类</param>

        /// <param name="listNotShowError">

        /// <pra>不需要显示错误的错误类别(接口返回的错误类别),如果包含，则会返回【Success】</pra>

        /// <pra>如果指定有NotSetAgain,则不二次发送(比如断网),然后返回【ErrorEx】</pra>

        /// <param name="listNotShowError">不需要显示错误的错误类别(接口返回的错误类别),如果包含，则会返回【true】</param>

        /// <param name="setAgain">当发送失败时,是否重发,默认不重发</param>

        /// </param>

        public static async Task<string> GetResultCodeByRequestHttps(string RequestName, bool checkAuthority, object obj, List<string> listNotShowError = null)

        public static string GetResultCodeByRequestHttps(string RequestName, bool checkAuthority, object obj, List<string> listNotShowError = null, bool setAgain = false)

        {

            //检测是否已经完成账号信息初始化

            if (UserCenterResourse.UserInfo.InitUserInfoSuccess == false)

            if (HdlWifiLogic.Current.CanAccessHttp == false && setAgain == false)

            {

                //不管结果怎么样,如果调用了这个函数,需要重头获取Token,所以必须返回失败

                await ReInitUserAccoutInfo(listNotShowError);

                //当前无法访问网络(当需要重新发送时,跳过这个判断)

                ShowNotNetMsg(listNotShowError);

                return "Error";

            }



            //获取接口的连接模式

            var connectMode = GetHttpConnectMode(checkAuthority);

            //获取从接口那里取到的比特数据

            var byteData = await GettByteResponsePack(RequestName, connectMode, obj);

            var byteData = GettByteResponsePack(RequestName, connectMode, obj);

            if (byteData == null)

            {

                if (listNotShowError != null && listNotShowError.Contains("NotSetAgain") == true)

                if (setAgain == false)

                {

                    return "ErrorEx";

                    //不指定重发

                    return "Error";

                }

                byteData = await ResetByteRequestHttps(RequestName, checkAuthority, obj);

                byteData = ResetByteRequestHttps(RequestName, checkAuthority, obj);

                if (byteData == null)

                {

                    return "Error";

@@ -109,30 +104,29 @@
        /// <param name="RequestName">访问地址</param>

        /// <param name="checkAuthority">是否检测权限，该参数不能省略</param>

        /// <param name="obj">一个类</param>

        /// <param name="listNotShowError">

        /// <pra>不需要显示错误的错误类别(接口返回的错误类别),如果包含，则会返回空字符串</pra>

        /// <pra>如果指定有NotSetAgain,则不二次发送(比如断网),然后返回空字符串</pra>

        /// <param name="listNotShowError">不需要显示错误的错误类别(接口返回的错误类别),如果包含，则会返回【true】</param>

        /// <param name="setAgain">当发送失败时,是否重发,默认不重发</param>

        /// </param>

        public static async Task<string> GetResponseDataByRequestHttps(string RequestName, bool checkAuthority, object obj, List<string> listNotShowError = null)

        public static string GetResponseDataByRequestHttps(string RequestName, bool checkAuthority, object obj, List<string> listNotShowError = null, bool setAgain = false)

        {

            //检测是否已经完成账号信息初始化

            if (UserCenterResourse.UserInfo.InitUserInfoSuccess == false)

            if (HdlWifiLogic.Current.CanAccessHttp == false && setAgain == false)

            {

                //不管结果怎么样,如果调用了这个函数,需要重头获取Token,所以必须返回失败

                await ReInitUserAccoutInfo(listNotShowError);

                //当前无法访问网络(当需要重新发送时,跳过这个判断)

                ShowNotNetMsg(listNotShowError);

                return null;

            }

            //获取接口的连接模式

            var connectMode = GetHttpConnectMode(checkAuthority);

            //获取从接口那里取到的比特数据

            var byteData = await GettByteResponsePack(RequestName, connectMode, obj);

            var byteData = GettByteResponsePack(RequestName, connectMode, obj);

            if (byteData == null)

            {

                if (listNotShowError != null && listNotShowError.Contains("NotSetAgain") == true)

                if (setAgain == false)

                {

                    return string.Empty;

                    //不指定重发

                    return null;

                }

                byteData = await ResetByteRequestHttps(RequestName, checkAuthority, obj);

                byteData = ResetByteRequestHttps(RequestName, checkAuthority, obj);

                if (byteData == null)

                {

                    return null;

@@ -159,32 +153,29 @@
        /// <param name="RequestName">访问地址</param>

        /// <param name="checkAuthority">是否检测权限，该参数不能省略</param>

        /// <param name="obj">一个类</param>

        /// <param name="listNotShowError">

        /// <pra>不需要显示错误的错误类别(接口返回的错误类别),如果包含，则会返回空字符串</pra>

        /// <pra>如果指定有NotSetAgain,则不二次发送(比如断网),然后返回null</pra>

        /// </param>

        public static async Task<byte[]> GetByteResponseDataByRequestHttps(string RequestName, bool checkAuthority, object obj, List<string> listNotShowError = null)

        /// <param name="listNotShowError">不需要显示错误的错误类别(接口返回的错误类别),如果包含，则会返回【true】</param>

        /// <param name="setAgain">当发送失败时,是否重发,默认不重发</param>

        public static byte[] GetByteResponseDataByRequestHttps(string RequestName, bool checkAuthority, object obj, List<string> listNotShowError = null, bool setAgain = false)

        {

            //检测是否已经完成账号信息初始化

            if (UserCenterResourse.UserInfo.InitUserInfoSuccess == false)

            if (HdlWifiLogic.Current.CanAccessHttp == false && setAgain == false)

            {

                //不管结果怎么样,如果调用了这个函数,需要重头获取Token,所以必须返回失败

                await ReInitUserAccoutInfo(listNotShowError);

                //当前无法访问网络(当需要重新发送时,跳过这个判断)

                ShowNotNetMsg(listNotShowError);

                return null;

            }

            //获取接口的连接模式

            var connectMode = GetHttpConnectMode(checkAuthority);

            //获取从接口那里取到的比特数据

            var revertObj = await GettByteResponsePack(RequestName, connectMode, obj);

            var revertObj = GettByteResponsePack(RequestName, connectMode, obj);



            if (revertObj == null)

            {

                if (listNotShowError != null && listNotShowError.Contains("NotSetAgain") == true)

                if (setAgain == false)

                {

                    //不指定重发

                    return null;

                }

                //重新发送

                revertObj = await ResetByteRequestHttps(RequestName, checkAuthority, obj);

                revertObj = ResetByteRequestHttps(RequestName, checkAuthority, obj);

                if (revertObj == null)

                {

                    return null;

@@ -216,7 +207,7 @@
        /// <param name="checkAuthority">是否检测权限，该参数不能省略</param>

        /// <param name="obj">一个类</param>

        /// <returns></returns>

        private static async Task<byte[]> ResetByteRequestHttps(string RequestName, bool checkAuthority, object obj)

        private static byte[] ResetByteRequestHttps(string RequestName, bool checkAuthority, object obj)

        {

            //获取接口的连接模式

            var connectMode = GetHttpConnectMode(checkAuthority);

@@ -225,9 +216,9 @@
            int count = 0;

            while (true)

            {

                await Task.Delay(1000);

                System.Threading.Thread.Sleep(1000);

                //调用接口

                responsePack = await GettByteResponsePack(RequestName, connectMode, obj);

                responsePack = GettByteResponsePack(RequestName, connectMode, obj);

                if (responsePack != null)

                {

                    break;

@@ -235,13 +226,8 @@
                count++;

                if (count == 3)

                {

                    Application.RunOnMainThread(() =>

                    {

                        //网络不稳定,请稍后再试

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

                        var control = new ShowMsgControl(ShowMsgType.Tip, msg);

                        control.Show();

                    });

                    //显示没有网络的Msg

                    ShowNotNetMsg(null);

                    break;

                }

            }

@@ -255,7 +241,7 @@
        /// <param name="RequestName">访问地址</param>

        /// <param name="connectMode">接口的连接模式</param>

        /// <param name="obj">一个类</param>

        private static async Task<byte[]> GettByteResponsePack(string RequestName, HttpConnectMode connectMode, object obj)

        private static byte[] GettByteResponsePack(string RequestName, HttpConnectMode connectMode, object obj)

        {

            try

            {

@@ -266,12 +252,12 @@
                if (connectMode == HttpConnectMode.Normal)

                {

                    //普通访问

                    result = await CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync(RequestName, Encoding.UTF8.GetBytes(requestJson));

                    result = CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync(RequestName, Encoding.UTF8.GetBytes(requestJson));

                }

                else if (connectMode == HttpConnectMode.Admin)

                {

                    //以管理员的身份访问，自身是成员

                    result = await CommonPage.Instance.RequestZigbeeHttpsByAdmin(RequestName, Encoding.UTF8.GetBytes(requestJson));

                    result = CommonPage.Instance.RequestZigbeeHttpsByAdmin(RequestName, Encoding.UTF8.GetBytes(requestJson));

                }

                return result;

            }

@@ -299,13 +285,13 @@
            }

            if (revertObj == null)

            {

                Application.RunOnMainThread(() =>

                HdlThreadLogic.Current.RunMain(() =>

                {

                    //网络不稳定,请稍后再试

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

                    var control = new ShowMsgControl(ShowMsgType.Tip, msg);

                    control.Show();

                });

                }, ShowErrorMode.NO);



                return false;

            }

@@ -316,7 +302,7 @@
                    //不显示错误,然后返回true

                    return true;

                }

                Application.RunOnMainThread(() =>

                HdlThreadLogic.Current.RunMain(() =>

                {

                    if (HdlCheckLogic.Current.IsAccountLoginOut() == true)

                    {

@@ -332,10 +318,10 @@
                        //无效登录Token

                        if (revertObj.StateCode == "NoLogin")

                        {

                            UserCenterLogic.ReLoginAgain(Config.Instance.Account, false);

                            ReLoginAgain(Config.Instance.Account, false);

                        }

                    }

                });

                }, ShowErrorMode.NO);



                return false;

            }

@@ -358,6 +344,25 @@
                return HttpConnectMode.Admin;

            }

            return HttpConnectMode.Normal;

        }



        /// <summary>

        /// 显示没有网络的Msg

        /// </summary>

        private static void ShowNotNetMsg(List<string> listNotShowError)

        {

            if (listNotShowError != null && listNotShowError.Contains("NotCheck") == true)

            {

                //不检测

                return;

            }

            HdlThreadLogic.Current.RunMain(() =>

            {

                // 当前无网络连接,请确认网络

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

                var control = new ShowMsgControl(ShowMsgType.Tip, msg);

                control.Show();

            }, ShowErrorMode.NO);

        }



        #endregion

@@ -529,6 +534,12 @@
            HdlGatewayLogic.Current.SynchronizeDbGateway();

            //从本地重新加载全部的房间

            HdlRoomLogic.Current.RefreshAllRoomByLocation();

            //断开远程Mqtt连接,重新连接

            HdlThreadLogic.Current.RunThread(async () =>

            {

                HdlGatewayLogic.Current.ClearAllRealGateway();

                await ZigBee.Device.ZbGateway.DisConnectRemoteMqttClient();

            }, ShowErrorMode.NO);

        }



        /// <summary>

@@ -551,62 +562,6 @@
            Config.Instance.Home.Longitude = Longitude;

            Config.Instance.Home.Latitude = Latitude;

            Config.Instance.Home.Save(false);

        }



        #endregion



        #region ■ 删除本地文件_______________________



        /// <summary>

        /// 删除本地所有文件

        /// </summary>

        /// <param name="all">true:全部删除(用于住宅删除) false:重要的文件不删除</param>

        public static void DeleteAllLocationFile(bool all = true)

        {

            string dPath = Config.Instance.FullPath;

            if (System.IO.Directory.Exists(dPath) == false)

            {

                return;

            }



            //然后获取全部的文件

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

            foreach (string file in listFile)

            {

                if (all == false && IsNotDeleteFile(file) == true)

                {

                    //这是不能删除的文件

                    continue;

                }

                //删除文件

                Global.DeleteFilebyHomeId(file);

            }

            //如果是把文件全部删除的话，那么文件夹也一起删除掉

            if (all == true)

            {

                //删除文件夹

                System.IO.Directory.Delete(dPath, true);

            }

        }



        /// <summary>

        /// 判断是不是不应该删除的文件

        /// </summary>

        /// <param name="fileName"></param>

        /// <returns></returns>

        public static bool IsNotDeleteFile(string fileName)

        {

            if (fileName == "Config.json")

            {

                //不能删除Config文件

                return true;

            }

            else if (fileName.StartsWith("House_") == true)

            {

                //不能删除住宅文件

                return true;

            }

            return false;

        }



        #endregion

@@ -648,12 +603,12 @@
            //清除升级列表

            FirmwareUpdateResourse.dicUpdateList.Clear();



            HdlThreadLogic.Current.RunThread(async () =>

            HdlThreadLogic.Current.RunThread(() =>

            {

                //检测APP是否能够退出

                while (UserCenterResourse.AccountOption.AppCanSignout == false)

                {

                    await Task.Delay(500);

                    System.Threading.Thread.Sleep(500);

                }

                //设定一个时间

                Config.Instance.LoginDateTime = new DateTime(1970, 1, 1);

@@ -685,7 +640,7 @@
                if (noticeDb == true)

                {

                    //通知云端，已经退出登陆

                    var result = await CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync("ZigbeeUsers/SignOut", null, "GET");

                    var result = CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync("ZigbeeUsers/SignOut", null, "GET");

                }

            });

        }

@@ -746,29 +701,6 @@
        #endregion



        #region ■ 拼接信息___________________________



        /// <summary>

        /// 拼接路径(全路径)，以住宅ID的文件夹为起点，当没有指定参数时，则返回【住宅ID的文件夹】的全路径

        /// </summary>

        /// <param name="listNames">要拼接的路径</param>

        /// <returns></returns>

        public static string CombinePath(params object[] listNames)

        {

            string rootPath = Config.Instance.FullPath;

            if (listNames == null || listNames.Length == 0)

            {

                return rootPath;

            }

            foreach (var file in listNames)

            {

                if (file == null)

                {

                    continue;

                }

                rootPath = System.IO.Path.Combine(rootPath, file.ToString());

            }

            return rootPath;

        }



        /// <summary>

        /// 拼接网关回复超时的信息

@@ -835,10 +767,13 @@
        /// </summary>

        /// <param name="ShowPrompted">新追加变量：是否显示提示自动备份的界面</param>

        /// <returns></returns>

        public async static Task<bool> InitUserCenterMenmoryAndThread(bool ShowPrompted = true)

        public static bool InitUserCenterMenmoryAndThread(bool ShowPrompted = true)

        {

            //调用这个方法,都需要重新刷新主页

            UserView.UserPage.Instance.RefreshForm = true;

            UserView.UserPage.Instance.RefreshAllForm = true;



            //添加网络状态监听

            HdlWifiLogic.Current.StartListenNetWork();



            //如果是虚拟住宅

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

@@ -857,12 +792,6 @@
            if (Common.Config.Instance.HomeId != UserCenterResourse.AccountOption.OldHomeStringId

                || Common.Config.Instance.Account != UserCenterResourse.AccountOption.OldAccountId)

            {

                //断开远程Mqtt连接

                HdlThreadLogic.Current.RunThread(async () =>

                {

                    await ZigBee.Device.ZbGateway.DisConnectRemoteMqttClient();

                }, ShowErrorMode.NO);



                //清空所有成员缓存

                ClearAllMemberMemory();



@@ -870,27 +799,23 @@
                var optionInfo = UserCenterResourse.AccountOption.Load();

                UserCenterResourse.AccountOption = optionInfo;

                //变更根用户图片目录路径

                UserCenterResourse.AccountOption.UserPictruePath = System.IO.Path.Combine(Shared.IO.FileUtils.RootPath, Config.Instance.Guid, DirNameResourse.UserPictrueDirectory);

                UserCenterResourse.AccountOption.UserPictruePath = DirNameResourse.UserPictrueDirectory;



                //加载住宅配置信息

                UserCenterResourse.ResidenceOption = UserCenterResourse.ResidenceOption.Load();



                //初始化登陆账号的信息

                var hadNet = await InitUserAccoutInfo(true);

                var hadNet = InitUserAccoutInfo(true);

                //如果有网络的话

                if (hadNet == 1)

                {

                    //重新发送命令去绑定断网情况下备份的网关

                    HdlGatewayLogic.Current.ResetComandToBindBackupGateway();

                    //读取隐匿配置

                    await HdlBackupLogic.Current.LoadHideOption();

                    HdlBackupLogic.Current.LoadHideOption();

                }



                //初始化缓存成员的信息

                InitLocalMemberListInfo();



                //预创建个人中心全部的文件夹

                CreatAllUserCenterDirectory();

                HdlFileLogic.Current.CreatAllUserCenterDirectory();



                //关闭所有接收

                HdlGatewayReceiveLogic.Current.RemoveAllEvent();

@@ -907,7 +832,7 @@
                int result = -1;

                if (hadNet == 1)

                {

                    result = await HdlAutoBackupLogic.SynchronizeDbAutoBackupData();

                    result = HdlAutoBackupLogic.SynchronizeDbAutoBackupData();

                }



                //初始化本地的网关信息

@@ -923,6 +848,13 @@
                    //同步云端的网关id，如果本地拥有云端不存在的id，则表示应该被换绑了，直接删除

                    HdlGatewayLogic.Current.SynchronizeDbGateway();

                }



                //断开远程Mqtt连接,重新连接

                HdlThreadLogic.Current.RunThread(async () =>

                {

                    HdlGatewayLogic.Current.ClearAllRealGateway();

                    await ZigBee.Device.ZbGateway.DisConnectRemoteMqttClient();

                }, ShowErrorMode.NO);



                //刷新APP前一次选择的网关ID(可以反复调用,需要在网关初始化完了之后才能调用)

                HdlGatewayLogic.Current.RefreshAppOldSelectGatewayId();

@@ -951,7 +883,7 @@
            //清空所有成员缓存

            ClearAllMemberMemory();

            //预创建个人中心全部的文件夹

            CreatAllUserCenterDirectory();

            HdlFileLogic.Current.CreatAllUserCenterDirectory();

            //关闭所有接收

            HdlGatewayReceiveLogic.Current.RemoveAllEvent();

            //初始化本地的网关信息

@@ -996,7 +928,7 @@
        /// </summary>

        /// <param name="reLoad">是否从新从本地加载(重新初始化登陆账号的信息,不需要重新加载)</param>

        /// <returns></returns>

        private async static Task<int> InitUserAccoutInfo(bool reLoad)

        private static int InitUserAccoutInfo(bool reLoad)

        {

            //初始化个人信息的标识

            UserCenterResourse.UserInfo.InitUserInfoSuccess = false;

@@ -1006,13 +938,18 @@
                UserCenterResourse.UserInfo = GetUserInformationFromLocation();

                UserCenterResourse.UserInfo.UserIconFile = System.IO.Path.Combine(UserCenterResourse.AccountOption.UserPictruePath, "Admin.png");

            }

            if (HdlWifiLogic.Current.CanAccessHttp == false)

            {

                //无法连接外网

                return -1;

            }



            //获取登录账号的信息

            var pra = new AccountInfoPra();

            //序列化对象

            var requestJson = JsonConvert.SerializeObject(pra);

            //访问接口

            byte[] byteData = await CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync("ZigbeeUsers/GetAccountInfo", Encoding.UTF8.GetBytes(requestJson));

            byte[] byteData = CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync("ZigbeeUsers/GetAccountInfo", Encoding.UTF8.GetBytes(requestJson), "POST", 4);

            if (byteData == null)

            {

                return -1;

@@ -1051,29 +988,27 @@
                userInfo.AuthorityText = Language.StringByID(R.MyInternationalizationString.uMember);

            }



            if (UserCenterResourse.UserInfo.AuthorityNo != userInfo.AuthorityNo)

            //UserInfo.AuthorityNo==0代表本地还没有生成文件,这个时候不需要处理

            if (UserCenterResourse.UserInfo.AuthorityNo != userInfo.AuthorityNo

                && UserCenterResourse.UserInfo.AuthorityNo != 0)

            {

                //如果登陆的账号的权限和上一次的不一样,则删除本地这个住宅全部的文件,从头再来

                string dirPath = CombinePath();

                string dirPath = Config.Instance.FullPath;

                if (System.IO.Directory.Exists(dirPath) == true)

                {

                    try

                    {

                        //同步数据的判断文件(以防万一删除整个文件夹失败的时候,这个文件被删的话,应该没什么大问题)

                        string SynchronizeFile = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.AutoDownLoadBackupCheckFile);

                        string SynchronizeFile = DirNameResourse.AutoDownLoadBackupCheckFile;

                        //如果本地已经拥有了这个文件，则说明不是新手机，不再自动还原

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

                        {

                            System.IO.File.Delete(SynchronizeFile);

                        }

                        //删除整个文件夹

                        System.IO.Directory.Delete(dirPath, true);

                        HdlFileLogic.Current.DeleteFile(SynchronizeFile);

                        HdlFileLogic.Current.DeleteDirectory(dirPath);

                    }

                    catch { }

                    //创建住宅文件夹

                    Global.CreateHomeDirectory(Config.Instance.HomeId);

                    //预创建个人中心全部的文件夹

                    CreatAllUserCenterDirectory();

                    HdlFileLogic.Current.CreatAllUserCenterDirectory();

                }

            }

            if (string.IsNullOrEmpty(userInfo.UserName) == true)

@@ -1096,9 +1031,11 @@
            //密码验证

            UserCenterResourse.AccountOption.PswAuthentication = UserCenterResourse.UserInfo.StringPwd == null ? string.Empty : UserCenterResourse.UserInfo.StringPwd;

            UserCenterResourse.UserInfo.StringPwd = null;

            //保存缓存

            UserCenterResourse.AccountOption.Save();



            //初始化管理员控制主人的连接地址(因为这个连接Token是不会改变的,所以只需要初始化一次)

            var flage = await InitAdminConnectMainInfo();

            var flage = InitAdminConnectMainInfo();

            //初始化个人信息的标识

            UserCenterResourse.UserInfo.InitUserInfoSuccess = flage == 1;



@@ -1111,8 +1048,7 @@
        /// <returns></returns>

        private static UserInformation GetUserInformationFromLocation()

        {

            string fileName = CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.UserInfoFile);

            var value = LoadFileContent(fileName);

            var value = HdlFileLogic.Current.ReadFileTextContent(DirNameResourse.UserInfoFile);

            if (value == null)

            {

                return new UserInformation();

@@ -1125,26 +1061,10 @@
        /// 重新初始化登陆账号的信息(旨在对应那一瞬间,网络不好,导致误判的情况)

        /// </summary>

        /// <returns></returns>

        private async static Task<bool> ReInitUserAccoutInfo(List<string> listNotShowError)

        public static bool ReInitUserAccoutInfo()

        {

            //重新初始化账号信息

            var result = await InitUserAccoutInfo(false);

            //连接不了外网的时候

            if (result == -1)

            {

                if (listNotShowError != null &&

                    (listNotShowError.Contains("NotSetAgain") == true || listNotShowError.Contains("NotCheck") == true))

                {

                    //有这两个标识时,不提示错误

                    return false;

                }

                Application.RunOnMainThread(() =>

                {

                    //当前无网络连接,请确认网络

                    var alert = new ShowMsgControl(ShowMsgType.Tip, Language.StringByID(R.MyInternationalizationString.uNowIsDonotNetworkAndCheckNetwork));

                    alert.Show();

                });

            }

            var result = InitUserAccoutInfo(false);

            if (result == 1)

            {

                //同步云端的网关id，如果本地拥有云端不存在的id，则表示应该被换绑了，直接删除

@@ -1162,9 +1082,8 @@
        /// </summary>

        private static void SaveUserInformationToLocation()

        {

            string fullName = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.UserInfoFile);

            //写入内容

            SaveFileContent(fullName, UserCenterResourse.UserInfo);

            HdlFileLogic.Current.SaveFileContent(DirNameResourse.UserInfoFile, UserCenterResourse.UserInfo);



            //搞一下主人的默认头像

            string defultFile = IO.FileUtils.GetImageFilePath("Center/Admin.png");

@@ -1188,7 +1107,7 @@
        /// 初始化管理员权限远程连接主人的信息 -1:无网 1:正常 2:其他错误

        /// </summary>

        /// <returns></returns>

        private static async Task<int> InitAdminConnectMainInfo()

        private static int InitAdminConnectMainInfo()

        {

            if (UserCenterResourse.UserInfo.AuthorityNo != 2 && UserCenterResourse.UserInfo.AuthorityNo != 3)

            {

@@ -1206,7 +1125,7 @@
            //序列化对象

            var requestJson = JsonConvert.SerializeObject(pra);

            //访问接口

            byte[] byteData = await CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync("App/GetSharedHomeApiControl", Encoding.UTF8.GetBytes(requestJson));

            byte[] byteData = CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync("App/GetSharedHomeApiControl", Encoding.UTF8.GetBytes(requestJson));

            if (byteData == null)

            {

                return -1;

@@ -1224,87 +1143,6 @@
            Config.Instance.AdminRequestToken = info.RequestToken;



            return 1;

        }



        #endregion



        #region ■ 初始化缓存成员的信息_______________



        /// <summary>

        /// 初始化缓存成员的信息

        /// </summary>

        private static void InitLocalMemberListInfo()

        {

            //先清空

            UserCenterResourse.ListMemberInfo.Clear();

            string fileName = CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.MemberListInfoFile);

            if (System.IO.File.Exists(fileName) == false)

            {

                return;

            }

            var varByte = Shared.IO.FileUtils.ReadFile(fileName);

            UserCenterResourse.ListMemberInfo = JsonConvert.DeserializeObject<List<MemberInfoRes>>(System.Text.Encoding.UTF8.GetString(varByte));

        }



        /// <summary>

        /// 保存缓存成员的信息

        /// </summary>

        public static void SaveLocalMemberListInfo()

        {

            var data = Newtonsoft.Json.JsonConvert.SerializeObject(UserCenterResourse.ListMemberInfo);

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



            string fullName = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.MemberListInfoFile);

            //写入内容

            Shared.IO.FileUtils.WriteFileByBytes(fullName, byteData);

        }



        #endregion



        #region ■ 预创建个人中心全部的文件夹_________



        /// <summary>

        /// 预创建个人中心全部的文件夹

        /// </summary>

        public static void CreatAllUserCenterDirectory()

        {

            //本地缓存的根目录

            string LocalDirectory = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory);

            Global.CreateEmptyDirectory(LocalDirectory);



            //自动备份【文件夹】(编辑,追加)

            string directory = System.IO.Path.Combine(LocalDirectory, DirNameResourse.AutoBackupDirectory);

            Global.CreateEmptyDirectory(directory);



            //自动备份【文件夹】(删除)

            directory = System.IO.Path.Combine(LocalDirectory, DirNameResourse.AutoBackupdeleteDirectory);

            Global.CreateEmptyDirectory(directory);



            //下载备份的时候所使用的临时【文件夹】

            directory = System.IO.Path.Combine(LocalDirectory, DirNameResourse.DownLoadBackupTempDirectory);

            Global.CreateEmptyDirectory(directory);



            //保存安防记录的【文件夹】

            directory = System.IO.Path.Combine(LocalDirectory, DirNameResourse.SafeguardAlarmDirectory);

            Global.CreateEmptyDirectory(directory);



            //上传网关备份文件到云端的临时【文件夹】

            directory = System.IO.Path.Combine(LocalDirectory, DirNameResourse.GatewayBackupDirectory);

            Global.CreateEmptyDirectory(directory);



            //下载分享文件的临时【文件夹】

            directory = System.IO.Path.Combine(LocalDirectory, DirNameResourse.DownLoadShardDirectory);

            Global.CreateEmptyDirectory(directory);



            //LOG出力【文件夹】

            directory = System.IO.Path.Combine(LocalDirectory, DirNameResourse.LogDirectory);

            Global.CreateEmptyDirectory(directory);



            //用户图片目录路径【文件夹】

            if (UserCenterResourse.AccountOption.UserPictruePath != string.Empty && !System.IO.Directory.Exists(UserCenterResourse.AccountOption.UserPictruePath))
            {
                System.IO.Directory.CreateDirectory(UserCenterResourse.AccountOption.UserPictruePath);
            }

        }



        #endregion

@@ -1335,7 +1173,7 @@
        /// <param name="result">同步结果 -1：异常   0:已经同步过，不需要同步  1：正常同步  2:没有自动备份数据</param>

        private static void ShowGuideForm(int result)

        {

            var checkFile = System.IO.Path.Combine(Shared.IO.FileUtils.RootPath, DirNameResourse.GuideFile);

            var checkFile = DirNameResourse.GuideFile;

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

            {

                //不需要显示

@@ -1478,89 +1316,6 @@
        {

            var utcTime = Convert.ToDateTime(timeText);

            return TimeZoneInfo.ConvertTimeFromUtc(utcTime, TimeZoneInfo.Local);

        }



        #endregion



        #region ■ 文件保存和读取_____________________



        /// <summary>

        /// 文件保存(整天忘记,所以建一个函数来玩玩)

        /// </summary>

        /// <param name="fullName">全路径</param>

        /// <param name="obj">需要序列化的东西</param>

        public static void SaveFileContent(string fullName, object obj)

        {

            var data = JsonConvert.SerializeObject(obj);

            SaveTexToFile(fullName, data);

        }



        /// <summary>

        /// 文件保存(整天忘记,所以建一个函数来玩玩)

        /// </summary>

        /// <param name="fullName">全路径</param>

        /// <param name="obj">需要序列化的东西</param>

        public static void SaveTexToFile(string fullName, string textValue)

        {

            var byteData = Encoding.UTF8.GetBytes(textValue);

            //写入内容

            System.IO.FileStream fileStream = null;

            try

            {

                fileStream = new System.IO.FileStream(fullName, System.IO.FileMode.Create, System.IO.FileAccess.Write);

                fileStream.Write(byteData, 0, byteData.Length);

                fileStream.Flush();

            }

            catch { }

            finally

            {

                fileStream?.Close();

            }

        }



        /// <summary>

        /// 读取文件,不限制住宅(文件不存在返回null,整天忘记,所以建一个函数来玩玩)

        /// </summary>

        /// <param name="fullName">全路径</param>

        /// <returns></returns>

        public static string LoadFileContent(string fullName)

        {

            //读取文件

            var varByte = ReadFileContent(fullName);

            if (varByte == null)

            {

                return null;

            }

            return Encoding.UTF8.GetString(varByte);

        }



        /// <summary>

        /// 读取文件,不限制住宅,文件不存在返回null

        /// </summary>

        /// <param name="fullName">全路径</param>

        /// <returns></returns>

        public static byte[] ReadFileContent(string fullName)

        {

            if (System.IO.File.Exists(fullName) == false)

            {

                return null;

            }

            System.IO.FileStream fileStream = null;

            try

            {

                fileStream = new System.IO.FileStream(fullName, System.IO.FileMode.Open, System.IO.FileAccess.Read);

                byte[] array = new byte[fileStream.Length];

                fileStream.Read(array, 0, array.Length);

                return array;

            }

            catch

            {

                return null;

            }

            finally

            {

                fileStream?.Close();

            }

        }



        #endregion