~xm/HomeApp.git

old mode 100755 new mode 100644

			@@ -1,1517 +1,1396 @@
			using System;
			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;

			namespace Shared.Phone.UserCenter
			{
			/// <summary>
			/// 个人中心逻辑类
			/// </summary>
			public class UserCenterLogic
			{
			#region ■ 云端接口访问_______________________

			/// <summary>
			/// 访问指定接口，返回是否成功
			/// </summary>
			/// <returns>是否成功</returns>
			/// <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)
			{
			//检测是否已经完成账号信息初始化
			if (UserCenterResourse.UserInfo.InitUserInfoSuccess == false)
			{
			//不管结果怎么样,如果调用了这个函数,需要重头获取Token,所以必须返回失败
			await ReInitUserAccoutInfo();
			return false;
			}
			//获取接口的连接模式
			var connectMode = GetHttpConnectMode(checkAuthority);
			//获取从接口那里取到的比特数据
			var byteData = await GettByteResponsePack(RequestName, connectMode, obj);
			if (byteData == null)
			{
			if (listNotShowError != null && listNotShowError.Contains("NotSetAgain") == true)
			{
			return false;
			}
			byteData = await ResetByteRequestHttps(RequestName, checkAuthority, obj);
			if (byteData == null)
			{
			return false;
			}
			}
			var revertObj = JsonConvert.DeserializeObject<ResponsePack>(Encoding.UTF8.GetString(byteData));
			//检测是否存在错误信息
			return CheckNotEorrorMsg(revertObj, RequestName, listNotShowError, obj);
			}

			/// <summary>
			/// 访问指定接口，返回状态码(出现异常时，返回 Error)
			/// </summary>
			/// <returns>接口的状态码(出现异常时，返回 Error)</returns>
			/// <param name="RequestName">访问地址</param>
			/// <param name="checkAuthority">是否检测权限，该参数不能省略</param>
			/// <param name="obj">一个类</param>
			/// <param name="listNotShowError">
			/// <pra>不需要显示错误的错误类别(接口返回的错误类别),如果包含，则会返回【Success】</pra>
			/// <pra>如果指定有NotSetAgain,则不二次发送(比如断网),然后返回【ErrorEx】</pra>
			/// </param>
			public static async Task<string> GetResultCodeByRequestHttps(string RequestName, bool checkAuthority, object obj, List<string> listNotShowError = null)
			{
			//检测是否已经完成账号信息初始化
			if (UserCenterResourse.UserInfo.InitUserInfoSuccess == false)
			{
			//不管结果怎么样,如果调用了这个函数,需要重头获取Token,所以必须返回失败
			await ReInitUserAccoutInfo();
			return "Error";
			}

			//获取接口的连接模式
			var connectMode = GetHttpConnectMode(checkAuthority);
			//获取从接口那里取到的比特数据
			var byteData = await GettByteResponsePack(RequestName, connectMode, obj);
			if (byteData == null)
			{
			if (listNotShowError != null && listNotShowError.Contains("NotSetAgain") == true)
			{
			return "ErrorEx";
			}
			byteData = await ResetByteRequestHttps(RequestName, checkAuthority, obj);
			if (byteData == null)
			{
			return "Error";
			}
			}
			var revertObj = JsonConvert.DeserializeObject<ResponsePack>(Encoding.UTF8.GetString(byteData));
			return revertObj.StateCode;
			}

			/// <summary>
			/// 访问指定接口，并返回接口把对象已经序列化了的字符串，存在错误信息时，返回null
			/// </summary>
			/// <returns>返回：接口把对象已经序列化了的字符串，存在错误信息时，返回null</returns>
			/// <param name="RequestName">访问地址</param>
			/// <param name="checkAuthority">是否检测权限，该参数不能省略</param>
			/// <param name="obj">一个类</param>
			/// <param name="listNotShowError">
			/// <pra>不需要显示错误的错误类别(接口返回的错误类别),如果包含，则会返回空字符串</pra>
			/// <pra>如果指定有NotSetAgain,则不二次发送(比如断网),然后返回空字符串</pra>
			/// </param>
			public static async Task<string> GetResponseDataByRequestHttps(string RequestName, bool checkAuthority, object obj, List<string> listNotShowError = null)
			{
			//检测是否已经完成账号信息初始化
			if (UserCenterResourse.UserInfo.InitUserInfoSuccess == false)
			{
			//不管结果怎么样,如果调用了这个函数,需要重头获取Token,所以必须返回失败
			await ReInitUserAccoutInfo();
			return null;
			}
			//获取接口的连接模式
			var connectMode = GetHttpConnectMode(checkAuthority);
			//获取从接口那里取到的比特数据
			var byteData = await GettByteResponsePack(RequestName, connectMode, obj);
			if (byteData == null)
			{
			if (listNotShowError != null && listNotShowError.Contains("NotSetAgain") == true)
			{
			return string.Empty;
			}
			byteData = await ResetByteRequestHttps(RequestName, checkAuthority, obj);
			if (byteData == null)
			{
			return null;
			}
			}
			var revertObj = JsonConvert.DeserializeObject<ResponsePack>(Encoding.UTF8.GetString(byteData));
			//检测错误
			bool notError = CheckNotEorrorMsg(revertObj, RequestName, listNotShowError, obj);
			if (notError == false)
			{
			return null;
			}
			if (revertObj == null \|\| revertObj.ResponseData == null)
			{
			return string.Empty;
			}
			return revertObj.ResponseData.ToString();
			}

			/// <summary>
			/// 访问指定接口，并直接返回接口返回的比特，存在错误信息时，返回null
			/// </summary>
			/// <returns>返回：并直接返回接口返回的比特，存在错误信息时，返回null</returns>
			/// <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)
			{
			//检测是否已经完成账号信息初始化
			if (UserCenterResourse.UserInfo.InitUserInfoSuccess == false)
			{
			//不管结果怎么样,如果调用了这个函数,需要重头获取Token,所以必须返回失败
			await ReInitUserAccoutInfo();
			return null;
			}
			//获取接口的连接模式
			var connectMode = GetHttpConnectMode(checkAuthority);
			//获取从接口那里取到的比特数据
			var revertObj = await GettByteResponsePack(RequestName, connectMode, obj);

			if (revertObj == null)
			{
			if (listNotShowError != null && listNotShowError.Contains("NotSetAgain") == true)
			{
			return null;
			}
			//重新发送
			revertObj = await ResetByteRequestHttps(RequestName, checkAuthority, obj);
			if (revertObj == null)
			{
			return null;
			}
			}
			if (revertObj != null && revertObj.Length > 0)
			{
			if (revertObj[0] == '{' && revertObj[revertObj.Length - 1] == '}')
			{
			string data2 = System.Text.Encoding.UTF8.GetString(revertObj);
			var data = JsonConvert.DeserializeObject<ResponsePack>(data2);
			if (data != null && string.IsNullOrEmpty(data.StateCode) == false)
			{
			bool notError = CheckNotEorrorMsg(data, RequestName, listNotShowError, obj);
			if (notError == false)
			{
			return null;
			}
			}
			}
			}
			return revertObj;
			}

			/// <summary>
			/// 私有类型:从新发送(懂的人自然懂，很难解释清楚)
			/// </summary>
			/// <param name="RequestName">访问地址</param>
			/// <param name="checkAuthority">是否检测权限，该参数不能省略</param>
			/// <param name="obj">一个类</param>
			/// <returns></returns>
			private static async Task<byte[]> ResetByteRequestHttps(string RequestName, bool checkAuthority, object obj)
			{
			//获取接口的连接模式
			var connectMode = GetHttpConnectMode(checkAuthority);

			byte[] responsePack = null;
			int count = 0;
			while (true)
			{
			await Task.Delay(1000);
			//调用接口
			responsePack = await GettByteResponsePack(RequestName, connectMode, obj);
			if (responsePack != null)
			{
			break;
			}
			count++;
			if (count == 3)
			{
			Application.RunOnMainThread(() =>
			{
			//网络不稳定,请稍后再试
			string msg = Language.StringByID(R.MyInternationalizationString.uNetIsUnStabilityAndDoAgain);
			var control = new ShowMsgControl(ShowMsgType.Tip, msg);
			control.Show();
			});
			break;
			}
			}
			return responsePack;
			}

			/// <summary>
			/// 获取从接口那里取到的内容
			/// </summary>
			/// <returns>获取从接口那里取到的文本内容</returns>
			/// <param name="RequestName">访问地址</param>
			/// <param name="connectMode">接口的连接模式</param>
			/// <param name="obj">一个类</param>
			private static async Task<byte[]> GettByteResponsePack(string RequestName, HttpConnectMode connectMode, object obj)
			{
			try
			{
			//序列化对象
			var requestJson = JsonConvert.SerializeObject(obj);
			//访问接口
			byte[] result = null;
			if (connectMode == HttpConnectMode.Normal)
			{
			//普通访问
			result = await CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync(RequestName, Encoding.UTF8.GetBytes(requestJson));
			}
			else if (connectMode == HttpConnectMode.Admin)
			{
			//以管理员的身份访问，自身是成员
			result = await CommonPage.Instance.RequestZigbeeHttpsByAdmin(RequestName, Encoding.UTF8.GetBytes(requestJson));
			}
			return result;
			}
			catch (Exception ex)
			{
			Console.WriteLine(ex.Message);
			return null;
			}
			}

			/// <summary>
			/// 检测是否存在错误信息,并显示错误
			/// </summary>
			/// <returns>是否存在错误信息</returns>
			/// <param name="revertObj">从接口接收到的数据</param>
			/// <param name="RequestName">请求接口</param>
			/// <param name="listNotShowError">不需要显示错误的错误类别(接口返回的错误类别)</param>
			/// <param name="pra">请求的参数</param>
			public static bool CheckNotEorrorMsg(ResponsePack revertObj, string RequestName, List<string> listNotShowError = null, object pra = null)
			{
			if (listNotShowError != null && listNotShowError.Contains("NotCheck") == true)
			{
			//不检测
			return true;
			}
			if (revertObj == null)
			{
			Application.RunOnMainThread(() =>
			{
			//网络不稳定,请稍后再试
			string msg = Language.StringByID(R.MyInternationalizationString.uNetIsUnStabilityAndDoAgain);
			var control = new ShowMsgControl(ShowMsgType.Tip, msg);
			control.Show();
			});

			return false;
			}
			if (revertObj.StateCode.ToUpper() != "SUCCESS")
			{
			if (listNotShowError != null && listNotShowError.Contains(revertObj.StateCode) == true)
			{
			//不显示错误,然后返回true
			return true;
			}
			Application.RunOnMainThread(() =>
			{
			if (HdlCheckLogic.Current.IsAccountLoginOut() == true)
			{
			//如果用户已经退出了登陆,则不处理
			return;
			}
			string msg = IMessageCommon.Current.GetMsgByRequestName(RequestName, revertObj, pra);
			if (msg != null)
			{
			var control = new ShowMsgControl(ShowMsgType.Tip, msg);
			control.Show();

			//无效登录Token
			if (revertObj.StateCode == "NoLogin")
			{
			UserCenterLogic.ReLoginAgain(Config.Instance.Account, false);
			}
			}
			});

			return false;
			}
			return true;
			}

			/// <summary>
			/// 获取接口的连接模式
			/// </summary>
			/// <param name="checkAuthority">是否检测权限</param>
			/// <returns></returns>
			public static HttpConnectMode GetHttpConnectMode(bool checkAuthority)
			{
			if (checkAuthority == false)
			{
			return HttpConnectMode.Normal;
			}
			if (Config.Instance.Home.IsOthreShare == true)
			{
			return HttpConnectMode.Admin;
			}
			return HttpConnectMode.Normal;
			}

			#endregion

			#region ■ 添加界面相关_______________________

			/// <summary>
			/// 检测能否添加画面
			/// </summary>
			/// <returns>true:可以追加 false:不可追加</returns>
			/// <param name="form">Form</param>
			public static bool CheckCanAddForm(CommonFormBase form)
			{
			//获取画面英文名字
			string formName = GetFormName(form);

			//二重追加不可
			if (UserCenterResourse.DicActionForm.ContainsKey(formName) == false)
			{
			return true;
			}
			//暂时这样弄看看，如果重复，则关闭掉原来的界面
			var formTemp = UserCenterResourse.DicActionForm[formName];
			formTemp.CloseForm();
			UserCenterResourse.DicActionForm.Remove(formName);

			return true;
			}

			/// <summary>
			/// 把打开的画面添加到内存中
			/// </summary>
			/// <param name="form">Form.</param>
			public static void AddActionForm(CommonFormBase form)
			{
			//获取画面英文名字
			string formName = GetFormName(form);

			//二重追加不可
			if (UserCenterResourse.DicActionForm.ContainsKey(formName) == false)
			{
			form.FormID = formName;
			//内存添加
			UserCenterResourse.DicActionForm[formName] = form;
			//添加画面时，它自身就是激活的界面
			UserCenterResourse.NowActionFormID = form.FormID;

			UserCenterResourse.listActionFormId.Add(form.FormID);
			}
			}

			/// <summary>
			/// 从列表中移除画面
			/// </summary>
			/// <param name="form">Form</param>
			public static void RemoveActionForm(CommonFormBase form)
			{
			//获取画面英文名字
			string formName = GetFormName(form);

			if (UserCenterResourse.DicActionForm.ContainsKey(formName) == true)
			{
			//刷新当前正在操作的画面ID
			if (UserCenterResourse.NowActionFormID == UserCenterResourse.DicActionForm[formName].FormID)
			{
			//向前推一位即为下一个激活的界面
			int index = UserCenterResourse.listActionFormId.IndexOf(UserCenterResourse.NowActionFormID) - 1;
			//初始值
			UserCenterResourse.NowActionFormID = string.Empty;
			if (index >= 0)
			{
			var actionForm = UserView.HomePage.Instance.GetChildren(UserView.HomePage.Instance.ChildrenCount - 1);
			if (actionForm != null && actionForm is CommonFormBase)
			{
			string formId = ((CommonFormBase)actionForm).FormID;
			//对应徐梅继承了底层，但是不初始化数据的问题
			if (UserCenterResourse.listActionFormId.Contains(formId) == true)
			{
			//调用界面重新激活的函数
			CallFormActionAgainEvent(form, index);
			}
			}
			else if (actionForm != null && actionForm is UserView.UserPage)
			{
			//这里它已经退到主页了
			if (UserCenterResourse.listActionFormId.Contains("UserMainForm") == true//个人中心
			\|\| UserCenterResourse.listActionFormId.Contains("HomeMainPageForm") == true)//
			{
			//调用界面重新激活的函数
			CallFormActionAgainEvent(form, index);
			}
			}
			}
			}
			//移除ID
			UserCenterResourse.listActionFormId.Remove(UserCenterResourse.DicActionForm[formName].FormID);
			//移除画面
			UserCenterResourse.DicActionForm.Remove(formName);
			}
			}

			/// <summary>
			/// 调用界面重新激活的函数
			/// </summary>
			/// <param name="form">关闭的界面对象</param>
			/// <param name="index">当前需要重新激活界面的索引</param>
			private static void CallFormActionAgainEvent(CommonFormBase form, int index)
			{
			//设置当前激活的画面ID
			UserCenterResourse.NowActionFormID = UserCenterResourse.listActionFormId[index];
			//追加条件一:关闭的界面为EditorCommonForm的时候才处理
			if ((form is EditorCommonForm) && UserCenterResourse.DicActionForm.ContainsKey(UserCenterResourse.NowActionFormID) == true)
			{
			try
			{
			var Myform = UserCenterResourse.DicActionForm[UserCenterResourse.NowActionFormID] as EditorCommonForm;
			//重置左滑使能
			Myform.ScrollEnabled = Myform.ScrollEnabled;
			//触发界面再次激活的事件
			int value = Myform.FormActionAgainEvent();
			if (value == 1)
			{
			//Log出力
			HdlLogLogic.Current.WriteLog(1, Myform.FormID + " 被激活");
			}
			}
			catch (Exception ex)
			{
			//出现未知错误,数据丢失
			var alert = new ShowMsgControl(ShowMsgType.Error, Language.StringByID(R.MyInternationalizationString.uUnKnownError));
			alert.Show();

			//Log出力
			HdlLogLogic.Current.WriteLog(ex, "界面重新激活异常");
			}
			}
			}

			/// <summary>
			/// 获取画面英文名字
			/// </summary>
			/// <returns>The form name.</returns>
			/// <param name="form">Form.</param>
			public static string GetFormName(CommonFormBase form)
			{
			if (form.FormID != string.Empty)
			{
			return form.FormID;
			}
			//将命名空间去掉
			string[] Arry = form.ToString().Split(new string[] { "." }, StringSplitOptions.RemoveEmptyEntries);
			string formName = Arry[Arry.Length - 1].Trim();
			return formName;
			}

			/// <summary>
			/// 获取当前正在激活的画面
			/// </summary>
			/// <returns></returns>
			public static CommonFormBase GetNowActionForm()
			{
			if (UserCenterResourse.DicActionForm.ContainsKey(UserCenterResourse.NowActionFormID) == true)
			{
			return UserCenterResourse.DicActionForm[UserCenterResourse.NowActionFormID];
			}
			return null;
			}

			#endregion

			#region ■ 刷新本地缓存_______________________
			/// <summary>
			/// 刷新本地所有缓存
			/// </summary>
			public static void RefreshAllMemory()
			{
			//刷新住宅对象
			RefreshHomeObject();
			//刷新本地网关文件
			HdlGatewayLogic.Current.ReFreshByLocal();
			//刷新本地设备
			Common.LocalDevice.Current.ReFreshByLocal();
			//需优先于刷新房间,同步云端的网关id，如果本地拥有云端不存在的id，则表示应该被换绑了，直接删除
			HdlGatewayLogic.Current.SynchronizeDbGateway();
			//从本地重新加载全部的房间
			HdlRoomLogic.Current.RefreshAllRoomByLocation();
			}

			/// <summary>
			/// 刷新住宅对象
			/// </summary>
			public static void RefreshHomeObject()
			{
			//备份的数据，有可能是主人自己上传的，如果管理员登陆时，他获取的备份数据有点特殊
			//比如下面这三个东西在主账号那里是不需要的
			bool isOthreShare = Config.Instance.Home.IsOthreShare;
			int accountType = Config.Instance.Home.AccountType;
			string mainMark = Config.Instance.Home.MainUserDistributedMark;
			double Longitude = Config.Instance.Home.Longitude;
			double Latitude = Config.Instance.Home.Latitude;
			//还原住宅对象
			Config.Instance.Home = House.GetHouseByHouseId(Config.Instance.Home.Id);
			Config.Instance.Home.IsOthreShare = isOthreShare;
			Config.Instance.Home.AccountType = accountType;
			Config.Instance.Home.MainUserDistributedMark = mainMark;
			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

			#region ■ 重新登录___________________________

			/// <summary>
			/// 重新登录
			/// </summary>
			/// <param name="account">账号</param>
			/// <param name="noticeDb">是否通知云端</param>
			public static void ReLoginAgain(string account = "", bool noticeDb = true)
			{
			if (Config.Instance.Home.IsVirtually == true)
			{
			//如果是虚拟住宅
			HdlThreadLogic.Current.RunMain(() =>
			{
			//收起左菜单
			CommonPage.Instance.CloseLeftMenu();
			//关闭所有打开了的界面
			CloseAllOpenForm();

			//显示登陆画面
			var formLogin = new Login.AccountLogin();
			Shared.Common.CommonPage.Instance.AddChidren(formLogin);
			formLogin.ShowForm(account);
			});
			return;
			}
			UserCenterResourse.AccountOption.OldAccountId = string.Empty;
			//关闭所有接收
			HdlGatewayReceiveLogic.Current.RemoveAllEvent();
			//清除升级列表
			FirmwareUpdateResourse.dicUpdateList.Clear();

			HdlThreadLogic.Current.RunThread(async () =>
			{
			//检测APP是否能够退出
			while (UserCenterResourse.AccountOption.AppCanSignout == false)
			{
			await Task.Delay(500);
			}
			//设定一个时间
			Config.Instance.LoginDateTime = new DateTime(1970, 1, 1);
			Config.Instance.Save();

			//清空当前住宅id
			Shared.Common.Config.Instance.HomeId = string.Empty;
			HdlGatewayLogic.Current.ClearAllRealGateway();
			try
			{
			//断开远程Mqtt连接
			ZigBee.Device.ZbGateway.DisConnectRemoteMqttClient();
			}
			catch { }

			HdlThreadLogic.Current.RunMain(() =>
			{
			//收起左菜单
			CommonPage.Instance.CloseLeftMenu();
			//关闭所有打开了的界面
			CloseAllOpenForm();

			//显示登陆画面
			var formLogin = new Login.AccountLogin();
			Shared.Common.CommonPage.Instance.AddChidren(formLogin);
			formLogin.ShowForm(account);
			});

			if (noticeDb == true)
			{
			//通知云端，已经退出登陆
			var result = await CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync("ZigbeeUsers/SignOut", null, "GET");
			}
			});
			}

			/// <summary>
			/// 关闭所有打开了的界面
			/// </summary>
			/// <param name="tagetFrom">目标界面,如果指定了的话,则关闭目标界面上层的全部界面(它自身不关闭)</param>
			public static void CloseAllOpenForm(string tagetFrom = null)
			{
			while (UserView.HomePage.Instance.ChildrenCount > 0)
			{
			var view = UserView.HomePage.Instance.GetChildren(UserView.HomePage.Instance.ChildrenCount - 1);
			//(因底层控件修改了, 父控件移除时, 不触发子控件的移除事件)
			if (view is ViewGroup)
			{
			//关闭加载在ViewGroup里面的自定义界面Form
			CloseViewGroupChildren((ViewGroup)view);
			}

			if (view is CommonFormBase)
			{
			if (((CommonFormBase)view).FormID == tagetFrom)
			{
			//只关闭到指定目标界面
			return;
			}
			((CommonFormBase)view).CloseForm();
			}
			else if (view is UserView.UserPage)
			{
			return;
			}
			else
			{
			view.RemoveFromParent();
			}
			}
			}

			/// <summary>
			/// 关闭加载在ViewGroup里面的自定义界面Form(因底层控件修改了,父控件移除时,不触发子控件的移除事件)
			/// </summary>
			/// <param name="group"></param>
			private static void CloseViewGroupChildren(ViewGroup group)
			{
			for (int i = 0; i < group.ChildrenCount; i++)
			{
			var view = group.GetChildren(i);
			if (view is CommonFormBase)
			{
			((CommonFormBase)view).CloseForm();
			i--;
			}
			}
			}

			#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>
			/// 拼接网关回复超时的信息
			/// </summary>
			/// <param name="errorMsg">错误信息</param>
			/// <param name="resultData">网关返回的resultData,里面有【errorMessageBase】这个东西的那种对象</param>
			/// <param name="strResultData">网关返回的resultData,里面的【errorMessageBase】的值,设定有此值时，resultData无效</param>
			/// <param name="addBrackets">是否添加括号</param>
			/// <returns></returns>
			public static string CombineGatewayTimeOutMsg(string errorMsg, object resultData, string strResultData = null, bool addBrackets = true)
			{
			if (resultData == null && strResultData == null)
			{
			return errorMsg;
			}

			string errorMsgBase = strResultData;
			if (errorMsgBase == null)
			{
			Type myType = resultData.GetType();
			object errorObj = myType.InvokeMember("errorMessageBase", System.Reflection.BindingFlags.GetField, null, resultData, null);
			if (errorObj == null)
			{
			return errorMsg;
			}
			errorMsgBase = errorObj.ToString();
			}

			if (errorMsgBase.Contains("回复超时") == false)
			{
			//只有回复超时的时候才会加上
			return errorMsg;
			}
			errorMsg += "\r\n";
			if (addBrackets == true)
			{
			//(网关回复超时,请稍后再试)
			return errorMsg + "(" + Language.StringByID(R.MyInternationalizationString.uGatewayResponseTimeOut) + ")";
			}
			else
			{
			//网关回复超时,请稍后再试
			return errorMsg + Language.StringByID(R.MyInternationalizationString.uGatewayResponseTimeOut);
			}
			}

			#endregion

			#region ■ 刷新个人中心的内存及线程___________

			/// <summary>
			/// 异步方法执行(仅限切换住宅时调用)，刷新个人中心的内存及线程
			/// </summary>
			/// <param name="ShowPrompted">新追加变量：是否显示提示自动备份的界面</param>
			/// <returns></returns>
			public async static Task<bool> InitUserCenterMenmoryAndThread(bool ShowPrompted = true)
			{
			//如果是虚拟住宅
			if (Config.Instance.Home.IsVirtually == true)
			{
			//初始化虚拟住宅的个人中心的数据(切换住宅使用)
			InitUserCenterMenmoryByVirtualHome();
			return true;
			}

			//APP缓存加载开始
			UserCenterResourse.AccountOption.AppCanSignout = false;
			//还原远程连接权限变量
			ZigBee.Device.ZbGateway.AllowRemoteCtrl = true;

			//只有在住宅ID不一样的时候才做这个操作
			if (Common.Config.Instance.HomeId != UserCenterResourse.AccountOption.OldHomeStringId
			\|\| Common.Config.Instance.Account != UserCenterResourse.AccountOption.OldAccountId)
			{
			try
			{
			//断开远程Mqtt连接
			await ZigBee.Device.ZbGateway.DisConnectRemoteMqttClient();
			}
			catch { }

			//清空所有成员缓存
			ClearAllMemberMemory();

			//加载账号配置信息
			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.ResidenceOption = UserCenterResourse.ResidenceOption.Load();

			//初始化登陆账号的信息
			var hadNet = await InitUserAccoutInfo();
			//如果有网络的话
			if (hadNet == true)
			{
			//重新发送命令去绑定断网情况下备份的网关
			HdlGatewayLogic.Current.ResetComandToBindBackupGateway();
			//读取隐匿配置
			await HdlBackupLogic.Current.LoadHideOption();
			}

			//初始化缓存成员的信息
			InitLocalMemberListInfo();

			//预创建个人中心全部的文件夹
			CreatAllUserCenterDirectory();

			//关闭所有接收
			HdlGatewayReceiveLogic.Current.RemoveAllEvent();
			//刷新安防上报信息
			HdlAlarmsLogic.Current.RefreshAlarmInfo();

			//保存用户的登陆信息到本地
			SaveUserInformationToLocation();

			UserCenterResourse.AccountOption.OldHomeStringId = Common.Config.Instance.HomeId;
			UserCenterResourse.AccountOption.OldAccountId = Common.Config.Instance.Account;

			//同步数据(二次调用没关系)
			int result = -1;
			if (hadNet == true)
			{
			result = await HdlAutoBackupLogic.SynchronizeDbAutoBackupData();
			}

			//初始化本地的网关信息
			HdlGatewayLogic.Current.ReFreshByLocal();
			//初始化本地的设备信息
			Common.LocalDevice.Current.ReFreshByLocal();

			//初始化房间(郭雪城那边不做处理,需要这里特殊执行一步)
			HdlRoomLogic.Current.RefreshAllRoomByLocation();

			if (hadNet == true)
			{
			//同步云端的网关id，如果本地拥有云端不存在的id，则表示应该被换绑了，直接删除
			HdlGatewayLogic.Current.SynchronizeDbGateway();
			}

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

			//0:已经同步过，不需要同步,这个时候需要提示备份
			if (result == 0 && ShowPrompted == true)
			{
			//开启自动备份
			HdlAutoBackupLogic.ShowAutoBackupPromptedForm();
			}
			//显示引导界面
			ShowGuideForm(result);
			}
			//APP缓存加载完成
			UserCenterResourse.AccountOption.AppCanSignout = true;

			return true;
			}

			/// <summary>
			/// 初始化虚拟住宅的个人中心的数据(切换住宅使用)
			/// </summary>
			private static void InitUserCenterMenmoryByVirtualHome()
			{
			//清空所有成员缓存
			ClearAllMemberMemory();
			//预创建个人中心全部的文件夹
			CreatAllUserCenterDirectory();
			//关闭所有接收
			HdlGatewayReceiveLogic.Current.RemoveAllEvent();
			//初始化本地的网关信息
			HdlGatewayLogic.Current.ReFreshByLocal();
			//初始化本地的设备信息
			Common.LocalDevice.Current.ReFreshByLocal();
			//初始化房间(郭雪城那边不做处理,需要这里特殊执行一步)
			HdlRoomLogic.Current.RefreshAllRoomByLocation();
			}

			/// <summary>
			/// 清空所有成员缓存
			/// </summary>
			private static void ClearAllMemberMemory()
			{
			//消息记录重新读取及检测
			ControlCommonResourse.ReadMessageAgain = true;
			ControlCommonResourse.HadNewMessage = false;
			HdlThreadLogic.Current.RunMain(() =>
			{
			for (int i = 0; i < ControlCommonResourse.listMessageManaContr.Count; i++)
			{
			//显示角标特效
			ControlCommonResourse.listMessageManaContr[i].IsSelected = false;
			}
			});

			//当前主页,场景和功能所选择的分支 1:场景 2:功能
			UserCenterResourse.ResidenceOption.HomeMainPageSwitchIndex = 1;
			//当前分类,场景和功能所选择的分支 0:场景 1:功能 2:自动化
			UserCenterResourse.ResidenceOption.CategoryPageSwitchIndex = 0;
			}

			#endregion

			#region ■ 初始化登陆账号的信息_______________

			/// <summary>
			/// 初始化登陆账号的信息
			/// </summary>
			/// <returns></returns>
			private async static Task<bool> InitUserAccoutInfo()
			{
			//初始化个人信息的标识
			UserCenterResourse.UserInfo.InitUserInfoSuccess = false;
			//获取本地记录的用户信息
			UserCenterResourse.UserInfo = GetUserInformationFromLocation();
			UserCenterResourse.UserInfo.UserIconFile = System.IO.Path.Combine(UserCenterResourse.AccountOption.UserPictruePath, "Admin.png");

			//获取登录账号的信息
			var pra = new AccountInfoPra();
			//序列化对象
			var requestJson = JsonConvert.SerializeObject(pra);
			//访问接口
			byte[] byteData = await CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync("ZigbeeUsers/GetAccountInfo", Encoding.UTF8.GetBytes(requestJson));
			if (byteData == null)
			{
			return false;
			}
			//检测错误
			var revertObj = JsonConvert.DeserializeObject<ResponsePack>(Encoding.UTF8.GetString(byteData));
			if (revertObj.StateCode.ToUpper() != "SUCCESS")
			{
			return false;
			}

			var userInfo = Newtonsoft.Json.JsonConvert.DeserializeObject<UserInformation>(revertObj.ResponseData.ToString());
			userInfo.Account = Common.Config.Instance.Account;
			if (string.IsNullOrEmpty(userInfo.UserName) == true)
			{
			//没有昵称的时候，把账号作为昵称
			userInfo.UserName = Common.Config.Instance.Account;
			}

			if (Common.Config.Instance.Home.IsOthreShare == false)
			{
			//身份:管理员
			userInfo.AuthorityNo = 1;
			userInfo.AuthorityText = Language.StringByID(R.MyInternationalizationString.Administrator);
			}
			else if (Common.Config.Instance.Home.AccountType == 1)
			{
			//身份:成员(拥有管理员权限)
			userInfo.AuthorityNo = 2;
			userInfo.AuthorityText = Language.StringByID(R.MyInternationalizationString.uMemberHadActionAuthority);
			}
			else
			{
			//身份:成员
			userInfo.AuthorityNo = 3;
			userInfo.AuthorityText = Language.StringByID(R.MyInternationalizationString.uMember);
			}

			if (UserCenterResourse.UserInfo.AuthorityNo != userInfo.AuthorityNo)
			{
			//如果登陆的账号的权限和上一次的不一样,则删除本地这个住宅全部的文件,从头再来
			string dirPath = CombinePath();
			if (System.IO.Directory.Exists(dirPath) == true)
			{
			try
			{
			//同步数据的判断文件(以防万一删除整个文件夹失败的时候,这个文件被删的话,应该没什么大问题)
			string SynchronizeFile = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.AutoDownLoadBackupCheckFile);
			//如果本地已经拥有了这个文件，则说明不是新手机，不再自动还原
			if (System.IO.File.Exists(SynchronizeFile) == true)
			{
			System.IO.File.Delete(SynchronizeFile);
			}
			//删除整个文件夹
			System.IO.Directory.Delete(dirPath, true);
			}
			catch { }
			//创建住宅文件夹
			Global.CreateHomeDirectory(Config.Instance.HomeId);
			//预创建个人中心全部的文件夹
			CreatAllUserCenterDirectory();
			}
			}
			if (string.IsNullOrEmpty(userInfo.UserName) == true)
			{
			//没有昵称的话,把账号丢过去
			userInfo.UserName = userInfo.Account;
			}

			UserCenterResourse.UserInfo = userInfo;
			UserCenterResourse.UserInfo.UserIconFile = System.IO.Path.Combine(UserCenterResourse.AccountOption.UserPictruePath, "Admin.png");
			if (UserCenterResourse.UserInfo.HeadImage != null)
			{
			//写入头像内容
			Shared.IO.FileUtils.WriteFileByBytes(UserCenterResourse.UserInfo.UserIconFile, UserCenterResourse.UserInfo.HeadImage);
			}
			UserCenterResourse.UserInfo.HeadImage = null;
			//手势密码
			UserCenterResourse.AccountOption.GestureAuthentication = UserCenterResourse.UserInfo.GesturePwd == null ? string.Empty : UserCenterResourse.UserInfo.GesturePwd;
			UserCenterResourse.UserInfo.GesturePwd = null;
			//密码验证
			UserCenterResourse.AccountOption.PswAuthentication = UserCenterResourse.UserInfo.StringPwd == null ? string.Empty : UserCenterResourse.UserInfo.StringPwd;
			UserCenterResourse.UserInfo.StringPwd = null;

			//初始化管理员控制主人的连接地址(因为这个连接Token是不会改变的,所以只需要初始化一次)
			bool flage = await InitAdminConnectMainInfo();
			//初始化个人信息的标识
			UserCenterResourse.UserInfo.InitUserInfoSuccess = flage;

			return flage;
			}

			/// <summary>
			/// 从本地获取用户的登陆信息
			/// </summary>
			/// <returns></returns>
			private static UserInformation GetUserInformationFromLocation()
			{
			string fileName = CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.UserInfoFile);
			var value = LoadFileContent(fileName);
			if (value == null)
			{
			return new UserInformation();
			}
			var info = Newtonsoft.Json.JsonConvert.DeserializeObject<UserInformation>(value);
			return info;
			}

			/// <summary>
			/// 重新初始化登陆账号的信息(旨在对应那一瞬间,网络不好,导致误判的情况)
			/// </summary>
			/// <returns></returns>
			private async static Task<bool> ReInitUserAccoutInfo()
			{
			//重新初始化账号信息
			var result = await InitUserAccoutInfo();
			if (result == false)
			{
			return result;
			}
			//同步云端的网关id，如果本地拥有云端不存在的id，则表示应该被换绑了，直接删除
			HdlGatewayLogic.Current.SynchronizeDbGateway();
			//初始化个人信息的标识
			UserCenterResourse.UserInfo.InitUserInfoSuccess = true;

			return true;
			}

			/// <summary>
			/// 保存用户的登陆信息到本地
			/// </summary>
			private static void SaveUserInformationToLocation()
			{
			string fullName = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.UserInfoFile);
			//写入内容
			SaveFileContent(fullName, UserCenterResourse.UserInfo);

			//搞一下主人的默认头像
			string defultFile = IO.FileUtils.GetImageFilePath("Center/Admin.png");
			if (defultFile == string.Empty)
			{
			return;
			}
			if (System.IO.File.Exists(UserCenterResourse.UserInfo.UserIconFile) == true)
			{
			return;
			}
			//复制过去
			System.IO.File.Copy(defultFile, UserCenterResourse.UserInfo.UserIconFile);
			}

			#endregion

			#region ■ 初始化管理员权限远程连接___________

			/// <summary>
			/// 初始化管理员权限远程连接主人的信息
			/// </summary>
			/// <returns></returns>
			private static async Task<bool> InitAdminConnectMainInfo()
			{
			if (UserCenterResourse.UserInfo.AuthorityNo != 2 && UserCenterResourse.UserInfo.AuthorityNo != 3)
			{
			//时代变了,这里管理员和成员都能调用
			return true;
			}
			var pra = new
			{
			CommonPage.RequestVersion,
			LoginAccessToken = Config.Instance.Token,
			MainAccountId = Config.Instance.Home.MainUserDistributedMark,
			SharedHid = Config.Instance.Home.Id
			};

			//序列化对象
			var requestJson = JsonConvert.SerializeObject(pra);
			//访问接口
			byte[] byteData = await CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync("App/GetSharedHomeApiControl", Encoding.UTF8.GetBytes(requestJson));
			if (byteData == null)
			{
			return false;
			}
			//检测错误
			var revertObj = JsonConvert.DeserializeObject<ResponsePack>(Encoding.UTF8.GetString(byteData));
			if (revertObj.StateCode.ToUpper() != "SUCCESS")
			{
			return false;
			}

			//分享链接
			var info = JsonConvert.DeserializeObject<MemberAdministratorResult>(revertObj.ResponseData.ToString());
			Config.Instance.AdminRequestBaseUrl = info.RequestBaseUrl;
			Config.Instance.AdminRequestToken = info.RequestToken;

			return true;
			}

			#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))
			using System;
			using Shared.Common;
			using Newtonsoft.Json;
			using Shared.Common.ResponseEntity;
			using System.Collections.Generic;
			using System.Text;
			using Shared.IOS.HDLFVSDK;
			namespace Shared.Phone.UserCenter
			{
			/// <summary>
			/// 个人中心逻辑类
			/// </summary>
			public class UserCenterLogic
			{
			#region ■ 云端接口访问_______________________

			/// <summary>
			/// 访问指定接口，返回是否成功
			/// </summary>
			/// <returns>是否成功</returns>
			/// <param name="RequestName">访问地址</param>
			/// <param name="checkAuthority">是否检测权限，该参数不能省略</param>
			/// <param name="obj">一个类</param>
			/// <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 = true)
			{
			//获取接口的连接模式
			var connectMode = GetHttpConnectMode(checkAuthority);
			//获取从接口那里取到的比特数据
			var byteData = GettByteResponsePack(RequestName, connectMode, obj);
			if (byteData == null)
			{
			System.IO.Directory.CreateDirectory(UserCenterResourse.AccountOption.UserPictruePath);
			}
			}

			#endregion

			#region ■ 获取控制主人账号的Token____________

			/// <summary>
			/// 获取控制主人账号的Token
			/// </summary>
			/// <returns></returns>
			public static string GetConnectMainToken()
			{
			//启用管理员权限
			if (Config.Instance.Home.IsOthreShare == true)
			{
			return Config.Instance.AdminRequestToken;
			}
			return Config.Instance.Token;
			}

			#endregion

			#region ■ 引导界面___________________________

			/// <summary>
			/// 显示引导界面
			/// </summary>
			/// <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);
			if (System.IO.File.Exists(checkFile) == true)
			{
			//不需要显示
			return;
			}
			if (result == 2 && Config.Instance.Home.IsOthreShare == false)
			{
			HdlThreadLogic.Current.RunMain(() =>
			{
			var form = new Guide.GuideHouseForm();
			form.ShowFrom();
			});
			}

			//创建一个空文件(标识已经完成引导)
			var file = System.IO.File.Create(checkFile);
			file.Close();
			}

			#endregion

			#region ■ 16进制转化_________________________

			/// <summary>
			/// 将16进制的文本翻译为正常文本
			/// </summary>
			/// <param name="hexText">16进制的文本</param>
			/// <param name="count">以多少个字节为一组</param>
			/// <returns></returns>
			public static string TranslateHexadecimalIntoText(string hexText, int count = 2)
			{
			string textValue = string.Empty;
			while (hexText.Length > 0)
			{
			string temp = hexText.Substring(0, count);
			hexText = hexText.Substring(count);
			int value = Convert.ToInt32(temp, 16);
			textValue += ((char)value).ToString();
			}
			return textValue;
			}

			/// <summary>
			/// 将文本翻译为16进制的文本
			/// </summary>
			/// <param name="text">指定文本</param>
			/// <returns></returns>
			public static string TranslateTextIntoHexadecimal(string text)
			{
			string textValue = string.Empty;
			foreach (char c in text)
			{
			int value = Convert.ToInt32(c);
			textValue += Convert.ToString(value, 16);
			}
			return textValue;
			}

			#endregion

			#region ■ 加密和解密_________________________

			/// <summary>
			/// 加密密码
			/// </summary>
			/// <param name="keys"></param>
			/// <param name="strPsw"></param>
			/// <returns></returns>
			public static string EncryptPassword(string keys, string strPsw)
			{
			try
			{
			if (strPsw == string.Empty)
			{
			return strPsw;
			}
			var des = new System.Security.Cryptography.DESCryptoServiceProvider();
			byte[] inputByteArray = Encoding.Default.GetBytes(strPsw);
			des.Key = ASCIIEncoding.ASCII.GetBytes(keys);
			des.IV = ASCIIEncoding.ASCII.GetBytes(keys);
			var ms = new System.IO.MemoryStream();
			var cs = new System.Security.Cryptography.CryptoStream(ms, des.CreateEncryptor(), System.Security.Cryptography.CryptoStreamMode.Write);
			cs.Write(inputByteArray, 0, inputByteArray.Length);
			cs.FlushFinalBlock();
			StringBuilder ret = new StringBuilder();
			foreach (byte b in ms.ToArray())
			{
			ret.AppendFormat("{0:X2}", b);
			}
			return ret.ToString().ToLower();
			}
			catch { return strPsw; }
			}

			/// <summary>
			/// 解密密码
			/// </summary>
			/// <param name="strPsw"></param>
			/// <returns></returns>
			public static string DecryptPassword(string keys, string strPsw)
			{
			try
			{
			if (strPsw == string.Empty)
			{
			return strPsw;
			}
			var des = new System.Security.Cryptography.DESCryptoServiceProvider();

			byte[] inputByteArray = new byte[strPsw.Length / 2];
			for (int x = 0; x < strPsw.Length / 2; x++)
			{
			int i = (Convert.ToInt32(strPsw.Substring(x * 2, 2), 16));
			inputByteArray[x] = (byte)i;
			}

			des.Key = ASCIIEncoding.ASCII.GetBytes(keys);
			des.IV = ASCIIEncoding.ASCII.GetBytes(keys);
			var ms = new System.IO.MemoryStream();
			var cs = new System.Security.Cryptography.CryptoStream(ms, des.CreateDecryptor(), System.Security.Cryptography.CryptoStreamMode.Write);
			cs.Write(inputByteArray, 0, inputByteArray.Length);
			cs.FlushFinalBlock();

			StringBuilder ret = new StringBuilder();

			return System.Text.Encoding.Default.GetString(ms.ToArray());
			}
			catch { return strPsw; }
			}
			#endregion

			#region ■ 时间转换___________________________

			/// <summary>
			/// 将utc时间类型的字符串,转换为本地时间
			/// </summary>
			/// <param name="timeText"></param>
			/// <returns></returns>
			public static DateTime ConvertUtcTimeToLocalTime(string timeText)
			{
			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 = Newtonsoft.Json.JsonConvert.SerializeObject(obj);
			var byteData = System.Text.Encoding.UTF8.GetBytes(data);
			//写入内容
			Shared.IO.FileUtils.WriteFileByBytes(fullName, byteData);
			}

			/// <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
			}
			}
			if (setAgain == false)
			{
			//当前无法访问网络
			ShowNotNetMsg(RequestName, listNotShowError);
			return false;
			}
			byteData = ResetByteRequestHttps(RequestName, checkAuthority, obj);
			if (byteData == null)
			{
			return false;
			}
			}
			var revertObj = JsonConvert.DeserializeObject<ResponsePack>(Encoding.UTF8.GetString(byteData));
			//检测是否存在错误信息
			return CheckNotEorrorMsg(revertObj, RequestName, listNotShowError, obj);
			}

			/// <summary>
			/// 访问指定接口，返回状态码(出现异常时，返回 Error)
			/// </summary>
			/// <returns>接口的状态码(出现异常时，返回 Error)</returns>
			/// <param name="RequestName">访问地址</param>
			/// <param name="checkAuthority">是否检测权限，该参数不能省略</param>
			/// <param name="obj">一个类</param>
			/// <param name="listNotShowError">不需要显示错误的错误类别(接口返回的错误类别),如果包含，则会返回【true】</param>
			/// <param name="setAgain">当发送失败时,是否重发,默认重发</param>
			/// </param>
			public static string GetResultCodeByRequestHttps(string RequestName, bool checkAuthority, object obj, List<string> listNotShowError = null, bool setAgain = true)
			{
			//获取接口的连接模式
			var connectMode = GetHttpConnectMode(checkAuthority);
			//获取从接口那里取到的比特数据
			var byteData = GettByteResponsePack(RequestName, connectMode, obj);
			if (byteData == null)
			{
			if (setAgain == false)
			{
			//当前无法访问网络
			ShowNotNetMsg(RequestName, listNotShowError);
			return "Error";
			}
			byteData = ResetByteRequestHttps(RequestName, checkAuthority, obj);
			if (byteData == null)
			{
			return "Error";
			}
			}
			var revertObj = JsonConvert.DeserializeObject<ResponsePack>(Encoding.UTF8.GetString(byteData));
			if (revertObj == null)
			{
			return "Error";
			}
			return revertObj.StateCode;
			}

			/// <summary>
			/// 访问指定接口，并返回接口把对象已经序列化了的字符串，存在错误信息时，返回null
			/// </summary>
			/// <returns>返回：接口把对象已经序列化了的字符串，存在错误信息时，返回null</returns>
			/// <param name="RequestName">访问地址</param>
			/// <param name="checkAuthority">是否检测权限，该参数不能省略</param>
			/// <param name="obj">一个类</param>
			/// <param name="listNotShowError">不需要显示错误的错误类别(接口返回的错误类别),如果包含，则会返回【true】</param>
			/// <param name="setAgain">当发送失败时,是否重发,默认重发</param>
			/// </param>
			public static string GetResponseDataByRequestHttps(string RequestName, bool checkAuthority, object obj, List<string> listNotShowError = null, bool setAgain = true)
			{
			//获取接口的连接模式
			var connectMode = GetHttpConnectMode(checkAuthority);
			//获取从接口那里取到的比特数据
			var byteData = GettByteResponsePack(RequestName, connectMode, obj);
			if (byteData == null)
			{
			if (setAgain == false)
			{
			//当前无法访问网络
			ShowNotNetMsg(RequestName, listNotShowError);
			return null;
			}
			byteData = ResetByteRequestHttps(RequestName, checkAuthority, obj);
			if (byteData == null)
			{
			return null;
			}
			}
			var revertObj = JsonConvert.DeserializeObject<ResponsePack>(Encoding.UTF8.GetString(byteData));
			//检测错误
			bool notError = CheckNotEorrorMsg(revertObj, RequestName, listNotShowError, obj);
			if (notError == false)
			{
			return null;
			}
			if (revertObj == null \|\| revertObj.ResponseData == null)
			{
			return null;
			}
			return revertObj.ResponseData.ToString();
			}

			/// <summary>
			/// 访问指定接口，并直接返回接口返回的比特，存在错误信息时，返回null
			/// </summary>
			/// <returns>返回：并直接返回接口返回的比特，存在错误信息时，返回null</returns>
			/// <param name="RequestName">访问地址</param>
			/// <param name="checkAuthority">是否检测权限，该参数不能省略</param>
			/// <param name="obj">一个类</param>
			/// <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 = true)
			{
			//获取接口的连接模式
			var connectMode = GetHttpConnectMode(checkAuthority);
			//获取从接口那里取到的比特数据
			var revertObj = GettByteResponsePack(RequestName, connectMode, obj);

			if (revertObj == null)
			{
			if (setAgain == false)
			{
			//当前无法访问网络
			ShowNotNetMsg(RequestName, listNotShowError);
			return null;
			}
			revertObj = ResetByteRequestHttps(RequestName, checkAuthority, obj);
			if (revertObj == null)
			{
			return null;
			}
			}
			if (revertObj != null && revertObj.Length > 0)
			{
			if (revertObj[0] == '{' && revertObj[revertObj.Length - 1] == '}')
			{
			string data2 = System.Text.Encoding.UTF8.GetString(revertObj);
			var data = JsonConvert.DeserializeObject<ResponsePack>(data2);
			if (data != null && string.IsNullOrEmpty(data.StateCode) == false)
			{
			bool notError = CheckNotEorrorMsg(data, RequestName, listNotShowError, obj);
			if (notError == false)
			{
			return null;
			}
			}
			}
			}
			return revertObj;
			}

			/// <summary>
			/// 私有类型:从新发送(懂的人自然懂，很难解释清楚)
			/// </summary>
			/// <param name="RequestName">访问地址</param>
			/// <param name="checkAuthority">是否检测权限，该参数不能省略</param>
			/// <param name="obj">一个类</param>
			/// <returns></returns>
			private static byte[] ResetByteRequestHttps(string RequestName, bool checkAuthority, object obj)
			{
			//获取接口的连接模式
			var connectMode = GetHttpConnectMode(checkAuthority);

			byte[] responsePack = null;
			int count = 0;
			while (true)
			{
			System.Threading.Thread.Sleep(1000);
			//调用接口
			responsePack = GettByteResponsePack(RequestName, connectMode, obj);
			if (responsePack != null)
			{
			break;
			}
			count++;
			if (count == 3)
			{
			//显示没有网络的Msg
			ShowNotNetMsg(RequestName, null);
			break;
			}
			}
			return responsePack;
			}

			/// <summary>
			/// 获取从接口那里取到的内容
			/// </summary>
			/// <returns>获取从接口那里取到的文本内容</returns>
			/// <param name="RequestName">访问地址</param>
			/// <param name="connectMode">接口的连接模式</param>
			/// <param name="obj">一个类</param>
			private static byte[] GettByteResponsePack(string RequestName, HttpConnectMode connectMode, object obj)
			{
			try
			{
			//序列化对象
			var requestJson = JsonConvert.SerializeObject(obj);
			//访问接口
			byte[] result = null;
			if (connectMode == HttpConnectMode.Normal)
			{
			//普通访问
			result = CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync(RequestName, Encoding.UTF8.GetBytes(requestJson));
			}
			else if (connectMode == HttpConnectMode.Admin)
			{
			//以管理员的身份访问，自身是成员
			result = CommonPage.Instance.RequestZigbeeHttpsByAdmin(RequestName, Encoding.UTF8.GetBytes(requestJson));
			}
			return result;
			}
			catch (Exception ex)
			{
			Console.WriteLine(ex.Message);
			return null;
			}
			}

			/// <summary>
			/// 检测是否存在错误信息,并显示错误
			/// </summary>
			/// <returns>是否存在错误信息</returns>
			/// <param name="revertObj">从接口接收到的数据</param>
			/// <param name="RequestName">请求接口</param>
			/// <param name="listNotShowError">不需要显示错误的错误类别(接口返回的错误类别)</param>
			/// <param name="pra">请求的参数</param>
			public static bool CheckNotEorrorMsg(ResponsePack revertObj, string RequestName, List<string> listNotShowError = null, object pra = null)
			{
			if (listNotShowError != null && listNotShowError.Contains("NotCheck") == true)
			{
			//不检测
			return true;
			}
			if (revertObj == null)
			{
			HdlThreadLogic.Current.RunMain(() =>
			{
			//网络不稳定,请稍后再试
			string msg = Language.StringByID(R.MyInternationalizationString.uNetIsUnStabilityAndDoAgain);
			var control = new ShowMsgControl(ShowMsgType.Tip, msg);
			control.Show();
			}, ShowErrorMode.NO);

			return false;
			}
			if (revertObj.StateCode.ToUpper() != "SUCCESS")
			{
			if (listNotShowError != null && listNotShowError.Contains(revertObj.StateCode) == true)
			{
			//不显示错误,然后返回true
			return true;
			}
			HdlThreadLogic.Current.RunMain(() =>
			{
			if (HdlCheckLogic.Current.IsAccountLoginOut() == true)
			{
			//如果用户已经退出了登陆,则不处理
			return;
			}
			string msg = IMessageCommon.Current.GetMsgByRequestName(RequestName, revertObj, pra);
			if (msg != null)
			{
			var control = new ShowMsgControl(ShowMsgType.Tip, msg);
			control.Show();

			//无效登录Token
			if (revertObj.StateCode == "NoLogin")
			{
			ReLoginAgain(Config.Instance.Account, false);
			}
			}
			}, ShowErrorMode.NO);

			return false;
			}
			return true;
			}

			/// <summary>
			/// 获取接口的连接模式
			/// </summary>
			/// <param name="checkAuthority">是否检测权限</param>
			/// <returns></returns>
			public static HttpConnectMode GetHttpConnectMode(bool checkAuthority)
			{
			if (checkAuthority == false)
			{
			return HttpConnectMode.Normal;
			}
			if (Config.Instance.Home.IsOthreShare == true)
			{
			return HttpConnectMode.Admin;
			}
			return HttpConnectMode.Normal;
			}

			/// <summary>
			/// 显示没有网络的Msg
			/// </summary>
			private static void ShowNotNetMsg(string RequestName, List<string> listNotShowError)
			{
			if (listNotShowError != null && listNotShowError.Contains("NotCheck") == true)
			{
			//不检测
			return;
			}
			//HdlLogLogic.Current.WriteLog(-1, "当前无网络连接:" + RequestName);

			HdlThreadLogic.Current.RunMain(() =>
			{
			// 当前无网络连接,请确认网络
			string msg = Language.StringByID(R.MyInternationalizationString.uNowIsDonotNetworkAndCheckNetwork);
			var control = new ShowMsgControl(ShowMsgType.Tip, msg);
			control.Show();
			}, ShowErrorMode.NO);
			}

			#endregion

			#region ■ 添加界面相关_______________________

			/// <summary>
			/// 检测能否添加画面
			/// </summary>
			/// <returns>true:可以追加 false:不可追加</returns>
			/// <param name="form">Form</param>
			public static bool CheckCanAddForm(CommonFormBase form)
			{
			//获取画面英文名字
			string formId = GetFormID(form);

			//二重追加不可
			if (UserCenterResourse.DicActionForm.ContainsKey(formId) == false)
			{
			return true;
			}
			//暂时这样弄看看，如果重复，则关闭掉原来的界面
			var formTemp = UserCenterResourse.DicActionForm[formId];
			formTemp.CloseForm();
			UserCenterResourse.DicActionForm.Remove(formId);

			return true;
			}

			/// <summary>
			/// 把打开的画面添加到内存中
			/// </summary>
			/// <param name="form">Form.</param>
			public static void AddActionForm(CommonFormBase form)
			{
			//获取画面英文名字
			string formId = GetFormID(form);

			//二重追加不可
			if (UserCenterResourse.DicActionForm.ContainsKey(formId) == false)
			{
			form.FormID = formId;
			//内存添加
			UserCenterResourse.DicActionForm[formId] = form;
			//添加画面时，它自身就是激活的界面
			UserCenterResourse.NowActionFormID = form.FormID;

			UserCenterResourse.listActionFormId.Add(form.FormID);
			}
			}

			/// <summary>
			/// 从列表中移除画面
			/// </summary>
			/// <param name="i_closeForm">关闭的界面</param>
			public static void RemoveActionForm(CommonFormBase i_closeForm)
			{
			//获取画面ID
			string formId = GetFormID(i_closeForm);

			if (UserCenterResourse.DicActionForm.ContainsKey(formId) == true)
			{
			//移除ID
			UserCenterResourse.listActionFormId.Remove(formId);
			//移除画面
			UserCenterResourse.DicActionForm.Remove(formId);
			//清空
			UserCenterResourse.NowActionFormID = string.Empty;

			var actionForm = UserView.HomePage.Instance.GetChildren(UserView.HomePage.Instance.ChildrenCount - 1);
			if (actionForm == null)
			{
			return;
			}
			//如果关闭的界面是DialogCommonForm类型,则不需要触发激活函数
			if (i_closeForm is DialogCommonForm)
			{
			if (actionForm is EditorCommonForm)
			{
			UserCenterResourse.NowActionFormID = GetFormID((EditorCommonForm)actionForm);
			}
			return;
			}
			//关闭的界面为EditorCommonForm的时候
			else if ((i_closeForm is EditorCommonForm) && (actionForm is EditorCommonForm))
			{
			//接下来激活的界面id
			UserCenterResourse.NowActionFormID = GetFormID((CommonFormBase)actionForm);
			try
			{
			var Myform = actionForm as EditorCommonForm;
			//重置左滑使能
			Myform.ScrollEnabled = Myform.ScrollEnabled;
			//触发界面再次激活的事件
			int value = Myform.FormActionAgainEvent();
			if (value == 1)
			{
			//Log出力
			HdlLogLogic.Current.WriteLog(1, Myform.FormID + " 被激活");
			}
			}
			catch (Exception ex)
			{
			//Log出力
			HdlLogLogic.Current.WriteLog(ex, "界面重新激活异常 " + UserCenterResourse.NowActionFormID);
			}
			}
			else if (actionForm is UserView.UserPage)
			{
			//清空
			UserCenterResourse.NowActionFormID = string.Empty;
			//这里它已经退到主页了
			var nowForm = UserView.UserPage.Instance.GetNowActionForm();
			nowForm?.FormActionAgainEvent();
			}
			else
			{
			//清空
			UserCenterResourse.NowActionFormID = string.Empty;
			}
			}
			}

			/// <summary>
			/// 获取画面ID
			/// </summary>
			/// <returns>The form name.</returns>
			/// <param name="form">Form.</param>
			private static string GetFormID(CommonFormBase form)
			{
			if (form.FormID != string.Empty)
			{
			return form.FormID;
			}
			//将命名空间去掉
			string[] Arry = form.ToString().Split(new string[] { "." }, StringSplitOptions.RemoveEmptyEntries);
			string formName = Arry[Arry.Length - 1].Trim();
			return formName;
			}

			/// <summary>
			/// 获取当前正在激活的画面
			/// </summary>
			/// <returns></returns>
			public static CommonFormBase GetNowActionForm()
			{
			if (UserCenterResourse.DicActionForm.ContainsKey(UserCenterResourse.NowActionFormID) == true)
			{
			return UserCenterResourse.DicActionForm[UserCenterResourse.NowActionFormID];
			}
			return null;
			}

			#endregion

			#region ■ 刷新本地缓存_______________________

			/// <summary>
			/// 刷新本地所有缓存(目前此方法只提供给恢复备份数据使用)
			/// </summary>
			public static void RefreshAllMemory()
			{
			//刷新住宅对象
			RefreshHomeObject();
			//根据模板文件,恢复数据
			TemplateData.TemplateCommonLogic.Current.RecoverDataByTemplateBinFile();
			//强制生成设备和网关文件
			TemplateData.TemplateCommonLogic.Current.CreatDeviceAndGatewayFileFromMemoryByForce();
			//刷新本地网关文件
			HdlGatewayLogic.Current.ReFreshByLocal();
			//刷新本地设备
			Common.LocalDevice.Current.ReFreshByLocal();
			//需优先于刷新房间,同步云端的网关id，如果本地拥有云端不存在的id，则表示应该被换绑了，直接删除
			HdlGatewayLogic.Current.SynchronizeDbGateway();
			//从本地重新加载全部的房间
			HdlRoomLogic.Current.RefreshAllRoomByLocation();
			//断开远程Mqtt连接,重新连接
			HdlThreadLogic.Current.RunThread(async () =>
			{
			HdlGatewayLogic.Current.ClearAllRealGatewayConection(true);
			await ZigBee.Device.ZbGateway.CloseRemoteConnectionOnForce();
			}, ShowErrorMode.NO);
			}

			/// <summary>
			/// 刷新住宅对象
			/// </summary>
			public static void RefreshHomeObject()
			{
			var home = HdlResidenceLogic.Current.GetHouseByHouseId(Config.Instance.Home.Id);

			//刷新楼层
			Config.Instance.Home.FloorDics = home.FloorDics;
			Config.Instance.Home.CurrentFloorId = string.Empty;
			if (Config.Instance.Home.TemplateMode == -1)
			{
			Config.Instance.Home.TemplateMode = home.TemplateMode;
			if (Config.Instance.Home.TemplateMode == -1)
			{
			//默认初始值
			Config.Instance.Home.TemplateMode = 1;
			}
			}

			Config.Instance.Home.Save(false);

			//主页需要重新刷新
			UserView.UserPage.Instance.RefreshAllForm = true;
			}

			#endregion

			#region ■ 重新登录___________________________

			/// <summary>
			/// 重新登录
			/// </summary>
			/// <param name="account">账号</param>
			/// <param name="noticeDb">是否通知云端</param>
			public static void ReLoginAgain(string account = "", bool noticeDb = true)
			{
			#if iOS
			//退出全视通登录
			Shared.IOS.HDLFVSDK.Video.Logout();
			#endif
			if (Config.Instance.Home.IsVirtually == true)
			{
			//如果是虚拟住宅
			HdlThreadLogic.Current.RunMain(() =>
			{
			//设定一个时间
			Config.Instance.LoginDateTime = new DateTime(1970, 1, 1);
			Config.Instance.Save();
			//清空当前住宅id
			Config.Instance.HomeId = string.Empty;
			//收起左菜单
			CommonPage.Instance.CloseLeftMenu();
			//关闭全部弹窗
			ShowMsgControl.CloseAllMsgDialog();
			//关闭所有打开了的界面
			CloseAllOpenForm(null, false);

			//显示登陆画面
			var formLogin = new Login.AccountLoginForm();
			Shared.Common.CommonPage.Instance.AddChidren(formLogin);
			formLogin.ShowForm(account);
			});
			return;
			}
			UserCenterResourse.AccountOption.OldAccountId = string.Empty;
			//关闭所有接收
			HdlGatewayReceiveLogic.Current.RemoveAllEvent();
			//清除升级列表
			FirmwareUpdateResourse.dicUpdateList.Clear();

			HdlThreadLogic.Current.RunThread(() =>
			{
			//检测APP是否能够退出
			while (UserCenterResourse.AccountOption.AppCanSignout == false)
			{
			System.Threading.Thread.Sleep(500);
			}
			//设定一个时间
			Config.Instance.LoginDateTime = new DateTime(1970, 1, 1);
			Config.Instance.Save();

			//清空当前住宅id
			Config.Instance.HomeId = string.Empty;
			HdlGatewayLogic.Current.ClearAllRealGatewayConection(false);

			//断开远程Mqtt连接
			HdlThreadLogic.Current.RunThread(async () =>
			{
			await ZigBee.Device.ZbGateway.CloseRemoteConnectionOnForce();
			}, ShowErrorMode.NO);

			HdlThreadLogic.Current.RunMain(() =>
			{
			//收起左菜单
			CommonPage.Instance.CloseLeftMenu();
			//关闭所有打开了的界面
			CloseAllOpenForm(null, false);

			//显示登陆画面
			var formLogin = new Login.AccountLoginForm();
			Shared.Common.CommonPage.Instance.AddChidren(formLogin);
			formLogin.ShowForm(account);
			});

			if (noticeDb == true)
			{
			//通知云端，已经退出登陆
			var result = CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync("ZigbeeUsers/SignOut", null, "GET");
			}
			});
			}

			/// <summary>
			/// 关闭所有打开了的界面
			/// </summary>
			/// <param name="tagetFrom">目标界面,如果指定了的话,则关闭目标界面上层的全部界面(它自身不关闭)</param>
			/// <param name="refreshMainPage">当关闭的界面达到主页时,是否刷新主页</param>
			public static void CloseAllOpenForm(string tagetFrom = null, bool refreshMainPage = true)
			{
			while (UserView.HomePage.Instance.ChildrenCount > 0)
			{
			var view = UserView.HomePage.Instance.GetChildren(UserView.HomePage.Instance.ChildrenCount - 1);
			//(因底层控件修改了, 父控件移除时, 不触发子控件的移除事件)
			if (view is ViewGroup)
			{
			//关闭加载在ViewGroup里面的自定义界面Form
			CloseViewGroupChildren((ViewGroup)view);
			}

			if (view is CommonFormBase)
			{
			if (((CommonFormBase)view).FormID == tagetFrom)
			{
			//只关闭到指定目标界面
			return;
			}
			((CommonFormBase)view).CloseForm();
			}
			else if (view is UserView.UserPage)
			{
			//刷新主页
			if (refreshMainPage == true)
			{
			UserView.UserPage.Instance.ReFreshControl();
			}
			return;
			}
			else
			{
			view.RemoveFromParent();
			}
			}
			}

			/// <summary>
			/// 关闭加载在ViewGroup里面的自定义界面Form(因底层控件修改了,父控件移除时,不触发子控件的移除事件)
			/// </summary>
			/// <param name="group"></param>
			private static void CloseViewGroupChildren(ViewGroup group)
			{
			for (int i = 0; i < group.ChildrenCount; i++)
			{
			var view = group.GetChildren(i);
			if (view is CommonFormBase)
			{
			((CommonFormBase)view).CloseForm();
			i--;
			}
			}
			}

			#endregion

			#region ■ 拼接信息___________________________

			/// <summary>
			/// 拼接网关回复超时的信息
			/// </summary>
			/// <param name="errorMsg">错误信息</param>
			/// <param name="resultData">网关返回的resultData,里面有【errorMessageBase】这个东西的那种对象</param>
			/// <param name="strResultData">网关返回的resultData,里面的【errorMessageBase】的值,设定有此值时，resultData无效</param>
			/// <param name="addBrackets">是否添加括号</param>
			/// <returns></returns>
			public static string CombineGatewayTimeOutMsg(string errorMsg, object resultData, string strResultData = null, bool addBrackets = true)
			{
			if (resultData == null && strResultData == null)
			{
			return errorMsg;
			}

			string errorMsgBase = strResultData;
			if (errorMsgBase == null)
			{
			if (resultData is ReceiptGatewayResult)
			{
			errorMsgBase = string.Empty;
			if (((ReceiptGatewayResult)resultData).ErrorMsgDiv == 0)
			{
			errorMsgBase = "回复超时";
			}
			}
			else
			{
			Type myType = resultData.GetType();
			object errorObj = myType.InvokeMember("errorMessageBase", System.Reflection.BindingFlags.GetField, null, resultData, null);
			if (errorObj == null)
			{
			return errorMsg;
			}
			errorMsgBase = errorObj.ToString();
			}
			}

			if (errorMsgBase.Contains("回复超时") == false)
			{
			//只有回复超时的时候才会加上
			return errorMsg;
			}
			errorMsg += "\r\n";
			if (addBrackets == true)
			{
			//(网关回复超时,请稍后再试)
			return errorMsg + "(" + Language.StringByID(R.MyInternationalizationString.uGatewayResponseTimeOut) + ")";
			}
			else
			{
			//网关回复超时,请稍后再试
			return errorMsg + Language.StringByID(R.MyInternationalizationString.uGatewayResponseTimeOut);
			}
			}

			#endregion

			#region ■ 刷新个人中心的内存及线程___________

			/// <summary>
			/// 异步方法执行(仅限切换住宅时调用)，刷新个人中心的内存及线程
			/// </summary>
			/// <param name="ShowPrompted">新追加变量：是否显示提示自动备份的界面</param>
			/// <returns></returns>
			public static bool InitUserCenterMenmoryAndThread(bool ShowPrompted = true)
			{
			//调用这个方法,都需要重新刷新主页
			UserView.UserPage.Instance.RefreshAllForm = true;

			//添加网络状态监听
			HdlWifiLogic.Current.StartListenNetWork();

			//如果是虚拟住宅
			if (Config.Instance.Home.IsVirtually == true)
			{
			//初始化虚拟住宅的个人中心的数据(切换住宅使用)
			InitUserCenterMenmoryByVirtualHome();
			return true;
			}

			//APP缓存加载开始
			UserCenterResourse.AccountOption.AppCanSignout = false;
			//还原远程连接权限变量
			ZigBee.Device.ZbGateway.AllowRemoteCtrl = true;

			//只有在住宅ID不一样的时候才做这个操作
			if (Common.Config.Instance.HomeId != UserCenterResourse.AccountOption.OldHomeStringId
			\|\| Common.Config.Instance.Account != UserCenterResourse.AccountOption.OldAccountId)
			{
			//借用一下这个变量(检测能否广播到网关)
			UserCenterResourse.DicReceiveGatewayTest = new Dictionary<string, ZigBee.Device.ZbGateway>();
			UserCenterResourse.HideOption.CheckCanReceiveGateway = 1;

			//清空所有成员缓存
			ClearAllMemberMemory();

			//加载账号配置信息
			var optionInfo = UserCenterResourse.AccountOption.Load();
			UserCenterResourse.AccountOption = optionInfo;
			//变更根用户图片目录路径
			UserCenterResourse.AccountOption.UserPictruePath = DirNameResourse.UserPictrueDirectory;

			//加载住宅配置信息
			UserCenterResourse.ResidenceOption = UserCenterResourse.ResidenceOption.Load();

			//预创建个人中心全部的文件夹
			HdlFileLogic.Current.CreatAllUserCenterDirectory();

			//初始化登陆账号的信息
			var hadNet = InitUserAccoutInfo(true);
			//如果有网络的话
			if (hadNet == 1)
			{
			//读取隐匿配置
			//HdlBackupLogic.Current.LoadHideOption();
			//调试：强制开启后台调试App功能
			if (UserCenterResourse.HideOption.StartDebugApp == 1)
			{
			HdlThreadLogic.Current.RunMain(() =>
			{
			var form = new HideOption.HideOptionMainForm();
			form.AddForm();
			});
			ProgressBar.Close(true);
			return false;
			}
			}

			//关闭所有接收
			HdlGatewayReceiveLogic.Current.RemoveAllEvent();
			//刷新安防上报信息
			HdlAlarmsLogic.Current.RefreshAlarmInfo();

			//保存用户的登陆信息到本地
			SaveUserInformationToLocation();

			UserCenterResourse.AccountOption.OldHomeStringId = Common.Config.Instance.HomeId;
			UserCenterResourse.AccountOption.OldAccountId = Common.Config.Instance.Account;

			//同步数据(二次调用没关系)
			int result = -1;
			if (hadNet == 1)
			{
			result = HdlAutoBackupLogic.SynchronizeDbAutoBackupData();
			}

			//初始化本地的网关信息
			HdlGatewayLogic.Current.ReFreshByLocal();
			//初始化本地的设备信息
			LocalDevice.Current.ReFreshByLocal();

			//初始化房间(郭雪城那边不做处理,需要这里特殊执行一步)
			HdlRoomLogic.Current.RefreshAllRoomByLocation();

			if (hadNet == 1)
			{
			//重新发送命令去绑定断网情况下备份的网关
			HdlGatewayLogic.Current.ResetComandToBindBackupGateway();

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

			//读取App最低版本
			HdlFirmwareUpdateLogic.ReadAppLestVersion();
			//读取网关最低版本
			HdlFirmwareUpdateLogic.ReadGatewayLestVersion();
			}

			//断开远程Mqtt连接,重新连接
			HdlThreadLogic.Current.RunThread(async () =>
			{
			HdlGatewayLogic.Current.ClearAllRealGatewayConection(true);
			await ZigBee.Device.ZbGateway.CloseRemoteConnectionOnForce();
			}, ShowErrorMode.NO);

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

			//加载模板缓存
			//TemplateData.TemplateCommonLogic.Current.LoadLocalTemplateMemoryData();

			//0:已经同步过，不需要同步,这个时候需要提示备份
			if (result == 0 && ShowPrompted == true)
			{
			//开启自动备份
			HdlAutoBackupLogic.ShowAutoBackupPromptedForm();
			}
			//显示引导界面
			ShowGuideForm(result);

			//关闭debug广播
			UserCenterResourse.HideOption.CheckCanReceiveGateway = 0;
			System.Threading.Thread.Sleep(30);
			if (hadNet == 1)
			{
			//住宅切换时,检测网关连接情况
			CheckGatewayConnection();
			}
			UserCenterResourse.DicReceiveGatewayTest = null;
			}
			//APP缓存加载完成
			UserCenterResourse.AccountOption.AppCanSignout = true;
			if (Shared.Phone.Device.Logic.Send.If_Exist == "1")
			{
			//以本地状态为主打开GPS服务
			Application.StartGPSLocationService();
			}

			return true;
			}

			/// <summary>
			/// 初始化虚拟住宅的个人中心的数据(切换住宅使用)
			/// </summary>
			private static void InitUserCenterMenmoryByVirtualHome()
			{
			UserCenterResourse.AccountOption.OldHomeStringId = Common.Config.Instance.Home.Id;
			//清空所有成员缓存
			ClearAllMemberMemory();
			//预创建个人中心全部的文件夹
			HdlFileLogic.Current.CreatAllUserCenterDirectory();
			//关闭所有接收
			HdlGatewayReceiveLogic.Current.RemoveAllEvent();
			//初始化本地的网关信息
			HdlGatewayLogic.Current.ReFreshByLocal();
			//初始化本地的设备信息
			Common.LocalDevice.Current.ReFreshByLocal();
			//初始化房间(郭雪城那边不做处理,需要这里特殊执行一步)
			HdlRoomLogic.Current.RefreshAllRoomByLocation();
			//刷新左边刷新房间视图列表
			HdlRoomLogic.Current.RefreshRoomListView();
			//加载模板缓存
			//TemplateData.TemplateCommonLogic.Current.LoadLocalTemplateMemoryData();
			}

			/// <summary>
			/// 清空所有成员缓存
			/// </summary>
			private static void ClearAllMemberMemory()
			{
			//消息记录重新读取及检测
			ControlCommonResourse.ReadMessageAgain = true;
			ControlCommonResourse.HadNewMessage = false;
			HdlThreadLogic.Current.RunMain(() =>
			{
			for (int i = 0; i < ControlCommonResourse.listMessageManaContr.Count; i++)
			{
			//显示角标特效
			ControlCommonResourse.listMessageManaContr[i].IsSelected = false;
			}
			});

			//切换住宅清除之前逻辑缓存数据;
			Common.Logic.LogicList.Clear();
			Common.Logic.LockLogicList.Clear();
			Common.Logic.SoneLogicList.Clear();
			}

			/// <summary>
			/// 住宅切换时,检测网关连接情况
			/// </summary>
			private static void CheckGatewayConnection()
			{
			try
			{
			bool canReceiveGw = false;
			foreach (var gateway in UserCenterResourse.DicReceiveGatewayTest.Values)
			{
			if (gateway.HomeId == Config.Instance.Home.Id)
			{
			//能够搜索得到网关
			canReceiveGw = true;
			break;
			}
			}
			UserCenterResourse.DicReceiveGatewayTest = null;
			//设置远程连接的初始值
			ZigBee.Device.ZbGateway.IsRemote = canReceiveGw == false;
			if (canReceiveGw == false)
			{
			//如果是远程的话,追加等待时间
			System.Threading.Thread.Sleep(1500);
			}
			}
			catch { }
			}

			#endregion

			#region ■ 初始化登陆账号的信息_______________

			/// <summary>
			/// 初始化登陆账号的信息 -1:无网 1:正常 2:其他错误
			/// </summary>
			/// <param name="reLoad">是否从新从本地加载(重新初始化登陆账号的信息,不需要重新加载)</param>
			/// <returns></returns>
			private static int InitUserAccoutInfo(bool reLoad)
			{
			//初始化个人信息的标识
			UserCenterResourse.UserInfo.InitUserInfoSuccess = false;
			if (reLoad == true)
			{
			//获取本地记录的用户信息
			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 = CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync("ZigbeeUsers/GetAccountInfo", Encoding.UTF8.GetBytes(requestJson), "POST", 4);
			if (byteData == null)
			{
			return -1;
			}
			//检测错误
			var revertObj = JsonConvert.DeserializeObject<ResponsePack>(Encoding.UTF8.GetString(byteData));
			if (revertObj.StateCode.ToUpper() != "SUCCESS")
			{
			return 2;
			}

			var userInfo = Newtonsoft.Json.JsonConvert.DeserializeObject<UserInformation>(revertObj.ResponseData.ToString());
			userInfo.Account = Common.Config.Instance.Account;
			if (string.IsNullOrEmpty(userInfo.UserName) == true)
			{
			//没有昵称的时候，把账号作为昵称
			userInfo.UserName = Common.Config.Instance.Account;
			}

			if (Common.Config.Instance.Home.IsOthreShare == false)
			{
			//身份:管理员
			userInfo.AuthorityNo = 1;
			userInfo.AuthorityText = Language.StringByID(R.MyInternationalizationString.Administrator);
			}
			else if (Common.Config.Instance.Home.AccountType == 1)
			{
			//身份:成员(拥有管理员权限)
			userInfo.AuthorityNo = 2;
			userInfo.AuthorityText = Language.StringByID(R.MyInternationalizationString.uMemberHadActionAuthority);
			}
			else
			{
			//身份:成员
			userInfo.AuthorityNo = 3;
			userInfo.AuthorityText = Language.StringByID(R.MyInternationalizationString.uMember);
			}

			//UserInfo.AuthorityNo==0代表本地还没有生成文件,这个时候不需要处理
			if (UserCenterResourse.UserInfo.AuthorityNo != userInfo.AuthorityNo
			&& UserCenterResourse.UserInfo.AuthorityNo != 0)
			{
			//如果登陆的账号的权限和上一次的不一样,则删除本地这个住宅全部的文件,从头再来
			string dirPath = Config.Instance.FullPath;
			if (System.IO.Directory.Exists(dirPath) == true)
			{
			try
			{
			//同步数据的判断文件(以防万一删除整个文件夹失败的时候,这个文件被删的话,应该没什么大问题)
			string SynchronizeFile = DirNameResourse.AutoDownLoadBackupCheckFile;
			//如果本地已经拥有了这个文件，则说明不是新手机，不再自动还原
			HdlFileLogic.Current.DeleteFile(SynchronizeFile);
			HdlFileLogic.Current.DeleteDirectory(dirPath);
			}
			catch { }
			//创建住宅文件夹
			Global.CreateHomeDirectory(Config.Instance.HomeId);
			//预创建个人中心全部的文件夹
			HdlFileLogic.Current.CreatAllUserCenterDirectory();
			}
			}
			if (string.IsNullOrEmpty(userInfo.UserName) == true)
			{
			//没有昵称的话,把账号丢过去
			userInfo.UserName = userInfo.Account;
			}

			UserCenterResourse.UserInfo = userInfo;
			UserCenterResourse.UserInfo.UserIconFile = System.IO.Path.Combine(UserCenterResourse.AccountOption.UserPictruePath, "Admin.png");
			if (UserCenterResourse.UserInfo.HeadImage != null)
			{
			//写入头像内容
			HdlFileLogic.Current.SaveByteToFile(UserCenterResourse.UserInfo.UserIconFile, UserCenterResourse.UserInfo.HeadImage);
			}
			UserCenterResourse.UserInfo.HeadImage = null;
			//手势密码
			UserCenterResourse.AccountOption.GestureAuthentication = UserCenterResourse.UserInfo.GesturePwd == null ? string.Empty : UserCenterResourse.UserInfo.GesturePwd;
			UserCenterResourse.UserInfo.GesturePwd = null;
			//密码验证
			UserCenterResourse.AccountOption.PswAuthentication = UserCenterResourse.UserInfo.StringPwd == null ? string.Empty : UserCenterResourse.UserInfo.StringPwd;
			UserCenterResourse.UserInfo.StringPwd = null;
			//保存缓存
			UserCenterResourse.AccountOption.Save();

			//初始化管理员控制主人的连接地址(因为这个连接Token是不会改变的,所以只需要初始化一次)
			var flage = InitAdminConnectMainInfo();
			//初始化个人信息的标识
			UserCenterResourse.UserInfo.InitUserInfoSuccess = flage == 1;

			return flage;
			}

			/// <summary>
			/// 从本地获取用户的登陆信息
			/// </summary>
			/// <returns></returns>
			private static UserInformation GetUserInformationFromLocation()
			{
			var value = HdlFileLogic.Current.ReadFileTextContent(DirNameResourse.UserInfoFile);
			if (value == null)
			{
			return new UserInformation();
			}
			var info = Newtonsoft.Json.JsonConvert.DeserializeObject<UserInformation>(value);
			return info;
			}

			/// <summary>
			/// 重新初始化登陆账号的信息(旨在对应那一瞬间,网络不好,导致误判的情况)
			/// </summary>
			/// <returns></returns>
			public static bool ReInitUserAccoutInfo()
			{
			//重新初始化账号信息
			var result = InitUserAccoutInfo(false);
			if (result == 1)
			{
			//同步云端的网关id，如果本地拥有云端不存在的id，则表示应该被换绑了，直接删除
			HdlGatewayLogic.Current.SynchronizeDbGateway();
			//初始化个人信息的标识
			UserCenterResourse.UserInfo.InitUserInfoSuccess = true;

			return true;
			}
			return false;
			}

			/// <summary>
			/// 保存用户的登陆信息到本地
			/// </summary>
			private static void SaveUserInformationToLocation()
			{
			//写入内容
			HdlFileLogic.Current.SaveFileContent(DirNameResourse.UserInfoFile, UserCenterResourse.UserInfo);

			//搞一下主人的默认头像
			string defultFile = IO.FileUtils.GetImageFilePath("Center/Admin.png");
			if (defultFile == string.Empty)
			{
			return;
			}
			if (System.IO.File.Exists(UserCenterResourse.UserInfo.UserIconFile) == true)
			{
			return;
			}
			//复制过去
			System.IO.File.Copy(defultFile, UserCenterResourse.UserInfo.UserIconFile);
			}

			#endregion

			#region ■ 初始化管理员权限远程连接___________

			/// <summary>
			/// 初始化管理员权限远程连接主人的信息 -1:无网 1:正常 2:其他错误
			/// </summary>
			/// <returns></returns>
			private static int InitAdminConnectMainInfo()
			{
			if (UserCenterResourse.UserInfo.AuthorityNo != 2 && UserCenterResourse.UserInfo.AuthorityNo != 3)
			{
			//时代变了,这里管理员和成员都能调用
			return 1;
			}
			var pra = new
			{
			CommonPage.RequestVersion,
			LoginAccessToken = Config.Instance.Token,
			MainAccountId = Config.Instance.Home.MainUserDistributedMark,
			SharedHid = Config.Instance.Home.Id
			};

			//序列化对象
			var requestJson = JsonConvert.SerializeObject(pra);
			//访问接口
			byte[] byteData = CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync("App/GetSharedHomeApiControl", Encoding.UTF8.GetBytes(requestJson));
			if (byteData == null)
			{
			return -1;
			}
			//检测错误
			var revertObj = JsonConvert.DeserializeObject<ResponsePack>(Encoding.UTF8.GetString(byteData));
			if (revertObj.StateCode.ToUpper() != "SUCCESS")
			{
			return 2;
			}

			//分享链接
			var info = JsonConvert.DeserializeObject<MemberAdministratorResult>(revertObj.ResponseData.ToString());
			Config.Instance.AdminRequestBaseUrl = info.RequestBaseUrl;
			Config.Instance.AdminRequestToken = info.RequestToken;

			return 1;
			}

			#endregion

			#region ■ 获取控制主人账号的Token____________

			/// <summary>
			/// 获取控制主人账号的Token
			/// </summary>
			/// <returns></returns>
			public static string GetConnectMainToken()
			{
			//启用管理员权限
			if (Config.Instance.Home.IsOthreShare == true)
			{
			return Config.Instance.AdminRequestToken;
			}
			return Config.Instance.Token;
			}

			#endregion

			#region ■ 引导界面___________________________

			/// <summary>
			/// 显示引导界面
			/// </summary>
			/// <param name="result">同步结果 -1：异常 0:已经同步过，不需要同步 1：正常同步 2:没有自动备份数据</param>
			private static void ShowGuideForm(int result)
			{
			var checkFile = DirNameResourse.GuideFile;
			if (System.IO.File.Exists(checkFile) == true)
			{
			//不需要显示
			return;
			}
			if (result == 2 && Config.Instance.Home.IsOthreShare == false)
			{
			HdlThreadLogic.Current.RunMain(() =>
			{
			var form = new Guide.GuideHouseForm();
			form.ShowFrom();
			});
			}

			//创建一个空文件(标识已经完成引导)
			var file = System.IO.File.Create(checkFile);
			file.Close();
			}

			#endregion

			#region ■ 16进制转化_________________________

			/// <summary>
			/// 将16进制的文本翻译为正常文本
			/// </summary>
			/// <param name="hexText">16进制的文本</param>
			/// <param name="count">以多少个字节为一组</param>
			/// <returns></returns>
			public static string TranslateHexadecimalIntoText(string hexText, int count = 2)
			{
			string textValue = string.Empty;
			while (hexText.Length > 0)
			{
			string temp = hexText.Substring(0, count);
			hexText = hexText.Substring(count);
			int value = Convert.ToInt32(temp, 16);
			textValue += ((char)value).ToString();
			}
			return textValue;
			}

			/// <summary>
			/// 将文本翻译为16进制的文本
			/// </summary>
			/// <param name="text">指定文本</param>
			/// <returns></returns>
			public static string TranslateTextIntoHexadecimal(string text)
			{
			string textValue = string.Empty;
			foreach (char c in text)
			{
			int value = Convert.ToInt32(c);
			textValue += Convert.ToString(value, 16);
			}
			return textValue;
			}

			#endregion

			#region ■ 加密和解密_________________________

			/// <summary>
			/// 加密密码
			/// </summary>
			/// <param name="keys"></param>
			/// <param name="strPsw"></param>
			/// <returns></returns>
			public static string EncryptPassword(string keys, string strPsw)
			{
			try
			{
			if (string.IsNullOrEmpty(strPsw) == true)
			{
			return strPsw;
			}
			var des = new System.Security.Cryptography.DESCryptoServiceProvider();
			byte[] inputByteArray = Encoding.Default.GetBytes(strPsw);
			des.Key = ASCIIEncoding.ASCII.GetBytes(keys);
			des.IV = ASCIIEncoding.ASCII.GetBytes(keys);
			var ms = new System.IO.MemoryStream();
			var cs = new System.Security.Cryptography.CryptoStream(ms, des.CreateEncryptor(), System.Security.Cryptography.CryptoStreamMode.Write);
			cs.Write(inputByteArray, 0, inputByteArray.Length);
			cs.FlushFinalBlock();
			StringBuilder ret = new StringBuilder();
			foreach (byte b in ms.ToArray())
			{
			ret.AppendFormat("{0:X2}", b);
			}
			return ret.ToString().ToLower();
			}
			catch { return strPsw; }
			}

			/// <summary>
			/// 解密密码
			/// </summary>
			/// <param name="strPsw"></param>
			/// <returns></returns>
			public static string DecryptPassword(string keys, string strPsw)
			{
			try
			{
			if (strPsw == string.Empty)
			{
			return strPsw;
			}
			var des = new System.Security.Cryptography.DESCryptoServiceProvider();

			byte[] inputByteArray = new byte[strPsw.Length / 2];
			for (int x = 0; x < strPsw.Length / 2; x++)
			{
			int i = (Convert.ToInt32(strPsw.Substring(x * 2, 2), 16));
			inputByteArray[x] = (byte)i;
			}

			des.Key = ASCIIEncoding.ASCII.GetBytes(keys);
			des.IV = ASCIIEncoding.ASCII.GetBytes(keys);
			var ms = new System.IO.MemoryStream();
			var cs = new System.Security.Cryptography.CryptoStream(ms, des.CreateDecryptor(), System.Security.Cryptography.CryptoStreamMode.Write);
			cs.Write(inputByteArray, 0, inputByteArray.Length);
			cs.FlushFinalBlock();

			StringBuilder ret = new StringBuilder();

			return System.Text.Encoding.Default.GetString(ms.ToArray());
			}
			catch { return strPsw; }
			}
			#endregion

			#region ■ 时间转换___________________________

			/// <summary>
			/// 将utc时间类型的字符串,转换为本地时间
			/// </summary>
			/// <param name="timeText"></param>
			/// <returns></returns>
			public static DateTime ConvertUtcTimeToLocalTime(string timeText)
			{
			var utcTime = Convert.ToDateTime(timeText);
			return TimeZoneInfo.ConvertTimeFromUtc(utcTime, TimeZoneInfo.Local);
			}

			#endregion
			}
			}