using System;
|
using Shared.Common;
|
using Newtonsoft.Json;
|
using Shared.Common.ResponseEntity;
|
using System.Threading.Tasks;
|
using System.Text.RegularExpressions;
|
using System.Collections.Generic;
|
|
namespace Shared.Phone.UserCenter
|
{
|
/// <summary>
|
/// 个人中心逻辑类
|
/// </summary>
|
public class UserCenterLogic
|
{
|
#region ■ 变量声明___________________________
|
|
/// <summary>
|
/// 锁
|
/// </summary>
|
private static object objLock = new object();
|
|
#endregion
|
|
#region ■ 云端接口访问_______________________
|
|
/// <summary>
|
/// 访问指定接口，返回是否成功
|
/// </summary>
|
/// <returns>是否成功</returns>
|
/// <param name="RequestName">访问地址</param>
|
/// <param name="obj">一个类</param>
|
/// <param name="listNotShowError">
|
/// <pra>不需要显示错误的错误类别(接口返回的错误类别),如果包含，则会返回【true】</pra>
|
/// <pra>如果指定有NotSetAgain,则不二次发送(比如断网),然后返回【false】</pra>
|
/// </param>
|
public static async Task<bool> GetResultStatuByRequestHttps(string RequestName, object obj, List<string> listNotShowError = null)
|
{
|
string nowFormId = UserCenterResourse.NowActionFormID;
|
|
//获取从接口那里取到的ResponsePack
|
var revertObj = await GetResponsePack(RequestName, obj);
|
if (revertObj == null)
|
{
|
if (listNotShowError != null && listNotShowError.Contains("NotSetAgain") == true)
|
{
|
return false;
|
}
|
revertObj = await ResetRequestHttps(RequestName, obj, nowFormId);
|
if (revertObj == null)
|
{
|
return false;
|
}
|
}
|
|
//检测是否存在错误信息
|
return CheckNotEorrorMsg(revertObj, RequestName, listNotShowError);
|
}
|
|
/// <summary>
|
/// 访问指定接口，返回状态码(出现异常时，返回 Error)
|
/// </summary>
|
/// <returns>接口的状态码(出现异常时，返回 Error)</returns>
|
/// <param name="RequestName">访问地址</param>
|
/// <param name="obj">一个类</param>
|
/// <param name="listNotShowError">
|
/// <pra>不需要显示错误的错误类别(接口返回的错误类别),如果包含，则会返回【Success】</pra>
|
/// <pra>如果指定有NotSetAgain,则不二次发送(比如断网),然后返回【ErrorEx】</pra>
|
/// </param>
|
public static async Task<string> GetResultCodeByRequestHttps(string RequestName, object obj, List<string> listNotShowError = null)
|
{
|
string nowFormId = UserCenterResourse.NowActionFormID;
|
|
//获取从接口那里取到的ResponsePack
|
var revertObj = await GetResponsePack(RequestName, obj);
|
if (revertObj == null)
|
{
|
if (listNotShowError != null && listNotShowError.Contains("NotSetAgain") == true)
|
{
|
return "ErrorEx";
|
}
|
revertObj = await ResetRequestHttps(RequestName, obj, nowFormId);
|
if (revertObj == null)
|
{
|
return "Error";
|
}
|
}
|
return revertObj.StateCode;
|
}
|
|
/// <summary>
|
/// 访问指定接口，并返回接口把对象已经序列化了的字符串，存在错误信息时，返回null
|
/// </summary>
|
/// <returns>返回：接口把对象已经序列化了的字符串，存在错误信息时，返回null</returns>
|
/// <param name="RequestName">访问地址</param>
|
/// <param name="obj">一个类</param>
|
/// <param name="listNotShowError">
|
/// <pra>不需要显示错误的错误类别(接口返回的错误类别),如果包含，则会返回空字符串</pra>
|
/// <pra>如果指定有NotSetAgain,则不二次发送(比如断网),然后返回空字符串</pra>
|
/// </param>
|
public static async Task<string> GetResponseDataByRequestHttps(string RequestName, object obj, List<string> listNotShowError = null)
|
{
|
string nowFormId = UserCenterResourse.NowActionFormID;
|
|
//获取从接口那里取到的ResponsePack
|
var revertObj = await GetResponsePack(RequestName, obj);
|
if (revertObj == null)
|
{
|
if (listNotShowError != null && listNotShowError.Contains("NotSetAgain") == true)
|
{
|
return string.Empty;
|
}
|
revertObj = await ResetRequestHttps(RequestName, obj, nowFormId);
|
if (revertObj == null)
|
{
|
return null;
|
}
|
}
|
|
//检测错误
|
bool notError = CheckNotEorrorMsg(revertObj, RequestName, listNotShowError);
|
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="obj">一个类</param>
|
/// <param name="listNotShowError">
|
/// <pra>不需要显示错误的错误类别(接口返回的错误类别),如果包含，则会返回空字符串</pra>
|
/// <pra>如果指定有NotSetAgain,则不二次发送(比如断网),然后返回null</pra>
|
/// </param>
|
public static async Task<byte[]> GetByteResponseDataByRequestHttps(string RequestName, object obj, List<string> listNotShowError = null)
|
{
|
string nowFormId = UserCenterResourse.NowActionFormID;
|
|
//获取从接口那里取到的ResponsePack
|
var revertObj = await GettByteResponsePack(RequestName, obj);
|
|
if (revertObj == null)
|
{
|
if (listNotShowError != null && listNotShowError.Contains("NotSetAgain") == true)
|
{
|
return null;
|
}
|
//重新发送
|
revertObj = await ResetByteRequestHttps(RequestName, obj, nowFormId);
|
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);
|
if (notError == false)
|
{
|
return null;
|
}
|
}
|
}
|
}
|
return revertObj;
|
}
|
|
/// <summary>
|
/// 私有类型:从新发送(懂的人自然懂，很难解释清楚)
|
/// </summary>
|
/// <param name="RequestName">访问地址</param>
|
/// <param name="obj">一个类</param>
|
/// <param name="actionFormId">那一瞬间的画面ID</param>
|
/// <returns></returns>
|
private static async Task<ResponsePack> ResetRequestHttps(string RequestName, object obj, string actionFormId)
|
{
|
if (actionFormId == string.Empty)
|
{
|
//主界面特殊，不需要考虑
|
return null;
|
}
|
|
ResponsePack responsePack = null;
|
int count = 0;
|
while (actionFormId == UserCenterResourse.NowActionFormID)
|
{
|
await Task.Delay(2000);
|
//调用接口
|
responsePack = await GetResponsePack(RequestName, obj);
|
if (responsePack != null)
|
{
|
break;
|
}
|
count++;
|
if (count == 3)
|
{
|
Application.RunOnMainThread(() =>
|
{
|
//网络不稳定,请稍后再试
|
string msg = Language.StringByID(R.MyInternationalizationString.uNetIsUnStabilityAndDoAgain);
|
var tipView = new TipViewControl(msg);
|
tipView.ShowView();
|
});
|
break;
|
}
|
}
|
return responsePack;
|
}
|
|
/// <summary>
|
/// 私有类型:从新发送(懂的人自然懂，很难解释清楚)
|
/// </summary>
|
/// <param name="RequestName">访问地址</param>
|
/// <param name="obj">一个类</param>
|
/// <param name="actionFormId">那一瞬间的画面ID</param>
|
/// <returns></returns>
|
private static async Task<byte[]> ResetByteRequestHttps(string RequestName, object obj, string actionFormId)
|
{
|
if (actionFormId == string.Empty)
|
{
|
//主界面特殊，不需要考虑
|
return null;
|
}
|
|
byte[] responsePack = null;
|
int count = 0;
|
while (actionFormId == UserCenterResourse.NowActionFormID)
|
{
|
await Task.Delay(2000);
|
//调用接口
|
responsePack = await GettByteResponsePack(RequestName, obj);
|
if (responsePack != null)
|
{
|
break;
|
}
|
count++;
|
if (count == 5)
|
{
|
Application.RunOnMainThread(() =>
|
{
|
//网络不稳定,请稍后再试
|
string msg = Language.StringByID(R.MyInternationalizationString.uNetIsUnStabilityAndDoAgain);
|
var tipView = new TipViewControl(msg);
|
tipView.ShowView();
|
});
|
break;
|
}
|
}
|
return responsePack;
|
}
|
|
/// <summary>
|
/// 获取从接口那里取到的ResponsePack
|
/// </summary>
|
/// <returns>获取从接口那里取到的ResponsePack</returns>
|
/// <param name="RequestName">访问地址</param>
|
/// <param name="obj">一个类</param>
|
private static async Task<ResponsePack> GetResponsePack(string RequestName, object obj)
|
{
|
try
|
{
|
//序列化对象
|
var requestJson = JsonConvert.SerializeObject(obj);
|
//访问接口
|
var result = await CommonPage.Instance.RequestHttpsZigbeeAsync(RequestName, System.Text.Encoding.UTF8.GetBytes(requestJson));
|
|
return result;
|
}
|
catch (Exception ex)
|
{
|
Console.WriteLine(ex.Message);
|
return null;
|
}
|
}
|
|
/// <summary>
|
/// 获取从接口那里取到的内容
|
/// </summary>
|
/// <returns>获取从接口那里取到的文本内容</returns>
|
/// <param name="RequestName">访问地址</param>
|
/// <param name="obj">一个类</param>
|
private static async Task<byte[]> GettByteResponsePack(string RequestName, object obj)
|
{
|
try
|
{
|
//序列化对象
|
var requestJson = JsonConvert.SerializeObject(obj);
|
//访问接口
|
var result = await CommonPage.Instance.RequestHttpsZigbeeBytesResultAsync(RequestName, System.Text.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>
|
public static bool CheckNotEorrorMsg(ResponsePack revertObj, string RequestName, List<string> listNotShowError = null)
|
{
|
if (revertObj == null)
|
{
|
Application.RunOnMainThread(() =>
|
{
|
//网络不稳定,请稍后再试
|
string msg = Language.StringByID(R.MyInternationalizationString.uNetIsUnStabilityAndDoAgain);
|
var tipView = new TipViewControl(msg);
|
tipView.ShowView();
|
});
|
|
return false;
|
}
|
if (revertObj.StateCode.ToUpper() != "SUCCESS")
|
{
|
if (listNotShowError != null && listNotShowError.Contains(revertObj.StateCode) == true)
|
{
|
//不显示错误,然后返回true
|
return true;
|
}
|
Application.RunOnMainThread(() =>
|
{
|
string msg = IMessageCommon.Current.GetMsgByRequestName(RequestName, revertObj.StateCode);
|
var tipView = new TipViewControl(msg);
|
tipView.ShowView();
|
|
//无效登录Token
|
if (revertObj.StateCode == "NoLogin")
|
{
|
new System.Threading.Thread(() =>
|
{
|
System.Threading.Thread.Sleep(1000);
|
Application.RunOnMainThread(() =>
|
{
|
//1秒后重新登录
|
UserCenterLogic.ReLoginAgain(Config.Instance.Account);
|
});
|
})
|
{ IsBackground = true }.Start();
|
}
|
});
|
|
return false;
|
}
|
return true;
|
}
|
|
#endregion
|
|
#region ■ 添加界面相关_______________________
|
|
/// <summary>
|
/// 检测能否添加画面
|
/// </summary>
|
/// <returns>true:可以追加 false:不可追加</returns>
|
/// <param name="form">Form</param>
|
public static bool CheckCanAddForm(UserCenterCommonForm form)
|
{
|
//lock (objLock)
|
{
|
//获取画面英文名字
|
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(UserCenterCommonForm form)
|
{
|
//lock (objLock)
|
{
|
//获取画面英文名字
|
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(UserCenterCommonForm form)
|
{
|
//lock (objLock)
|
{
|
//获取画面英文名字
|
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)
|
{
|
//设置当前激活的画面ID
|
UserCenterResourse.NowActionFormID = UserCenterResourse.listActionFormId[index];
|
if (UserCenterResourse.DicActionForm.ContainsKey(UserCenterResourse.NowActionFormID) == true)
|
{
|
new System.Threading.Thread(() =>
|
{
|
System.Threading.Thread.Sleep(100);
|
Application.RunOnMainThread(() =>
|
{
|
//触发界面再次激活的事件
|
UserCenterResourse.DicActionForm[UserCenterResourse.NowActionFormID].FormActionAgainEvent();
|
});
|
})
|
{ IsBackground = true }.Start();
|
}
|
}
|
}
|
//移除ID
|
UserCenterResourse.listActionFormId.Remove(UserCenterResourse.DicActionForm[formName].FormID);
|
//移除画面
|
UserCenterResourse.DicActionForm.Remove(formName);
|
}
|
}
|
}
|
|
/// <summary>
|
/// 获取画面英文名字
|
/// </summary>
|
/// <returns>The form name.</returns>
|
/// <param name="form">Form.</param>
|
public static string GetFormName(UserCenterCommonForm form)
|
{
|
//将命名空间去掉
|
string[] Arry = form.ToString().Split(new string[] { "." }, StringSplitOptions.RemoveEmptyEntries);
|
string formName = Arry[Arry.Length - 1].Trim();
|
return formName;
|
}
|
|
/// <summary>
|
/// 获取当前正在激活的画面
|
/// </summary>
|
/// <returns></returns>
|
public static UserCenterCommonForm GetNowActionForm()
|
{
|
foreach (UserCenterCommonForm form in UserCenterResourse.DicActionForm.Values)
|
{
|
if (form.FormID == UserCenterResourse.NowActionFormID)
|
{
|
return form;
|
}
|
}
|
return null;
|
}
|
|
#endregion
|
|
#region ■ 刷新本地缓存_______________________
|
/// <summary>
|
/// 刷新本地所有缓存
|
/// </summary>
|
public static void RefreshAllMemory()
|
{
|
//刷新本地网关文件
|
Common.LocalGateway.Current.ReFreshByLocal();
|
//刷新本地设备
|
Common.LocalDevice.Current.ReFreshByLocal();
|
//需优先于刷新房间,同步云端的网关id，如果本地拥有云端不存在的id，则表示应该被换绑了，直接删除
|
Common.LocalGateway.Current.SynchronizeDbGateway();
|
//从本地重新加载全部的房间
|
Common.Room.RefreshAllRoomByLocation();
|
}
|
|
#endregion
|
|
#region ■ 删除本地文件_______________________
|
|
/// <summary>
|
/// 删除本地所有文件
|
/// </summary>
|
/// <param name="all">true:全部删除(用于住宅删除) false:重要的文件不删除</param>
|
public static void DeleteAllLocationFile(bool all = true)
|
{
|
string dPath = UserCenterResourse.LocalRootPath;
|
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("DeviceUI_") == true)
|
{
|
//不能删除设备UI文件
|
return true;
|
}
|
else if (fileName.StartsWith("House_") == true)
|
{
|
//不能删除住宅文件
|
return true;
|
}
|
return false;
|
}
|
|
#endregion
|
|
#region ■ 各种正确检测_______________________
|
|
/// <summary>
|
/// 判断是否包含大写字母
|
/// </summary>
|
/// <returns><c>true</c>, if contain upper was checked, <c>false</c> otherwise.</returns>
|
/// <param name="value">Value.</param>
|
public static bool CheckContainUpper(string value)
|
{
|
return true;
|
}
|
|
/// <summary>
|
/// 判断是否包含小写字母
|
/// </summary>
|
/// <returns><c>true</c>, if contain lower was checked, <c>false</c> otherwise.</returns>
|
/// <param name="value">Value.</param>
|
public static bool CheckContainLower(string value)
|
{
|
return true;
|
}
|
|
/// <summary>
|
/// 判断是否包含数字
|
/// </summary>
|
/// <returns><c>true</c>, if contain lower was checked, <c>false</c> otherwise.</returns>
|
/// <param name="value">Value.</param>
|
public static bool CheckContainNum(string value)
|
{
|
return true;
|
}
|
|
/// <summary>
|
/// 判断是否包含符号
|
/// </summary>
|
/// <returns><c>true</c>, if contain lower was checked, <c>false</c> otherwise.</returns>
|
/// <param name="value">Value.</param>
|
public static bool CheckContainSymbol(string value)
|
{
|
return true;
|
}
|
|
/// <summary>
|
/// 检测邮箱是否合法
|
/// </summary>
|
/// <param name="email"></param>
|
/// <returns></returns>
|
public static bool CheckEmail(string email)
|
{
|
Regex reg = new Regex(CommonPage.EmailRegexStr);
|
return reg.IsMatch(email);
|
}
|
|
/// <summary>
|
/// 检测手机号是否合法
|
/// </summary>
|
/// <param name="phoneNumber">手机号</param>
|
/// <param name="areaCode">地区代码</param>
|
/// <returns></returns>
|
public static bool CheckPhoneNumber(string phoneNumber, string areaCode)
|
{
|
//校验外国手机号
|
if (areaCode != "86")
|
{
|
Regex reg = new Regex(CommonPage.PhoneForForeignRegexStr);
|
return reg.IsMatch(phoneNumber);
|
}
|
|
//校验国内手机号
|
if (phoneNumber.Length > 11)
|
{
|
return false;
|
}
|
else if (phoneNumber.Length == 11)
|
{
|
Regex reg = new Regex(CommonPage.PhoneRegexStr);
|
return reg.IsMatch(phoneNumber);
|
}
|
else
|
{
|
//正则表达式判断是否数字
|
Regex reg = new Regex("^[0-9]*$");
|
return reg.IsMatch(phoneNumber);
|
}
|
}
|
|
#endregion
|
|
#region ■ 从新登录___________________________
|
|
/// <summary>
|
/// 从新登录
|
/// </summary>
|
/// <param name="account">账号</param>
|
public static void ReLoginAgain(string account = "")
|
{
|
//复原管理员权限
|
Common.Config.Instance.isAdministrator = false;
|
UserCenterResourse.oldAccountId = string.Empty;
|
//关闭所有接收
|
DeviceAttributeLogic.Current.RemoveAllEvent();
|
//关闭监听网关变化
|
Common.LocalGateway.Current.StopListenNetWork();
|
//清除升级列表
|
FirmwareUpdateResourse.dicDeviceUpdateList.Clear();
|
FirmwareUpdateResourse.dicGatewayUpdateList.Clear();
|
|
//设定一个时间
|
Config.Instance.LoginDateTime = new DateTime(1970, 1, 1);
|
Config.Instance.Save();
|
|
//清空当前住宅id
|
Shared.Common.Config.Instance.HomeId = string.Empty;
|
Common.LocalGateway.Current.ClearAllRealGateway();
|
|
//通知云端，已经退出登陆
|
CommonPage.Instance.SignOutClearData();
|
|
Application.RunOnMainThread(() =>
|
{
|
//关闭所有打开了的界面
|
CloseAllOpenForm();
|
|
//显示登陆画面
|
var formLogin = new Shared.Phone.Device.Account.AccountLogin();
|
Shared.Common.CommonPage.Instance.AddChidren(formLogin);
|
formLogin.Show(account);
|
});
|
}
|
|
/// <summary>
|
/// 关闭所有打开了的界面
|
/// </summary>
|
public static void CloseAllOpenForm()
|
{
|
var listForm = new List<UserCenterCommonForm>();
|
foreach (UserCenterCommonForm form in UserCenterResourse.DicActionForm.Values)
|
{
|
listForm.Insert(0, form);
|
}
|
UserCenterResourse.DicActionForm.Clear();
|
|
//关闭所有画面
|
foreach (UserCenterCommonForm form in listForm)
|
{
|
form.CloseForm();
|
}
|
}
|
|
#endregion
|
|
#region ■ 子控件的Y轴坐标____________________
|
|
/// <summary>
|
/// 指定位置类型获取Rowlayout的子控件的Y轴坐标(请确保子控件不大于父容器)
|
/// </summary>
|
/// <param name="fatherCtrHeight">父控件的真实高度</param>
|
/// <param name="ctrHeight">子控件的真实高度</param>
|
/// <param name="alignment">位置对齐方式</param>
|
/// <param name="Space">上下间的空白间距,省略时，取行控件共通变量的值。设置为-1时，不计算空白间距</param>
|
/// <returns></returns>
|
public static int GetControlChidrenYaxis(int fatherCtrHeight, int ctrHeight, UViewAlignment alignment, int Space = 0)
|
{
|
if (Space == 0)
|
{
|
//获取行控件的间距
|
if (fatherCtrHeight == ControlCommonResourse.ListViewRowHeight)
|
{
|
Space = ControlCommonResourse.ListViewRowSpace;
|
}
|
}
|
|
if (Space < 0)
|
{
|
//不计算间距值
|
Space = 0;
|
}
|
|
if (alignment == UViewAlignment.Center)
|
{
|
return fatherCtrHeight / 2 - ctrHeight / 2;
|
}
|
else if (alignment == UViewAlignment.Top)
|
{
|
return (fatherCtrHeight / 2 - Space / 2) / 2 - ctrHeight / 2;
|
}
|
else
|
{
|
int top = fatherCtrHeight / 2 + Space / 2;
|
return top + (fatherCtrHeight - top) / 2 - ctrHeight / 2;
|
}
|
}
|
|
#endregion
|
|
#region ■ 拼接信息___________________________
|
|
/// <summary>
|
/// 拼接路径(全路径)，以住宅ID的文件夹为起点，当没有指定参数时，则返回【住宅ID的文件夹】的全路径
|
/// </summary>
|
/// <param name="listNames">要拼接的路径</param>
|
/// <returns></returns>
|
public static string CombinePath(params object[] listNames)
|
{
|
string rootPath = UserCenterResourse.LocalRootPath;
|
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="errorMsgBase">接口回复的东西</param>
|
/// <param name="addBrackets">是否添加括号</param>
|
/// <returns></returns>
|
public static string CombineGatewayTimeOutMsg(string errorMsg, string errorMsgBase, bool addBrackets = true)
|
{
|
if (errorMsgBase != null && 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>
|
/// <para>检测网关返回的共通错误状态码(返回null则代表没有错误),支持状态码为</para>
|
/// <para>1：网关无法解析命令数据。</para>
|
/// <para>2：协调器正在升级或备份/恢复数据</para>
|
/// <para>3：操作设备/组/场景不存在</para>
|
/// <para>4：其他错误</para>
|
/// <para>5：数据传输错误（在某次客户端向网关发送数据的过程中，网关在合理时间范围内接收客户端数据不完整导致该错误发生。如客户端向网关一次发送100个字节的数据，但网关等待接收了一秒只接收了80个字节。发生该错误，网关将主动关闭客户端连接）</para>
|
/// </summary>
|
/// <param name="resultData">网关返回的resultData,里面有【errorResponData】这个东西的那种对象</param>
|
/// <returns></returns>
|
public static string CheckCommonErrorCode(object resultData)
|
{
|
if (resultData == null)
|
{
|
return null;
|
}
|
Type myType = resultData.GetType();
|
object errorObj = myType.InvokeMember("errorResponData", System.Reflection.BindingFlags.GetField, null, resultData, null);
|
if (errorObj == null)
|
{
|
return null;
|
}
|
Type type = errorObj.GetType();
|
var code = type.InvokeMember("Error", System.Reflection.BindingFlags.GetField, null, errorObj, null);
|
int errorCode = Convert.ToInt32(code);
|
|
return CheckCommonErrorCode(errorCode);
|
}
|
|
/// <summary>
|
/// <para>检测网关返回的共通错误状态码(返回null则代表没有错误),支持状态码为</para>
|
/// <para>1：网关无法解析命令数据。</para>
|
/// <para>2：协调器正在升级或备份/恢复数据</para>
|
/// <para>3：操作设备/组/场景不存在</para>
|
/// <para>4：其他错误</para>
|
/// <para>5：数据传输错误（在某次客户端向网关发送数据的过程中，网关在合理时间范围内接收客户端数据不完整导致该错误发生。如客户端向网关一次发送100个字节的数据，但网关等待接收了一秒只接收了80个字节。发生该错误，网关将主动关闭客户端连接）</para>
|
/// </summary>
|
/// <param name="errorCode">错误代码</param>
|
/// <returns></returns>
|
public static string CheckCommonErrorCode(int errorCode)
|
{
|
if (errorCode == 1)
|
{
|
//网关无法解析命令数据
|
return Language.StringByID(R.MyInternationalizationString.uGatewayCannotResolveCommand);
|
}
|
else if (errorCode == 2)
|
{
|
//协调器正在升级或备份或恢复数据中
|
string msg = Language.StringByID(R.MyInternationalizationString.uCoordinatorIsUpOrBackupOrRecovering);
|
}
|
else if (errorCode == 3)
|
{
|
//目标设备不存在
|
string msg = Language.StringByID(R.MyInternationalizationString.uTargetDeviceIsNotExsit);
|
}
|
else if (errorCode == 4)
|
{
|
//出现未知错误,请稍后再试
|
string msg = Language.StringByID(R.MyInternationalizationString.uUnKnowErrorAndResetAgain);
|
}
|
else if (errorCode == 5)
|
{
|
//数据传输错误,请稍后再试
|
string msg = Language.StringByID(R.MyInternationalizationString.uDataTransmissionFailAndResetAgain);
|
}
|
return null;
|
}
|
|
#endregion
|
|
#region ■ 刷新个人中心的内存及线程___________
|
|
/// <summary>
|
/// 异步方法执行(仅限切换住宅时调用)，刷新个人中心的内存及线程
|
/// </summary>
|
public async static Task<bool> InitUserCenterMenmoryAndThread()
|
{
|
//强制指定不关闭进度条
|
ProgressBar.SetCloseBarFlag(true);
|
|
//只有在住宅ID不一样的时候才做这个操作
|
if (Common.Config.Instance.HomeId != UserCenterResourse.oldHomeStringId
|
|| Common.Config.Instance.Account != UserCenterResourse.oldAccountId)
|
{
|
//变更根目录路径
|
UserCenterResourse.LocalRootPath = System.IO.Path.Combine(Shared.IO.FileUtils.RootPath, Config.Instance.Guid, Config.Instance.Home.Id);
|
|
//复原管理员标识
|
Config.Instance.isAdministrator = false;
|
|
//重新发送命令去绑定断网情况下备份的网关
|
HdlGatewayLogic.Current.ResetComandToBindBackupGateway();
|
|
//初始化登陆账号的信息
|
await InitUserAccoutInfo();
|
|
//预创建个人中心全部的文件夹
|
CreatAllUserCenterDirectory();
|
|
//关闭所有接收
|
DeviceAttributeLogic.Current.RemoveAllEvent();
|
//刷新安防上报信息
|
Common.LocalSafeguard.Current.RefreshAlarmInfo();
|
//添加保存安防设备报警的事件(不需要再执行任何操作,并且永久存在)
|
DeviceAttributeLogic.Current.AddSaveSafetyAlarmInfoEvent();
|
|
//保存用户的登陆信息到本地
|
SaveUserInformationToLocation();
|
|
//初始化管理员权限信息
|
await InitAdministratorInfo();
|
|
UserCenterResourse.oldHomeStringId = Common.Config.Instance.HomeId;
|
UserCenterResourse.oldAccountId = Common.Config.Instance.Account;
|
|
//同步数据(二次调用没关系)
|
var result = await HdlAutoBackupLogic.SynchronizeDbAutoBackupData();
|
|
//初始化本地的网关信息
|
Common.LocalGateway.Current.ReFreshByLocal();
|
//初始化本地的设备信息
|
Common.LocalDevice.Current.ReFreshByLocal();
|
|
//同步云端的网关id，如果本地拥有云端不存在的id，则表示应该被换绑了，直接删除
|
Common.LocalGateway.Current.SynchronizeDbGateway();
|
|
//初始化房间(郭雪城那边不做处理,需要这里特殊执行一步)
|
Room.RefreshAllRoomByLocation();
|
|
//刷新APP前一次选择的网关ID(可以反复调用,需要在网关初始化完了之后才能调用)
|
Common.LocalGateway.Current.RefreshAppOldSelectGatewayId();
|
|
//开启监听网关线程(二次调用没关系) ★★废弃★★
|
//Common.LocalGateway.Current.StartListenNetWork();
|
|
//清空强制指定文本的附加信息
|
ProgressBar.SetAppendText(string.Empty);
|
|
//0:已经同步过，不需要同步,这个时候需要提示备份
|
if (result == 0)
|
{
|
//开启自动备份提示
|
HdlAutoBackupLogic.ShowAutoBackupPromptedForm();
|
}
|
}
|
|
//恢复可关闭进度条
|
ProgressBar.SetCloseBarFlag(false);
|
|
return true;
|
}
|
|
#endregion
|
|
#region ■ 初始化登陆账号的信息_______________
|
|
/// <summary>
|
/// 初始化登陆账号的信息
|
/// </summary>
|
/// <returns></returns>
|
private async static Task<bool> InitUserAccoutInfo()
|
{
|
//获取本地记录的用户信息
|
UserCenterResourse.UserInfo = GetUserInformationFromLocation();
|
|
//获取登录账号的信息
|
var pra = new AccountInfoPra();
|
var listNotShow = new List<string>() { "NotSetAgain" };
|
string result = await UserCenterLogic.GetResponseDataByRequestHttps("ZigbeeUsers/GetAccountInfo", pra, listNotShow);
|
if (result == null)
|
{
|
return false;
|
}
|
|
var userInfo = Newtonsoft.Json.JsonConvert.DeserializeObject<UserInformation>(result);
|
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)
|
{
|
//先记录起住宅的一些信息
|
var house = Config.Instance.Home;
|
//删除整个文件夹
|
System.IO.Directory.Delete(dirPath, true);
|
//创建住宅文件夹
|
Global.CreateHomeDirectory(Config.Instance.HomeId);
|
|
var newHouse = new House();
|
newHouse.Id = house.Id;
|
newHouse.Name = house.Name;
|
newHouse.IsOthreShare = house.IsOthreShare;
|
newHouse.AccountType = house.AccountType;
|
newHouse.MainUserDistributedMark = house.MainUserDistributedMark;
|
newHouse.Save();
|
}
|
}
|
|
UserCenterResourse.UserInfo = userInfo;
|
|
return true;
|
}
|
|
/// <summary>
|
/// 从本地获取用户的登陆信息
|
/// </summary>
|
/// <returns></returns>
|
private static UserInformation GetUserInformationFromLocation()
|
{
|
string fileName = CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.UserInfoFile);
|
if (System.IO.File.Exists(fileName) == false)
|
{
|
return new UserInformation();
|
}
|
var varByte = Shared.IO.FileUtils.ReadFile(fileName);
|
var info = Newtonsoft.Json.JsonConvert.DeserializeObject<UserInformation>(System.Text.Encoding.UTF8.GetString(varByte));
|
return info;
|
}
|
|
/// <summary>
|
/// 保存用户的登陆信息到本地
|
/// </summary>
|
private static void SaveUserInformationToLocation()
|
{
|
var data = Newtonsoft.Json.JsonConvert.SerializeObject(UserCenterResourse.UserInfo);
|
var byteData = System.Text.Encoding.UTF8.GetBytes(data);
|
|
string fullName = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.UserInfoFile);
|
//写入内容
|
Shared.IO.FileUtils.WriteFileByBytes(fullName, byteData);
|
}
|
|
#endregion
|
|
#region ■ 预创建个人中心全部的文件夹_________
|
|
/// <summary>
|
/// 预创建个人中心全部的文件夹
|
/// </summary>
|
private 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);
|
}
|
|
#endregion
|
|
#region ■ 初始化管理员权限信息_______________
|
|
/// <summary>
|
/// 初始化管理员权限信息
|
/// </summary>
|
/// <returns></returns>
|
public static async Task<bool> InitAdministratorInfo()
|
{
|
//先清空
|
Config.Instance.isAdministrator = false;
|
Config.Instance.AdminRequestBaseUrl = string.Empty;
|
Config.Instance.AdminRequestToken = string.Empty;
|
|
if (UserCenterResourse.UserInfo.AuthorityNo != 2)
|
{
|
//拥有管理员权限的成员才能这样搞
|
return true;
|
}
|
var pra = new
|
{
|
CommonPage.RequestVersion,
|
LoginAccessToken = Config.Instance.Token,
|
MainAccountId = Config.Instance.Home.MainUserDistributedMark,
|
SharedHid = Config.Instance.Home.Id
|
};
|
|
var listNotShow = new List<string>() { "NotSetAgain" };
|
var result = await GetResponseDataByRequestHttps("App/GetSharedHomeApiControl", pra, listNotShow);
|
if (result == null)
|
{
|
return false;
|
}
|
|
var praMqtt = new
|
{
|
CommonPage.RequestVersion,
|
LoginAccessToken = Config.Instance.Token,
|
Config.Instance.Home.MainUserDistributedMark,
|
HomeId = Config.Instance.Home.Id
|
};
|
var result2 = await GetResponseDataByRequestHttps("App/GetConnectMainUserMqttInfo", praMqtt, listNotShow);
|
if (result2 == null)
|
{
|
return false;
|
}
|
|
Config.Instance.isAdministrator = true;
|
//分享链接
|
var info = JsonConvert.DeserializeObject<MemberAdministratorResult>(result);
|
Config.Instance.AdminRequestBaseUrl = info.RequestBaseUrl;
|
Config.Instance.AdminRequestToken = info.RequestToken;
|
//远程Mqtt
|
var info2 = JsonConvert.DeserializeObject<MemberAdministratorMqttResult>(result2);
|
Config.Instance.AdminConnectZigbeeMqttBrokerPwd = info2.ConnectZigbeeMqttBrokerPwd;
|
Config.Instance.AdminConnectZigbeeMqttClientId = info2.ConnectZigbeeMqttClientId;
|
Config.Instance.AdminMqttKey = info2.MqttKey;
|
Config.Instance.AdminZigbeeMqttBrokerLoadSubDomain = info2.ZigbeeMqttBrokerLoadSubDomain;
|
Config.Instance.AdminConnectZigbeeMqttBrokerName = info2.ConnectZigbeeMqttBrokerName;
|
//断开远程mqtt链接
|
try
|
{
|
if (ZigBee.Device.ZbGateway.RemoteMqttClient != null && ZigBee.Device.ZbGateway.RemoteMqttClient.IsConnected == true)
|
{
|
await ZigBee.Device.ZbGateway.RemoteMqttClient.DisconnectAsync();
|
ZigBee.Device.ZbGateway.RemoteMqttClient = null;
|
}
|
}
|
catch { }
|
|
return true;
|
}
|
|
#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
|
}
|
}
|
