using Newtonsoft.Json;
|
using System;
|
using System.Collections.Generic;
|
using System.Text;
|
using System.Threading.Tasks;
|
using ZigBee.Device;
|
using Shared.Phone.UserCenter;
|
using System.Security.Cryptography;
|
using System.IO;
|
|
namespace Shared.Common
|
{
|
/// <summary>
|
/// <para>安防本地缓存(代码使用)</para>
|
/// <para>防区ID(ZoneId)：</para>
|
/// <para>1：24小时防区 2：24小时静音防区 3：出入防区 4：内部防区 5：周界防区</para>
|
/// <para>防区模式ID(ActionType -> 防区ID换算:ZoneId=3,4,5都当做3处理)：</para>
|
/// <para>1：24小时防区 2：静音防区 3：其他防区（出入防区、内部防区、周界防区）</para>
|
/// <para>布防模式ID(GarrisonMode)：</para>
|
/// <para>1：在家布防 或者 布防(内部防区没有设置的时候) 2：离家布防</para>
|
/// </summary>
|
public class LocalSafeguard
|
{
|
#region ■ 变量声明___________________________
|
|
/// <summary>
|
/// 本地安防数据
|
/// </summary>
|
private static LocalSafeguard m_Current = null;
|
/// <summary>
|
/// 本地安防数据
|
/// </summary>
|
public static LocalSafeguard Current
|
{
|
get
|
{
|
if (m_Current == null)
|
{
|
m_Current = new LocalSafeguard();
|
}
|
return m_Current;
|
}
|
set
|
{
|
m_Current = value;
|
}
|
}
|
|
/// <summary>
|
/// 本次登陆不再询问
|
/// </summary>
|
public bool NotAskAgain = false;
|
/// <summary>
|
/// 管理员密码的缓存
|
/// </summary>
|
private string adminPassword = string.Empty;
|
/// <summary>
|
/// 用户密码的缓存
|
/// </summary>
|
private string UserPassword = null;
|
/// <summary>
|
/// 安防数据缓存
|
/// </summary>
|
private LocalSafeguardData LocalData = new LocalSafeguardData();
|
/// <summary>
|
/// 安防上报信息
|
/// </summary>
|
public List<SafeguardAlarmInfo> listAlarmInfo = new List<SafeguardAlarmInfo>();
|
/// <summary>
|
/// 上一次安防上报信息保存的文件名字(考虑到用户有可能24点的时候，不退出APP)
|
/// </summary>
|
private string oldDeviceAlarmFile = string.Empty;
|
/// <summary>
|
/// 锁
|
/// </summary>
|
private object objLock = new object();
|
#endregion
|
|
#region ■ 刷新安防___________________________
|
|
/// <summary>
|
/// 刷新本地安防信息
|
/// </summary>
|
public void ReFreshByLocal()
|
{
|
if (Global.IsExistsByHomeId(LocalSafeguardData.LocalSecurityFile) == false)
|
{
|
return;
|
}
|
|
byte[] filebyte = Global.ReadFileByHomeId(LocalSafeguardData.LocalSecurityFile);
|
string strvalue = System.Text.Encoding.UTF8.GetString(filebyte);
|
this.LocalData = JsonConvert.DeserializeObject<LocalSafeguardData>(strvalue);
|
}
|
|
/// <summary>
|
/// 从新从网关那里获取数据(失败时会弹出信息框)
|
/// </summary>
|
/// <returns></returns>
|
public async Task<bool> ReFreshByGateway(ShowErrorMode showError = ShowErrorMode.YES)
|
{
|
//先清空
|
this.LocalData.dicAllZoneInfo.Clear();
|
|
List<int> listId = this.GetAllZoneId();
|
bool canGetData = false;
|
foreach (int zoneId in listId)
|
{
|
//通过防区ID查看防区传感器设备列表
|
var result = await Safeguard.getZoneDeviceListByIdAsync(zoneId);
|
if (result == null || result.getZoneDeviceListByIdResponData == null)
|
{
|
canGetData = false;
|
break;
|
}
|
if (result.getZoneDeviceListByIdResponData.Result == 1)
|
{
|
//失败，布防模式不存在
|
continue;
|
}
|
canGetData = true;
|
|
//将防区传感器设备列表加入缓存
|
this.SetZoneSensorDeviceToMemory(result.getZoneDeviceListByIdResponData);
|
//将报警目标列表加入缓存
|
bool flage = await this.SetAlarmTargetDeviceToMemory(zoneId);
|
if (flage == false)
|
{
|
canGetData = false;
|
break;
|
}
|
}
|
//全部错误，都获取不到信息
|
if (canGetData == false)
|
{
|
if (showError == ShowErrorMode.YES)
|
{
|
//获取防区信息失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uGetSafetyInfoFail);
|
this.ShowErrorMsg(msg);
|
}
|
return false;
|
}
|
|
return true;
|
}
|
|
|
/// <summary>
|
/// 将防区设备(传感器)列表加入缓存
|
/// </summary>
|
/// <param name="allData">防区数据</param>
|
private void SetZoneSensorDeviceToMemory(Safeguard.GetZoneDeviceListByIdResponData allData)
|
{
|
if (this.LocalData.dicAllZoneInfo.ContainsKey(allData.ZoneId) == false)
|
{
|
this.LocalData.dicAllZoneInfo[allData.ZoneId] = new SafeguardZoneInfo();
|
}
|
|
//设置基本信息
|
SafeguardZoneInfo zoneInfo = this.LocalData.dicAllZoneInfo[allData.ZoneId];
|
zoneInfo.ZoneId = allData.ZoneId;
|
zoneInfo.ZoneName = allData.ZoneName;
|
|
//处理设备
|
foreach (var data2 in allData.DeviceList)
|
{
|
string mainKey = data2.MacAddr + data2.Epoint;
|
//传感器设备信息
|
var Deviceinfo = new Safeguard.ZoneDeviceListData();
|
Deviceinfo.IsBypass = data2.IsBypass;
|
Deviceinfo.MomentStatus = data2.MomentStatus;
|
Deviceinfo.TriggerZoneStatus = data2.TriggerZoneStatus;
|
Deviceinfo.MacAddr = data2.MacAddr;
|
Deviceinfo.Epoint = data2.Epoint;
|
zoneInfo.dicSensor[mainKey] = Deviceinfo;
|
|
//本地是否有这个设备
|
CommonDevice device = LocalDevice.Current.GetDevice(mainKey);
|
if (device != null)
|
{
|
//全部设备
|
zoneInfo.dicAllDevice[mainKey] = device.FilePath;
|
}
|
else
|
{
|
//全部设备(缺失的未知设备)
|
var tempDevice = new CommonDevice();
|
tempDevice.DeviceAddr = data2.MacAddr;
|
tempDevice.DeviceEpoint = data2.Epoint;
|
zoneInfo.dicAllDevice[mainKey] = tempDevice.FilePath;
|
}
|
}
|
}
|
|
/// <summary>
|
/// 将报警目标列表加入缓存
|
/// </summary>
|
/// <param name="ActionType">
|
/// <para>1：24小时防区触发动作</para>
|
/// <para>2：24小时静音防区触发动作</para>
|
/// <para>3：其他防区（出入防区、内部防区、周界防区）触发动作</para>
|
/// </param>
|
/// <param name="mode">是否显示错误</param>
|
/// <returns></returns>
|
private async Task<bool> SetAlarmTargetDeviceToMemory(int ActionType, ShowErrorMode mode = ShowErrorMode.NO)
|
{
|
if (ActionType > 3)
|
{
|
return true;
|
}
|
if (this.LocalData.dicAllZoneInfo.ContainsKey(ActionType) == false)
|
{
|
this.LocalData.dicAllZoneInfo[ActionType] = new SafeguardZoneInfo();
|
//设置基本信息
|
this.LocalData.dicAllZoneInfo[ActionType].ZoneId = ActionType;
|
}
|
SafeguardZoneInfo zoneInfo = this.LocalData.dicAllZoneInfo[ActionType];
|
|
//查看防区报警目标
|
var resultData = await Safeguard.CatZoneActionAsync(ActionType);
|
if (resultData == null
|
|| resultData.catZoneActionResponseData == null
|
|| resultData.catZoneActionResponseData.Result == 1)
|
{
|
if (mode == ShowErrorMode.YES)
|
{
|
//获取报警目标列表失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uGetAlarmTargetListFail);
|
this.ShowErrorMsg(msg);
|
}
|
return false;
|
}
|
zoneInfo.dicAlarmDevice.Clear();
|
zoneInfo.dicScenes.Clear();
|
|
//信息推送
|
zoneInfo.InformationPush = resultData.catZoneActionResponseData.IsDisablePushMessage;
|
|
foreach (var data in resultData.catZoneActionResponseData.Actions)
|
{
|
//设备
|
if (data.Type == 0)
|
{
|
//本地是否有这个设备
|
string mainKey = data.DeviceAddr + data.Epoint;
|
//报警信息
|
zoneInfo.dicAlarmDevice[mainKey] = data;
|
CommonDevice device = LocalDevice.Current.GetDevice(mainKey);
|
if (device != null)
|
{
|
//全部设备
|
zoneInfo.dicAllDevice[mainKey] = device.FilePath;
|
}
|
else
|
{
|
//全部设备(缺失的未知设备)
|
var tempDevice = new CommonDevice();
|
tempDevice.DeviceAddr = data.DeviceAddr;
|
tempDevice.DeviceEpoint = data.Epoint;
|
zoneInfo.dicAllDevice[mainKey] = tempDevice.FilePath;
|
}
|
}
|
//场景
|
else if (data.Type == 1)
|
{
|
//场景
|
zoneInfo.dicScenes[data.ScenesId] = data.ESName;
|
}
|
}
|
|
return true;
|
}
|
|
#endregion
|
|
#region ■ 获取设备___________________________
|
|
/// <summary>
|
/// 获取指定防区的所有传感器设备的信息
|
/// </summary>
|
/// <param name="zoonId">防区ID(它似乎是唯一主键)</param>
|
/// <returns></returns>
|
public List<Safeguard.ZoneDeviceListData> GetSensorDevicesInfoByZoonID(int zoonId)
|
{
|
var list = new List<Safeguard.ZoneDeviceListData>();
|
if (this.LocalData.dicAllZoneInfo.ContainsKey(zoonId) == false)
|
{
|
return list;
|
}
|
SafeguardZoneInfo info = this.LocalData.dicAllZoneInfo[zoonId];
|
foreach (var data in info.dicSensor.Values)
|
{
|
list.Add(data);
|
}
|
|
return list;
|
}
|
|
/// <summary>
|
/// 获取全部的传感器设备的信息(按防区分组)
|
/// </summary>
|
/// <returns></returns>
|
public Dictionary<int, List<Safeguard.ZoneDeviceListData>> GetAllSensorDeviceInfo()
|
{
|
var dic = new Dictionary<int, List<Safeguard.ZoneDeviceListData>>();
|
|
foreach (int ZoonId in this.LocalData.dicAllZoneInfo.Keys)
|
{
|
List<Safeguard.ZoneDeviceListData> list = this.GetSensorDevicesInfoByZoonID(ZoonId);
|
if (list.Count > 0)
|
{
|
dic[ZoonId] = list;
|
}
|
}
|
return dic;
|
}
|
|
/// <summary>
|
/// 根据防区ID获取本地报警目标
|
/// </summary>
|
/// <param name="ZoneId">防区ID</param>
|
/// <returns></returns>
|
public List<Safeguard.CatActionResponseObj> GetLocalAlarmTargetInfoByZoneId(int ZoneId)
|
{
|
if (ZoneId > 3)
|
{
|
ZoneId = 3;
|
}
|
if (this.LocalData.dicAllZoneInfo.ContainsKey(ZoneId) == false)
|
{
|
return new List<Safeguard.CatActionResponseObj>();
|
}
|
SafeguardZoneInfo zoneInfo = this.LocalData.dicAllZoneInfo[ZoneId];
|
|
//优先场景吧
|
var list = new List<Safeguard.CatActionResponseObj>();
|
foreach (int sceneId in zoneInfo.dicScenes.Keys)
|
{
|
var objData = new Safeguard.CatActionResponseObj();
|
objData.Type = 1;
|
objData.ScenesId = sceneId;
|
objData.ESName = zoneInfo.dicScenes[sceneId];
|
|
list.Add(objData);
|
}
|
foreach (var data in zoneInfo.dicAlarmDevice.Values)
|
{
|
list.Add(data);
|
}
|
return list;
|
}
|
|
/// <summary>
|
/// 获取指定传感器所处的防区ID(不存在则返回-1)
|
/// </summary>
|
/// <param name="device">指定传感器设备</param>
|
/// <returns></returns>
|
public int GetZoneIdByIASZone(CommonDevice device)
|
{
|
string mainkey = this.GetDeviceMainKeys(device);
|
foreach (SafeguardZoneInfo info in this.LocalData.dicAllZoneInfo.Values)
|
{
|
if (info.dicSensor.ContainsKey(mainkey) == true)
|
{
|
return info.ZoneId;
|
}
|
}
|
return -1;
|
}
|
|
#endregion
|
|
#region ■ 添加传感器_________________________
|
|
/// <summary>
|
/// 添加传感器设备到防区(失败时会弹出信息框)
|
/// </summary>
|
/// <param name="zoonId">防区ID(它似乎是唯一主键)</param>
|
/// <param name="listdevice">设备列表</param>
|
public async Task<bool> AddSensorDevice(int zoonId, List<CommonDevice> listdevice)
|
{
|
//现获取当前的布防模式
|
var safetyMode = await this.GetSafetyMode();
|
if (safetyMode != null)
|
{
|
//当前正处于布防模式,无法添加设备
|
string msg = Language.StringByID(R.MyInternationalizationString.uCanNotAddDeviceInGarrisonMode);
|
this.ShowErrorMsg(msg);
|
return false;
|
}
|
//校验密码
|
bool result = await this.ShowSafetyAdminValidatedDialog();
|
if (result == false)
|
{
|
return false;
|
}
|
|
if (listdevice.Count == 0)
|
{
|
return true;
|
}
|
|
List<int> listMomentStatus = new List<int>();
|
List<int> listTriggerStatus = new List<int>();
|
foreach (var device in listdevice)
|
{
|
int MomentStatus = 0;
|
int TriggerZoneStatus = 0;
|
//获取安防传感器的瞬间状态设定值
|
this.GetSafeguardSensorMomentStatus(device, ref MomentStatus, ref TriggerZoneStatus);
|
|
listMomentStatus.Add(MomentStatus);
|
listTriggerStatus.Add(TriggerZoneStatus);
|
}
|
|
//添加设备到网关
|
List<string> listSuccess = await this.AddSensorDeviceToGateway(zoonId, listdevice, listMomentStatus, listTriggerStatus);
|
if (listSuccess == null)
|
{
|
return false;
|
}
|
|
//修改缓存
|
if (this.LocalData.dicAllZoneInfo.ContainsKey(zoonId) == false)
|
{
|
this.LocalData.dicAllZoneInfo[zoonId] = new SafeguardZoneInfo();
|
}
|
|
SafeguardZoneInfo info = this.LocalData.dicAllZoneInfo[zoonId];
|
for (int i = 0; i < listdevice.Count; i++)
|
{
|
CommonDevice device = listdevice[i];
|
string mainkey = this.GetDeviceMainKeys(device);
|
if (listSuccess.Contains(mainkey) == false)
|
{
|
//没有添加成功
|
continue;
|
}
|
|
Safeguard.ZoneDeviceListData sensorInfo = null;
|
if (info.dicSensor.ContainsKey(mainkey) == true)
|
{
|
sensorInfo = info.dicSensor[mainkey];
|
}
|
else
|
{
|
sensorInfo = new Safeguard.ZoneDeviceListData();
|
info.dicSensor[mainkey] = sensorInfo;
|
sensorInfo.Epoint = device.DeviceEpoint;
|
sensorInfo.MacAddr = device.DeviceAddr;
|
sensorInfo.IsBypass = 0;
|
}
|
info.dicAllDevice[mainkey] = device.FilePath;
|
//设备信息
|
sensorInfo.MomentStatus = listMomentStatus[0];
|
sensorInfo.TriggerZoneStatus = listTriggerStatus[0];
|
}
|
|
//保存到本地
|
this.LocalData.SaveToLocaltion();
|
|
return true;
|
}
|
|
/// <summary>
|
/// 添加传感器设备到网关(失败时会弹出信息框)
|
/// </summary>
|
/// <param name="zoonId">防区ID(它似乎是唯一主键)</param>
|
/// <param name="listdevice">设备列表</param>
|
/// <param name="listMomentStatus">设备上报的状态是否为瞬间状态</param>
|
/// <param name="listTriggerStatus">我也不知道这个是什么东西</param>
|
/// <returns></returns>
|
private async Task<List<string>> AddSensorDeviceToGateway(int zoonId, List<CommonDevice> listdevice, List<int> listMomentStatus, List<int> listTriggerStatus)
|
{
|
var addData = new Safeguard.AddDeviceToZoneData();
|
addData.ZoneId = zoonId;
|
addData.LoginToken = this.GetLoginToken();
|
|
for (int i = 0; i < listdevice.Count; i++)
|
{
|
CommonDevice device = listdevice[i];
|
//数据组装
|
var deviceData = new Safeguard.DeviceListObj();
|
deviceData.Epoint = device.DeviceEpoint;
|
deviceData.MacAddr = device.DeviceAddr;
|
deviceData.MomentStatus = listMomentStatus[i];
|
deviceData.TriggerZoneStatus = listTriggerStatus[i];
|
addData.DeviceList.Add(deviceData);
|
}
|
|
//没有数据
|
if (addData.DeviceList.Count == 0)
|
{
|
return new List<string>();
|
}
|
//添加到网关
|
var returnData = await Safeguard.AddDeviceToZoneAsync(addData);
|
if (returnData == null || returnData.addDeviceToPartResponseData == null || returnData.addDeviceToPartResponseData.Result == 1)
|
{
|
//向防区添加设备失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uAddDeviceToZoneFail);
|
//拼接上【网关回复超时】的Msg
|
msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, returnData.errorMessageBase);
|
|
this.ShowErrorMsg(msg);
|
return null;
|
}
|
|
List<string> listSuccess = new List<string>();
|
foreach (var data in returnData.addDeviceToPartResponseData.DeviceList)
|
{
|
//一批设备里面，成功添加的
|
if (data.Status == 0)
|
{
|
listSuccess.Add(data.MacAddr + data.Epoint);
|
}
|
else if (data.Status == 1)
|
{
|
var device = Common.LocalDevice.Current.GetDevice(data.MacAddr, data.Epoint);
|
string msg = Common.LocalDevice.Current.GetDeviceEpointName(device) + "\r\n";
|
//目标设备不存在
|
msg += Language.StringByID(R.MyInternationalizationString.uTargetDeviceIsNotExsit);
|
this.ShowTipMsg(msg);
|
}
|
else if (data.Status == 2)
|
{
|
var device = Common.LocalDevice.Current.GetDevice(data.MacAddr, data.Epoint);
|
string msg = Common.LocalDevice.Current.GetDeviceEpointName(device) + "\r\n";
|
//设备已加入其它防区
|
msg += Language.StringByID(R.MyInternationalizationString.uDeviceHadAddToTheOtherGarrison);
|
this.ShowTipMsg(msg);
|
}
|
}
|
|
return listSuccess;
|
}
|
|
/// <summary>
|
/// 获取安防传感器的瞬间状态设定值(添加传感器到安防时，需要调用此方法来初始化参数)
|
/// </summary>
|
/// <param name="device">设备对象</param>
|
/// <param name="MomentStatus">设备上报的状态是否为瞬间状态</param>
|
/// <param name="TriggerZoneStatus">我也不知道这个是什么东西</param>
|
public void GetSafeguardSensorMomentStatus(CommonDevice device, ref int MomentStatus, ref int TriggerZoneStatus)
|
{
|
//运动传感器
|
if (device.IasDeviceType == 13)
|
{
|
MomentStatus = 1;
|
TriggerZoneStatus = 1;
|
}
|
//烟雾传感器
|
else if (device.IasDeviceType == 40)
|
{
|
MomentStatus = 1;
|
TriggerZoneStatus = 1;
|
}
|
//水侵传感器
|
else if (device.IasDeviceType == 42)
|
{
|
MomentStatus = 1;
|
TriggerZoneStatus = 1;
|
}
|
//燃气传感器
|
else if (device.IasDeviceType == 43)
|
{
|
MomentStatus = 1;
|
TriggerZoneStatus = 1;
|
}
|
//紧急按钮
|
else if (device.IasDeviceType == 44)
|
{
|
MomentStatus = 1;
|
TriggerZoneStatus = 1;
|
}
|
//钥匙扣
|
else if (device.IasDeviceType == 277)
|
{
|
MomentStatus = 1;
|
TriggerZoneStatus = 1;
|
}
|
//门窗传感器
|
else if (device.IasDeviceType == 21 || device.IasDeviceType == 22)
|
{
|
MomentStatus = 0;
|
TriggerZoneStatus = 1;
|
}
|
//如果是虚拟设备，则这个东西永恒为0
|
if (device.DriveCode > 0)
|
{
|
MomentStatus = 0;
|
}
|
}
|
|
#endregion
|
|
#region ■ 删除设备___________________________
|
|
/// <summary>
|
/// 删除传感器设备
|
/// </summary>
|
/// <param name="zoonId">防区ID(它似乎是唯一主键)</param>
|
/// <param name="listdevice">传感器设备对象</param>
|
public async Task<bool> DeleteSensorDevice(int zoonId, List<CommonDevice> listdevice)
|
{
|
//现获取当前的布防模式
|
var safetyMode = await this.GetSafetyMode();
|
if (safetyMode != null)
|
{
|
//当前正处于布防模式,无法删除设备
|
string msg = Language.StringByID(R.MyInternationalizationString.uCanNotDeleteDeviceInGarrisonMode);
|
this.ShowErrorMsg(msg);
|
return false;
|
}
|
|
//校验密码
|
bool result = await this.ShowSafetyAdminValidatedDialog();
|
if (result == false)
|
{
|
return false;
|
}
|
|
if (listdevice.Count == 0)
|
{
|
return true;
|
}
|
|
//从网关那里删除设备
|
List<string> listKeys = await this.DeleteSensorDeviceFromGateway(zoonId, listdevice);
|
if (listKeys == null)
|
{
|
return false;
|
}
|
|
//修改缓存
|
if (this.LocalData.dicAllZoneInfo.ContainsKey(zoonId) == false)
|
{
|
return true;
|
}
|
|
SafeguardZoneInfo info = this.LocalData.dicAllZoneInfo[zoonId];
|
foreach (CommonDevice device in listdevice)
|
{
|
string mainkey = this.GetDeviceMainKeys(device);
|
if (info.dicSensor.ContainsKey(mainkey) == true
|
&& listKeys.Contains(mainkey) == true)
|
{
|
info.dicSensor.Remove(mainkey);
|
info.dicAllDevice.Remove(mainkey);
|
}
|
}
|
|
//保存到本地
|
this.LocalData.SaveToLocaltion();
|
|
return true;
|
}
|
|
/// <summary>
|
/// 从网关那里删除传感器设备
|
/// </summary>
|
/// <param name="zoonId">防区ID(它似乎是唯一主键)</param>
|
/// <param name="listdevice">设备对象</param>
|
/// <returns></returns>
|
private async Task<List<string>> DeleteSensorDeviceFromGateway(int zoonId, List<CommonDevice> listdevice)
|
{
|
var deteleData = new Safeguard.RemoveEqToZoneData();
|
deteleData.ZoneId = zoonId;
|
deteleData.LoginToken = this.GetLoginToken();
|
|
foreach (CommonDevice device in listdevice)
|
{
|
//组装数据
|
var removeData = new Safeguard.RemoveDeviceListObj();
|
removeData.MacAddr = device.DeviceAddr;
|
removeData.Epoint = device.DeviceEpoint;
|
deteleData.RemoveDeviceList.Add(removeData);
|
}
|
|
//没有数据
|
if (deteleData.RemoveDeviceList.Count == 0)
|
{
|
return new List<string>();
|
}
|
|
//从网关中移除
|
var returnData = await Safeguard.RemoveDeviceToZoneAsync(deteleData);
|
if (returnData == null || returnData.removeDeviceToZoneResponseData == null || returnData.removeDeviceToZoneResponseData.Result == 1)
|
{
|
//设备删除失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uDeviceDeleteFail);
|
//拼接上【网关回复超时】的Msg
|
msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, returnData.errorMessageBase);
|
|
this.ShowErrorMsg(msg);
|
|
return null;
|
}
|
|
List<string> listKeys = new List<string>();
|
foreach (var data in returnData.removeDeviceToZoneResponseData.RemoveDeviceList)
|
{
|
if (data.Status == 0)
|
{
|
listKeys.Add(data.MacAddr + data.Epoint);
|
}
|
}
|
|
return listKeys;
|
}
|
|
#endregion
|
|
#region ■ 存在检测___________________________
|
|
/// <summary>
|
/// 指定传感器设备是否存在于安防网关
|
/// </summary>
|
/// <param name="device"></param>
|
/// <returns></returns>
|
public bool IsSensorDeviceExist(CommonDevice device)
|
{
|
string mainkey = this.GetDeviceMainKeys(device);
|
foreach (SafeguardZoneInfo info in this.LocalData.dicAllZoneInfo.Values)
|
{
|
if (info.dicSensor.ContainsKey(mainkey) == true)
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
|
/// <summary>
|
/// 指定传感器设备是否存在于安防网关
|
/// </summary>
|
/// <param name="ZoneId">防区ID</param>
|
/// <param name="device"></param>
|
/// <returns></returns>
|
public bool IsSensorDeviceExist(int ZoneId, CommonDevice device)
|
{
|
if (this.LocalData.dicAllZoneInfo.ContainsKey(ZoneId) == false)
|
{
|
return false;
|
}
|
string mainkey = this.GetDeviceMainKeys(device);
|
SafeguardZoneInfo info = this.LocalData.dicAllZoneInfo[ZoneId];
|
|
if (info.dicSensor.ContainsKey(mainkey) == true)
|
{
|
return true;
|
}
|
|
return false;
|
}
|
|
/// <summary>
|
/// 指定报警设备是否存在于安防网关
|
/// </summary>
|
/// <param name="ZoneId">防区ID</param>
|
/// <param name="device"></param>
|
/// <returns></returns>
|
public bool IsAlarmDeviceExist(int ZoneId, CommonDevice device)
|
{
|
if (ZoneId < 3)
|
{
|
if (this.LocalData.dicAllZoneInfo.ContainsKey(ZoneId) == false)
|
{
|
return false;
|
}
|
string mainkey = this.GetDeviceMainKeys(device);
|
SafeguardZoneInfo info = this.LocalData.dicAllZoneInfo[ZoneId];
|
|
if (info.dicAlarmDevice.ContainsKey(mainkey) == true)
|
{
|
return true;
|
}
|
}
|
else
|
{
|
string mainkey = this.GetDeviceMainKeys(device);
|
|
for (int i = 3; i <= 5; i++)
|
{
|
if (this.LocalData.dicAllZoneInfo.ContainsKey(i) == false)
|
{
|
continue;
|
}
|
SafeguardZoneInfo info = this.LocalData.dicAllZoneInfo[i];
|
|
if (info.dicAlarmDevice.ContainsKey(mainkey) == true)
|
{
|
return true;
|
}
|
}
|
}
|
|
return false;
|
}
|
|
/// <summary>
|
/// 指定布防是否存在于安防网关
|
/// </summary>
|
/// <param name="zoonId">防区ID(它似乎是唯一主键)</param>
|
/// <returns></returns>
|
public bool IsZoonExist(int zoonId)
|
{
|
return this.LocalData.dicAllZoneInfo.ContainsKey(zoonId);
|
}
|
|
/// <summary>
|
/// 是否设置有内部防区
|
/// </summary>
|
/// <returns></returns>
|
public bool IsHadInternalDefenseArea()
|
{
|
foreach (SafeguardZoneInfo info in this.LocalData.dicAllZoneInfo.Values)
|
{
|
//存在第四防区
|
if (info.ZoneId == 4)
|
{
|
//里面有没有设备
|
if (info.dicSensor.Count > 0)
|
{
|
return true;
|
}
|
//不再往下循环
|
return false;
|
}
|
}
|
return false;
|
}
|
|
#endregion
|
|
#region ■ 安防登陆___________________________
|
|
/// <summary>
|
/// 主用户登陆(失败时会弹出信息框)
|
/// </summary>
|
/// <param name="password"></param>
|
/// <param name="showMode"></param>
|
public async Task<bool> AdminLogin(string password, ShowErrorMode showMode = ShowErrorMode.YES)
|
{
|
//尝试登陆
|
var resultData = await ZigBee.Device.Safeguard.AdminLoginResponAsync(password, this.GetLoginToken());
|
if (resultData != null && resultData.Result != 0)
|
{
|
if (showMode == ShowErrorMode.NO)
|
{
|
return false;
|
}
|
//管理员密码错误
|
string msg = Language.StringByID(R.MyInternationalizationString.uAdministratorPasswordIsError);
|
|
this.ShowErrorMsg(msg);
|
|
return false;
|
}
|
|
return true;
|
}
|
|
/// <summary>
|
/// 获取指定用户的密码,如果用户不存在，则返回null(错误不会弹出信息)
|
/// </summary>
|
/// <param name="userId"></param>
|
/// <returns></returns>
|
public async Task<string> GetUserPassword(int userId)
|
{
|
//先获取密码
|
var nowPw = await Safeguard.CatUserPasswordAsync(this.GetLoginToken());
|
if (nowPw == null || nowPw.catUserPasswordResponseData == null)
|
{
|
return null;
|
}
|
|
foreach (var pw in nowPw.catUserPasswordResponseData.UserPasswordList)
|
{
|
if (pw.UserId == userId)
|
{
|
return pw.Password;
|
}
|
}
|
return null;
|
}
|
|
/// <summary>
|
/// 获取全部用户的密码(错误会弹出信息)
|
/// </summary>
|
/// <param name="mode">是否显示错误</param>
|
/// <returns></returns>
|
public async Task<List<Safeguard.UserPasswordListObj>> GetAllUserPassword(ShowErrorMode mode = ShowErrorMode.YES)
|
{
|
//先获取密码
|
var nowPw = await Safeguard.CatUserPasswordAsync(this.GetLoginToken());
|
if (nowPw == null || nowPw.catUserPasswordResponseData == null)
|
{
|
//获取安防密码失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uGetSafetyPasswordFail);
|
//拼接上【网关回复超时】的Msg
|
msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, nowPw.errorMessageBase);
|
|
if (mode == ShowErrorMode.YES)
|
{
|
this.ShowErrorMsg(msg);
|
}
|
|
return null;
|
}
|
return nowPw.catUserPasswordResponseData.UserPasswordList;
|
}
|
|
/// <summary>
|
/// 修改用户密码(不存在时，则新建)
|
/// </summary>
|
/// <param name="userId"></param>
|
/// <param name="password"></param>
|
/// <returns></returns>
|
public async Task<bool> ChangedUserPassword(int userId, string password)
|
{
|
//创建新用户
|
var result = await Safeguard.SetUserPasswordAsync(userId, password, this.GetLoginToken());
|
if (result == null || result.setUserPasswordResponseData == null)
|
{
|
if (userId != 5)
|
{
|
//修改用户密码失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uChangedUserPasswordFail);
|
//拼接上【网关回复超时】的Msg
|
msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result.errorMessageBase);
|
|
this.ShowErrorMsg(msg);
|
return false;
|
}
|
else
|
{
|
//修改胁迫密码失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uChangedCoercePasswordFail);
|
this.ShowErrorMsg(msg);
|
return false;
|
}
|
}
|
if (result.setUserPasswordResponseData.Result == 1)
|
{
|
//用户密码数已满(最大4个)
|
string msg = Language.StringByID(R.MyInternationalizationString.uUserPasswordCountIsMax);
|
this.ShowErrorMsg(msg);
|
return false;
|
}
|
if (result.setUserPasswordResponseData.Result == 2)
|
{
|
//密码长度不正确
|
string msg = Language.StringByID(R.MyInternationalizationString.uPasswordLengthIsError);
|
this.ShowErrorMsg(msg);
|
return false;
|
}
|
if (result.setUserPasswordResponseData.Result == 3)
|
{
|
//用户密码重复
|
string msg = Language.StringByID(R.MyInternationalizationString.uUserPasswordIsRepeat);
|
this.ShowErrorMsg(msg);
|
return false;
|
}
|
|
return true;
|
}
|
|
/// <summary>
|
/// 显示校验管理员密码的窗口
|
/// </summary>
|
/// <returns></returns>
|
public async Task<bool> ShowSafetyAdminValidatedDialog()
|
{
|
//自动登录
|
if (this.NotAskAgain == true)
|
{
|
//解码
|
string psw = this.DecryptPassword(this.adminPassword);
|
bool flage = await this.AdminLogin(psw, ShowErrorMode.NO);
|
if (flage == true)
|
{
|
return true;
|
}
|
this.NotAskAgain = false;
|
//如果登录不成功的话,则弹出再次输入的窗口
|
}
|
Phone.UserCenter.SafetyAdminValidatedControl DialogForm = null;
|
bool isShowingProgressBar = false;
|
string ProgressBarText = string.Empty;
|
|
Application.RunOnMainThread(() =>
|
{
|
isShowingProgressBar = CommonPage.Loading.Visible;
|
ProgressBarText = CommonPage.Loading.Text;
|
if (isShowingProgressBar == true)
|
{
|
//如果在弹出校验密码框的时候，显示着进度条的话，先暂时关闭进度条
|
CommonPage.Loading.Hide();
|
}
|
DialogForm = new Phone.UserCenter.SafetyAdminValidatedControl();
|
});
|
|
while (DialogForm.IsSuccess == false)
|
{
|
//没有父控件，即：按下了取消键
|
if (DialogForm.Parent == null)
|
{
|
//恢复进度条
|
if (isShowingProgressBar == true)
|
{
|
Application.RunOnMainThread(() =>
|
{
|
CommonPage.Loading.Start(ProgressBarText);
|
});
|
}
|
return false;
|
}
|
await Task.Delay(500);
|
}
|
|
//恢复进度条
|
if (isShowingProgressBar == true)
|
{
|
Application.RunOnMainThread(() =>
|
{
|
CommonPage.Loading.Start(ProgressBarText);
|
});
|
}
|
|
return true;
|
}
|
|
/// <summary>
|
/// 修改管理员密码
|
/// </summary>
|
/// <param name="oldPsw"></param>
|
/// <param name="newPsw"></param>
|
/// <returns></returns>
|
public async Task<bool> ChangedAdminPassword(string oldPsw, string newPsw)
|
{
|
//执行修改
|
var result = await Safeguard.ChangeAdminPasswordAsync(oldPsw, newPsw);
|
if (result == null || result.changeAdminPasswordResponseData == null)
|
{
|
//修改管理员密码失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uChangedAdministratorPasswordFail);
|
//拼接上【网关回复超时】的Msg
|
msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result.errorMessageBase);
|
|
this.ShowErrorMsg(msg);
|
return false;
|
}
|
if (result.changeAdminPasswordResponseData.Result == 1)
|
{
|
//原密码不一致
|
string msg = Language.StringByID(R.MyInternationalizationString.uOldPsswordIsError);
|
this.ShowErrorMsg(msg);
|
return false;
|
}
|
if (result.changeAdminPasswordResponseData.Result == 2)
|
{
|
//密码长度不正确
|
string msg = Language.StringByID(R.MyInternationalizationString.uPasswordLengthIsError);
|
this.ShowErrorMsg(msg);
|
return false;
|
}
|
|
//更改缓存
|
this.adminPassword = this.EncryptPassword(result.changeAdminPasswordResponseData.NewPassword);
|
|
return true;
|
}
|
|
/// <summary>
|
/// 检测是否已经配置有用户密码(内部会弹出错误信息,-1:异常 0:没有配置 1:已经配置)
|
/// </summary>
|
/// <returns></returns>
|
public async Task<int> CheckHadConfigureUserPsw()
|
{
|
var pswInfo = await this.GetAllUserPassword(ShowErrorMode.NO);
|
if (pswInfo == null)
|
{
|
//出现未知错误,请稍后再试
|
string msg = Language.StringByID(R.MyInternationalizationString.uUnKnowErrorAndResetAgain);
|
this.ShowTipMsg(msg);
|
return -1;
|
}
|
foreach (var data in pswInfo)
|
{
|
//4个用户密码
|
if (data.UserId >= 1 && data.UserId <= 4)
|
{
|
return 1;
|
}
|
}
|
return 0;
|
}
|
|
/// <summary>
|
/// 保存管理员密码到本地
|
/// </summary>
|
/// <param name="psw"></param>
|
public void SetAdminPswInMenmory(string psw)
|
{
|
this.adminPassword = this.EncryptPassword(psw);
|
}
|
|
#endregion
|
|
#region ■ 报警目标___________________________
|
|
/// <summary>
|
/// 添加报警目标到安防
|
/// </summary>
|
/// <param name="ZoneId">防区ID</param>
|
/// <param name="listAction">添加的目标</param>
|
/// <returns></returns>
|
public async Task<bool> AddAlarmTagetToSafety(int ZoneId, List<Safeguard.AlarmActionObj> listAction)
|
{
|
//现获取当前的布防模式
|
var safetyMode = await this.GetSafetyMode();
|
if (safetyMode != null)
|
{
|
//当前正处于布防模式,无法添加设备
|
string msg = Language.StringByID(R.MyInternationalizationString.uCanNotAddDeviceInGarrisonMode);
|
this.ShowErrorMsg(msg);
|
return false;
|
}
|
//验证身份
|
bool login = await this.ShowSafetyAdminValidatedDialog();
|
if (login == false)
|
{
|
return false;
|
}
|
|
if (ZoneId > 3)
|
{
|
ZoneId = 3;
|
}
|
var saveData = new Safeguard.AddZoneActionData();
|
saveData.ActionType = ZoneId;
|
saveData.Actions = listAction;
|
saveData.LoginToken = this.GetLoginToken();
|
|
//添加报警目标到安防
|
var result = await Safeguard.AddZoneActionAsync(saveData);
|
if (result == null || result.addZoneActionResponseData == null || result.addZoneActionResponseData.Result == 1)
|
{
|
//添加报警目标失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uAddAlarmTargetFail);
|
//拼接上【网关回复超时】的Msg
|
msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result.errorMessageBase);
|
|
this.ShowErrorMsg(msg);
|
|
return false;
|
}
|
foreach (var data in result.addZoneActionResponseData.Actions)
|
{
|
if (data.Status == "1")
|
{
|
if (data.Type == "0")
|
{
|
var device = Common.LocalDevice.Current.GetDevice(data.DeviceAddr, data.Epoint);
|
string msg = Common.LocalDevice.Current.GetDeviceEpointName(device) + "\r\n";
|
//目标设备不存在
|
msg += Language.StringByID(R.MyInternationalizationString.uTargetDeviceIsNotExsit);
|
this.ShowTipMsg(msg);
|
}
|
else if (data.Type == "1")
|
{
|
var scene = Common.SceneRoomUI.AllSceneRoomUIList.Find((obj) => obj.sceneUI.Id == data.ScenesId);
|
if (scene != null)
|
{
|
string msg = scene.sceneUI.Name + "\r\n";
|
//目标场景不存在
|
msg += Language.StringByID(R.MyInternationalizationString.uTargetSceneIsNotExsit);
|
this.ShowTipMsg(msg);
|
}
|
}
|
}
|
}
|
|
//将报警目标列表加入缓存(从新从网关那里获取新追加的设备)
|
await this.SetAlarmTargetDeviceToMemory(ZoneId, ShowErrorMode.YES);
|
|
return true;
|
}
|
|
/// <summary>
|
/// 删除报警目标
|
/// </summary>
|
/// <param name="ZoneId">防区ID</param>
|
/// <param name="listActions">删除的目标</param>
|
/// <returns></returns>
|
public async Task<bool> DeleteAlarmTaget(int ZoneId, List<Safeguard.DelAlarmActionObj> listActions)
|
{
|
//现获取当前的布防模式
|
var safetyMode = await this.GetSafetyMode();
|
if (safetyMode != null)
|
{
|
//当前正处于布防模式,无法删除设备
|
string msg = Language.StringByID(R.MyInternationalizationString.uCanNotDeleteDeviceInGarrisonMode);
|
this.ShowErrorMsg(msg);
|
return false;
|
}
|
//验证身份
|
bool login = await this.ShowSafetyAdminValidatedDialog();
|
if (login == false)
|
{
|
return false;
|
}
|
if (ZoneId > 3)
|
{
|
ZoneId = 3;
|
}
|
//参数
|
var Pra = new Safeguard.DelZoneActionData();
|
Pra.ActionType = ZoneId;
|
Pra.Actions = listActions;
|
Pra.LoginToken = this.GetLoginToken();
|
//执行删除
|
var result = await Safeguard.DelZoneActionAsync(Pra);
|
if (result == null || result.delZoneActionResponseData == null || result.delZoneActionResponseData.Result == 1)
|
{
|
//删除报警目标失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uDeleteAlarmTargetFail);
|
//拼接上【网关回复超时】的Msg
|
msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result.errorMessageBase);
|
|
this.ShowErrorMsg(msg);
|
|
return false;
|
}
|
|
//获取本地缓存
|
if (this.LocalData.dicAllZoneInfo.ContainsKey(ZoneId) == false)
|
{
|
return true;
|
}
|
SafeguardZoneInfo zoneInfo = this.LocalData.dicAllZoneInfo[ZoneId];
|
|
//修改缓存
|
foreach (var device in result.delZoneActionResponseData.Actions)
|
{
|
//删除失败
|
if (device.Status == "1")
|
{
|
continue;
|
}
|
//设备
|
if (device.Type == "0")
|
{
|
//删除报警设备
|
string mainkeys = Common.LocalDevice.Current.GetDeviceMainKeys(device.DeviceAddr, device.Epoint);
|
if (zoneInfo.dicAlarmDevice.ContainsKey(mainkeys) == false)
|
{
|
continue;
|
}
|
zoneInfo.dicAlarmDevice.Remove(mainkeys);
|
zoneInfo.dicAllDevice.Remove(mainkeys);
|
}
|
//场景
|
else if (device.Type == "1")
|
{
|
//删除场景
|
if (zoneInfo.dicScenes.ContainsKey(device.ScenesId) == true)
|
{
|
zoneInfo.dicScenes.Remove(device.ScenesId);
|
}
|
}
|
}
|
return true;
|
}
|
|
#endregion
|
|
#region ■ 获取场景___________________________
|
|
/// <summary>
|
/// 根据防区ID获取本地的场景
|
/// </summary>
|
/// <param name="ZoneId">防区ID</param>
|
/// <returns></returns>
|
public Dictionary<int, string> GetLocalSceneByZoneID(int ZoneId)
|
{
|
if (ZoneId > 3)
|
{
|
ZoneId = 3;
|
}
|
if (this.LocalData.dicAllZoneInfo.ContainsKey(ZoneId) == false)
|
{
|
return new Dictionary<int, string>();
|
}
|
var infoData = this.LocalData.dicAllZoneInfo[ZoneId];
|
return infoData.dicScenes;
|
}
|
|
#endregion
|
|
#region ■ 旁路设置___________________________
|
|
/// <summary>
|
/// 旁路状态设置
|
/// </summary>
|
/// <param name="zoneId">防区ID</param>
|
/// <param name="device">传感器设备</param>
|
/// <param name="statu">旁路状态 -> 0:不旁路 1:旁路</param>
|
/// <returns></returns>
|
public async Task<bool> SetByPassStatuToSafety(int zoneId, CommonDevice device, int statu)
|
{
|
//验证
|
bool flage = await this.ShowSafetyAdminValidatedDialog();
|
if (flage == false)
|
{
|
return false;
|
}
|
|
//参数
|
var Pra = new Safeguard.EqByPassData();
|
Pra.ZoneId = zoneId;
|
Pra.MacAddr = device.DeviceAddr;
|
Pra.Epoint = device.DeviceEpoint;
|
Pra.IsByPass = statu;
|
Pra.LoginToken = this.GetLoginToken();
|
|
var result = await Safeguard.EqByPassAllDataAsync(Pra);
|
if (result == null || result.eqByPassResponseData != null && result.eqByPassResponseData.Result == 3)
|
{
|
//设置失败,系统当前处于撤防状态
|
string msg2 = Language.StringByID(R.MyInternationalizationString.uByPassFailAndSystemInWithdrawGarrisonStatu);
|
this.ShowErrorMsg(msg2);
|
return false;
|
}
|
|
//其他错误
|
if (result.eqByPassResponseData == null || result.eqByPassResponseData.Result != 0)
|
{
|
//旁路状态设置失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uSetByPassStatuFail);
|
//拼接上【网关回复超时】的Msg
|
msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result.errorMessageBase);
|
|
this.ShowErrorMsg(msg);
|
|
return false;
|
}
|
|
return true;
|
}
|
|
#endregion
|
|
#region ■ 布防撤防___________________________
|
|
/// <summary>
|
/// 设置安防的布防模式,成功时,内部不会提示信息(不要调用此方法来实现【撤防】)
|
/// </summary>
|
/// <param name="garrison">布防模式</param>
|
/// <returns>网关现在实行的布防模式</returns>
|
public async Task<GarrisonMode> SetSafetyGarrisonByModel(GarrisonMode garrison)
|
{
|
//检测其他防区里面有没有配置有传感器
|
if (this.CheckHadInteriorSectorsSensor() == false)
|
{
|
//其他防区里没有配置传感器设备
|
string msg = Language.StringByID(R.MyInternationalizationString.uNotSensorInOtherSectors);
|
this.ShowErrorMsg(msg);
|
return GarrisonMode.None;
|
}
|
|
if (this.UserPassword == null)
|
{
|
var data = Global.ReadFileByDirectory(DirNameResourse.LocalMemoryDirectory, DirNameResourse.SafeguardUserPassword);
|
if (data != null)
|
{
|
this.UserPassword = System.Text.Encoding.UTF8.GetString(data);
|
}
|
}
|
if (string.IsNullOrEmpty(this.UserPassword) == true)
|
{
|
//输入密码
|
string password = await this.ShowInputUserPasswordForm();
|
if (string.IsNullOrEmpty(password) == true)
|
{
|
return GarrisonMode.None;
|
}
|
var result = await this.SetSafetyGarrisonByModel(garrison, false);
|
if (result != GarrisonMode.None && result != GarrisonMode.RemoveGarrison)
|
{
|
//保存加密的密码到本地
|
Global.WriteFileToDirectoryByBytes(DirNameResourse.LocalMemoryDirectory, DirNameResourse.SafeguardUserPassword, System.Text.Encoding.UTF8.GetBytes(this.UserPassword));
|
}
|
return result;
|
}
|
else
|
{
|
return await this.SetSafetyGarrisonByModel(garrison, true);
|
}
|
}
|
|
/// <summary>
|
/// 设置安防的布防模式,成功时,内部不会提示信息(不要调用此方法来实现【撤防】)
|
/// </summary>
|
/// <param name="garrison">布防模式</param>
|
/// <param name="showPswForm">用户密码错误时，是否允许弹出输入用户密码的窗口</param>
|
/// <returns>网关现在实行的布防模式</returns>
|
private async Task<GarrisonMode> SetSafetyGarrisonByModel(GarrisonMode garrison, bool showPswForm)
|
{
|
//先把当前的模式给移除掉
|
bool flage = await this.RemoveSafetyGarrison(garrison, showPswForm);
|
if (flage == false)
|
{
|
return GarrisonMode.None;
|
}
|
|
//参数
|
var Pra = new Safeguard.EnableModeData();
|
//模式ID
|
Pra.ModeId = (int)garrison;
|
//检查防区设备最近上报的安防信息状态进行布防
|
Pra.CheckIASStatus = 1;
|
//永久布防，直到撤防
|
Pra.Setting = 1;
|
//用户密码
|
Pra.UserPassword = this.DecryptPassword(this.UserPassword);
|
|
//执行布防
|
var result = await Safeguard.EnableModeAsync(Pra);
|
if (result == null || result.enableModeResponseData == null)
|
{
|
//布防设置失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uSetGarrisonFail);
|
//拼接上【网关回复超时】的Msg
|
msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result.errorMessageBase);
|
|
this.ShowErrorMsg(msg);
|
return GarrisonMode.RemoveGarrison;
|
}
|
|
//错误检测
|
if (result.enableModeResponseData.Result == 1)
|
{
|
//布防模式不存在
|
string msg = Language.StringByID(R.MyInternationalizationString.uGarrisonModeIsNotEsixt);
|
this.ShowErrorMsg(msg);
|
return GarrisonMode.RemoveGarrison;
|
}
|
else if (result.enableModeResponseData.Result == 2)
|
{
|
//清空密码缓存
|
this.UserPassword = null;
|
|
if (showPswForm == false)
|
{
|
//用户密码错误或未设置用户密码
|
string msg = Language.StringByID(R.MyInternationalizationString.uUserPasswordIsError);
|
this.ShowErrorMsg(msg);
|
return GarrisonMode.RemoveGarrison;
|
}
|
else
|
{
|
//重新显示输入用户密码的窗口
|
string password = await this.ShowInputUserPasswordForm();
|
if (string.IsNullOrEmpty(password) == true)
|
{
|
return GarrisonMode.RemoveGarrison;
|
}
|
|
var result2 = await this.SetSafetyGarrisonByModel(garrison, false);
|
if (result2 != GarrisonMode.None && result2 != GarrisonMode.RemoveGarrison)
|
{
|
//保存加密密码到本地
|
Global.WriteFileToDirectoryByBytes(DirNameResourse.LocalMemoryDirectory, DirNameResourse.SafeguardUserPassword, System.Text.Encoding.UTF8.GetBytes(this.UserPassword));
|
}
|
return result2;
|
}
|
}
|
else if (result.enableModeResponseData.Result == 3)
|
{
|
//安防设备未就绪
|
string msg = Language.StringByID(R.MyInternationalizationString.uSafetyDeviceDoNotReady);
|
msg += "(" + result.enableModeResponseData.IASName + ")";
|
this.ShowErrorMsg(msg);
|
return GarrisonMode.RemoveGarrison;
|
}
|
else if (result.enableModeResponseData.Result == 4)
|
{
|
//其他布防模式正在启用中
|
string msg = Language.StringByID(R.MyInternationalizationString.uOtherGarrisonIsActtion);
|
this.ShowErrorMsg(msg);
|
return (GarrisonMode)result.enableModeResponseData.ModeIdBeUsing;
|
}
|
else if (result.enableModeResponseData.Result == 5)
|
{
|
//模式属性不允许失能
|
string msg = Language.StringByID(R.MyInternationalizationString.uGarrisonModeElementCanNotLostFunction);
|
this.ShowErrorMsg(msg);
|
return GarrisonMode.RemoveGarrison;
|
}
|
|
//保存布防操作信息到本地
|
this.SaveSafeguardAlarmInfo(garrison);
|
|
return garrison;
|
}
|
|
/// <summary>
|
/// 移除当前正在运行的布防模式(成功时，内部不会提示信息)
|
/// </summary>
|
/// <param name="garrison">布防模式(这个变量只是为了变更提示错误信息，当不是撤防时，错误提示信息会改变)</param>
|
/// <param name="showPswForm">用户密码错误时，是否允许弹出输入用户密码的窗口</param>
|
/// <returns></returns>
|
public async Task<bool> RemoveSafetyGarrison(GarrisonMode garrison, bool showPswForm)
|
{
|
//现获取当前的布防模式
|
var safetyMode = await this.GetSafetyMode();
|
if (safetyMode == null)
|
{
|
//如果是撤防的话
|
if (garrison == GarrisonMode.RemoveGarrison)
|
{
|
//当前不存在布防
|
string msg = Language.StringByID(R.MyInternationalizationString.uNowDoNotHadGarrison);
|
this.ShowErrorMsg(msg);
|
return false;
|
}
|
//并没有设置布防,也就不谈什么撤防了
|
return true;
|
}
|
|
//撤防的时候，无条件弹出输入密码框
|
if (garrison == GarrisonMode.RemoveGarrison)
|
{
|
string psw = await this.ShowInputUserPasswordForm();
|
if (string.IsNullOrEmpty(psw) == true)
|
{
|
return false;
|
}
|
}
|
|
//撤防
|
var result = await Safeguard.WithdrawModeAsync(this.DecryptPassword(this.UserPassword));
|
if (result == null || result.withdrawModeResponseData == null)
|
{
|
//执行撤防操作的时候
|
if (garrison == GarrisonMode.RemoveGarrison)
|
{
|
//撤防失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uRemoveGarrisonFail);
|
//拼接上【网关回复超时】的Msg
|
msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result.errorMessageBase);
|
|
this.ShowErrorMsg(msg);
|
}
|
else
|
{
|
//布防模式变更失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uChangedGarrisonModeFail);
|
//拼接上【网关回复超时】的Msg
|
msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result.errorMessageBase);
|
|
this.ShowErrorMsg(msg);
|
}
|
|
return false;
|
}
|
|
if (result.withdrawModeResponseData.Result == 2)
|
{
|
//清空密码缓存
|
this.UserPassword = null;
|
if (showPswForm == false || garrison == GarrisonMode.RemoveGarrison)
|
{
|
//用户密码错误或未设置用户密码
|
string msg = Language.StringByID(R.MyInternationalizationString.uUserPasswordIsError);
|
this.ShowErrorMsg(msg);
|
return false;
|
}
|
else
|
{
|
//重新显示输入用户密码的窗口
|
string password = await this.ShowInputUserPasswordForm();
|
if (string.IsNullOrEmpty(password) == true)
|
{
|
return false;
|
}
|
|
var result2 = await this.RemoveSafetyGarrison(garrison, false);
|
if (result2 == true)
|
{
|
//保存到加密密码本地
|
Global.WriteFileToDirectoryByBytes(DirNameResourse.LocalMemoryDirectory, DirNameResourse.SafeguardUserPassword, System.Text.Encoding.UTF8.GetBytes(this.UserPassword));
|
}
|
return result2;
|
}
|
}
|
else if (result.withdrawModeResponseData.Result == 3 && garrison == GarrisonMode.RemoveGarrison)
|
{
|
//当前模式不可撤防
|
string msg = Language.StringByID(R.MyInternationalizationString.uNowGarrisonCanNotRemove);
|
this.ShowErrorMsg(msg);
|
return false;
|
}
|
|
if (garrison == GarrisonMode.RemoveGarrison)
|
{
|
//保存布防操作信息到本地
|
this.SaveSafeguardAlarmInfo(garrison);
|
}
|
|
return true;
|
}
|
|
/// <summary>
|
/// 获取当前安防的模式(在家，离家等等),如果没有布防，则返回null
|
/// </summary>
|
public async Task<Safeguard.GetModeUsingResponseData> GetSafetyMode()
|
{
|
var result = await Safeguard.GetModeUsingAsync();
|
if (result == null || result.getModeUsingResponseData == null)
|
{
|
return null;
|
}
|
if (result.getModeUsingResponseData.Result == 1)
|
{
|
return null;
|
}
|
return result.getModeUsingResponseData;
|
}
|
|
/// <summary>
|
/// 显示输入用户密码的界面(返回null时代表出错或者取消)
|
/// </summary>
|
public async Task<string> ShowInputUserPasswordForm()
|
{
|
//获取当前正在激活的画面
|
UserCenterCommonForm form = UserCenterLogic.GetNowActionForm();
|
if (form == null)
|
{
|
//这种情况应该不存在
|
this.ShowErrorMsg("ERROR:Not Found The ActionForm!");
|
return null;
|
}
|
|
DialogInputFrameControl Dialogform = null;
|
|
bool isShowingProgressBar = false;
|
string ProgressBarText = string.Empty;
|
|
string pasword = null;
|
Application.RunOnMainThread(() =>
|
{
|
isShowingProgressBar = CommonPage.Loading.Visible;
|
ProgressBarText = CommonPage.Loading.Text;
|
if (isShowingProgressBar == true)
|
{
|
//如果在弹出校验密码框的时候，显示着进度条的话，先暂时关闭进度条
|
CommonPage.Loading.Hide();
|
}
|
|
Dialogform = new DialogInputFrameControl(form, DialogFrameMode.OnlyPassword);
|
//用户密码
|
Dialogform.SetTitleText(Language.StringByID(R.MyInternationalizationString.uUserPassword));
|
//设置提示信息:请输入用户密码
|
Dialogform.SetTipText(Language.StringByID(R.MyInternationalizationString.uPleaseInputUserPassword));
|
//确认按钮
|
Dialogform.ComfirmClickEvent += (() =>
|
{
|
if (Dialogform.InputText == string.Empty)
|
{
|
this.ShowErrorMsg(Language.StringByID(R.MyInternationalizationString.uPleaseInputUserPassword));
|
return;
|
}
|
Dialogform.CloseDialog();
|
|
//用户密码
|
pasword = Dialogform.InputText;
|
//加密密码
|
this.UserPassword = this.EncryptPassword(pasword);
|
});
|
});
|
while (pasword == null)
|
{
|
if (Dialogform != null && Dialogform.Parent == null)
|
{
|
break;
|
}
|
await Task.Delay(500);
|
}
|
|
//恢复进度条
|
if (isShowingProgressBar == true)
|
{
|
Application.RunOnMainThread(() =>
|
{
|
CommonPage.Loading.Start(ProgressBarText);
|
});
|
}
|
return pasword;
|
}
|
|
/// <summary>
|
/// 检测其他防区里面有没有配置有传感器(布防使用)
|
/// </summary>
|
/// <returns></returns>
|
private bool CheckHadInteriorSectorsSensor()
|
{
|
for (int i = 3; i <= 5; i++)
|
{
|
if (LocalData.dicAllZoneInfo.ContainsKey(i) == true
|
&& LocalData.dicAllZoneInfo[i].dicSensor.Count > 0)
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
|
#endregion
|
|
#region ■ 信息推送___________________________
|
|
/// <summary>
|
/// 设置指定防区的信息推送状态
|
/// </summary>
|
/// <param name="zoneId">防区ID</param>
|
/// <param name="statu">状态 0:推送 1:不推送</param>
|
/// <returns></returns>
|
public async Task<bool> SetGarrisonInformationPushStatu(int zoneId, int statu)
|
{
|
//校验密码
|
bool flage = await this.ShowSafetyAdminValidatedDialog();
|
if (flage == false)
|
{
|
return false;
|
}
|
|
if (zoneId > 3)
|
{
|
zoneId = 3;
|
}
|
//状态变更
|
var result = await Safeguard.DisablePushMessageAsync(zoneId, statu);
|
if (result == null || result.disablePushMessageResponseData == null || result.disablePushMessageResponseData.Result == 1)
|
{
|
//设置信息推送失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uSetInformationPushFail);
|
//拼接上【网关回复超时】的Msg
|
msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result.errorMessageBase);
|
|
this.ShowErrorMsg(msg);
|
return false;
|
}
|
if (this.LocalData.dicAllZoneInfo.ContainsKey(zoneId) == false)
|
{
|
return true;
|
}
|
SafeguardZoneInfo zoneInfo = this.LocalData.dicAllZoneInfo[zoneId];
|
zoneInfo.InformationPush = statu;
|
|
return true;
|
}
|
|
/// <summary>
|
/// 获取当前防区的信息推送状态
|
/// </summary>
|
/// <param name="zoneId">防区ID</param>
|
/// <returns>0:推送 1:不推送</returns>
|
public int GetGarrisonInformationPushStatu(int zoneId)
|
{
|
if (zoneId > 3)
|
{
|
zoneId = 3;
|
}
|
if (this.LocalData.dicAllZoneInfo.ContainsKey(zoneId) == false)
|
{
|
return 1;
|
}
|
SafeguardZoneInfo zoneInfo = this.LocalData.dicAllZoneInfo[zoneId];
|
return zoneInfo.InformationPush;
|
}
|
|
#endregion
|
|
#region ■ 延迟设置___________________________
|
|
/// <summary>
|
/// 获取防区的延迟时间(仅限出入防区),出错时返回null
|
/// </summary>
|
/// <returns></returns>
|
public async Task<Safeguard.CatDelayTimeResponseData> GetGarrisonDelayTime()
|
{
|
//获取
|
var result = await Safeguard.CatDelayTimeAsync();
|
if (result == null || result.catDelayTimeResponseData == null)
|
{
|
//获取延时时间失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uGetDelayTimeFail);
|
//拼接上【网关回复超时】的Msg
|
msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result.errorMessageBase);
|
|
this.ShowErrorMsg(msg);
|
return null;
|
}
|
return result.catDelayTimeResponseData;
|
}
|
|
/// <summary>
|
/// 设置防区的进出延迟时间 (仅限出入防区),现接口不支持单个修改
|
/// </summary>
|
/// <param name="enterDelayTime">进入延时(秒)</param>
|
/// <param name="goOutDelayTime">外出延时(秒)</param>
|
/// <returns></returns>
|
public async Task<bool> SetGarrisonDelayTime(int enterDelayTime, int goOutDelayTime)
|
{
|
//校验密码
|
bool flage = await this.ShowSafetyAdminValidatedDialog();
|
if (flage == false)
|
{
|
return false;
|
}
|
//更改时间
|
var result = await Safeguard.SetDelayTimeAsync(enterDelayTime, goOutDelayTime, this.GetLoginToken());
|
if (result == null || result.setDelayTimeResponseData == null)
|
{
|
//设置延时时间失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uSetDelayTimeFail);
|
//拼接上【网关回复超时】的Msg
|
msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result.errorMessageBase);
|
|
this.ShowErrorMsg(msg);
|
return false;
|
}
|
return true;
|
}
|
|
#endregion
|
|
#region ■ 胁迫设置___________________________
|
|
/// <summary>
|
/// 获取胁迫的电话联系方式(获取失败时会返回null)
|
/// </summary>
|
/// <returns></returns>
|
public async Task<Safeguard.CheckCoercePhoneNumberResponseData> GetCoercePhoneNumber()
|
{
|
//获取
|
var result = await Safeguard.CheckCoercePhoneNumberAsync();
|
if (result == null || result.checkCoercePhoneNumberResponseData == null)
|
{
|
//获取胁迫联系方式信息失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uGetCoercePhoneNumberFail);
|
//拼接上【网关回复超时】的Msg
|
msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result.errorMessageBase);
|
|
this.ShowErrorMsg(msg);
|
return null;
|
}
|
//没有数据
|
if (result.checkCoercePhoneNumberResponseData.Result == 1)
|
{
|
return null;
|
}
|
return result.checkCoercePhoneNumberResponseData;
|
}
|
|
/// <summary>
|
/// 设置胁迫的联系人方式
|
/// </summary>
|
/// <param name="dicPhone">keys:联系方式 values:地区码</param>
|
/// <returns></returns>
|
public async Task<bool> SetCoercePhoneNumber(Dictionary<string, string> dicPhone)
|
{
|
var Pra = new Safeguard.SetCoercePhoneNumberData();
|
var Actonobj = new Safeguard.PushTargetActionObj();
|
Actonobj.Type = 2;
|
Pra.Actions.Add(Actonobj);
|
Pra.LoginToken = this.GetLoginToken();
|
|
foreach (string phoneNum in dicPhone.Keys)
|
{
|
var phoneInfo = new Safeguard.PushTargetInfo();
|
Actonobj.PushTarget.Add(phoneInfo);
|
//电话号码
|
phoneInfo.PushNumber = dicPhone[phoneNum] + "-" + phoneNum;
|
}
|
|
var result = await Safeguard.SetCoercePhoneNumberAsync(Pra);
|
if (result == null || result.setCoercePhoneNumberResponseData == null || result.setCoercePhoneNumberResponseData.Result != 0)
|
{
|
//修改胁迫联系方式失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uChangedCoercePhoneNumberFail);
|
//拼接上【网关回复超时】的Msg
|
msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result.errorMessageBase);
|
|
this.ShowErrorMsg(msg);
|
return false;
|
}
|
|
return true;
|
}
|
|
/// <summary>
|
/// 删除胁迫的联系人方式
|
/// </summary>
|
/// <param name="areaCode"></param>
|
/// <param name="phoneNum"></param>
|
/// <returns></returns>
|
public async Task<bool> DeleteCoercePhoneNumber(string areaCode, string phoneNum)
|
{
|
var Pra = new Safeguard.DelCoercePhoneNumberData();
|
var Actonobj = new Safeguard.PushTargetActionObj();
|
Actonobj.Type = 2;
|
Pra.Actions.Add(Actonobj);
|
Pra.LoginToken = this.GetLoginToken();
|
|
var phoneInfo = new Safeguard.PushTargetInfo();
|
Actonobj.PushTarget.Add(phoneInfo);
|
//电话号码
|
phoneInfo.PushNumber = areaCode + "-" + phoneNum;
|
|
var result = await Safeguard.DelCoercePhoneNumberAsync(Pra);
|
if (result == null || result.delCoercePhoneNumberResponseData == null || result.delCoercePhoneNumberResponseData.Result != 0)
|
{
|
//删除胁迫联系方式失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uDeleteCoercePhoneNumberFail);
|
//拼接上【网关回复超时】的Msg
|
msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result.errorMessageBase);
|
|
this.ShowErrorMsg(msg);
|
return false;
|
}
|
|
return true;
|
}
|
|
#endregion
|
|
#region ■ 传感器报警_________________________
|
|
/// <summary>
|
/// 获取传感器报警的信息翻译文本(返回null则表示没有达成报警条件,停止报警则返回空字符串)
|
/// </summary>
|
/// <param name="i_device"></param>
|
/// <returns></returns>
|
public IASZoneReportInfo GetSensorAlarmInfo(CommonDevice i_device)
|
{
|
//IAS安防信息上报
|
if ((i_device is IASZone) == false)
|
{
|
return null;
|
}
|
string mainkey = Common.LocalDevice.Current.GetDeviceMainKeys(i_device);
|
//因为推送的是虚拟的设备，所以去获取真实物理设备
|
CommonDevice device = Common.LocalDevice.Current.GetDevice(mainkey);
|
if (device == null)
|
{
|
return null;
|
}
|
IASZone iASZone = (IASZone)i_device;
|
|
var alarmInfo = new IASZoneReportInfo();
|
if (iASZone.iASInfo.Battery == 1)
|
{
|
//电池电量低
|
alarmInfo.BatteryMsg = Language.StringByID(R.MyInternationalizationString.uLowElectricityConsumption);
|
}
|
if (iASZone.iASInfo.Tamper == 1)
|
{
|
//设备被拆除
|
alarmInfo.DemolishmenMsg = Language.StringByID(R.MyInternationalizationString.uDeviceWasDismantled);
|
}
|
|
//运动传感器
|
if (device.IasDeviceType == 13)
|
{
|
if (iASZone.iASInfo.Alarm1 == 1)
|
{
|
//有不明物体经过
|
alarmInfo.AlarmMsg = Language.StringByID(R.MyInternationalizationString.uHadUnKnowObjectPassed);
|
}
|
}
|
//烟雾传感器
|
else if (device.IasDeviceType == 40)
|
{
|
if (iASZone.iASInfo.Alarm1 == 1)
|
{
|
//烟雾报警
|
alarmInfo.AlarmMsg = Language.StringByID(R.MyInternationalizationString.uSmogAlarm);
|
}
|
}
|
//水侵传感器
|
else if (device.IasDeviceType == 42)
|
{
|
if (iASZone.iASInfo.Alarm1 == 1)
|
{
|
//检测到漏水
|
alarmInfo.AlarmMsg = Language.StringByID(R.MyInternationalizationString.uWaterLeakageDetection);
|
}
|
}
|
//燃气传感器
|
else if (device.IasDeviceType == 43)
|
{
|
if (iASZone.iASInfo.Alarm1 == 1)
|
{
|
//燃气泄漏
|
alarmInfo.AlarmMsg = Language.StringByID(R.MyInternationalizationString.uCarbonMonoxideRevealed);
|
}
|
}
|
//紧急按钮
|
else if (device.IasDeviceType == 44)
|
{
|
//紧急按钮
|
if (iASZone.iASInfo.Alarm1 == 1)
|
{
|
//紧急按钮被按下
|
alarmInfo.AlarmMsg = Language.StringByID(R.MyInternationalizationString.uEmergencyButtonPressdown);
|
}
|
}
|
//钥匙扣
|
else if (device.IasDeviceType == 277)
|
{
|
if (iASZone.iASInfo.Alarm1 == 1)
|
{
|
//钥匙扣触发报警
|
alarmInfo.AlarmMsg = Language.StringByID(R.MyInternationalizationString.uKeyFobAlarm);
|
}
|
}
|
//门窗传感器
|
else if (device.IasDeviceType == 21 || device.IasDeviceType == 22)
|
{
|
if (iASZone.iASInfo.Alarm1 == 1)
|
{
|
//门窗被打开
|
alarmInfo.AlarmMsg = Language.StringByID(R.MyInternationalizationString.uDoorOrWindowHadBeenOpen);
|
}
|
else
|
{
|
//门窗已关闭
|
alarmInfo.AlarmMsg = Language.StringByID(R.MyInternationalizationString.uDoorOrWindowHadClosed);
|
}
|
}
|
else
|
{
|
//传感器
|
if (iASZone.iASInfo.Alarm1 == 1)
|
{
|
//触发传感器报警
|
alarmInfo.AlarmMsg = Language.StringByID(R.MyInternationalizationString.uSensorAlarmHadTriggered);
|
}
|
}
|
return alarmInfo;
|
}
|
|
#endregion
|
|
#region ■ 安防报警保存_______________________
|
|
/// <summary>
|
/// 从新刷新缓存中的安防上报信息
|
/// </summary>
|
public void RefreshAlarmInfo()
|
{
|
this.listAlarmInfo.Clear();
|
string fileName = DateTime.Now.ToString("yyyyMMdd");
|
|
//判断有没有这个文件
|
string fullName = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.SafeguardAlarmDirectory, fileName);
|
if (System.IO.File.Exists(fullName) == true)
|
{
|
lock (objLock)
|
{
|
string dir = System.IO.Path.Combine(DirNameResourse.LocalMemoryDirectory, DirNameResourse.SafeguardAlarmDirectory);
|
var data = Global.ReadFileByDirectory(dir, fileName);
|
this.listAlarmInfo = JsonConvert.DeserializeObject<List<SafeguardAlarmInfo>>(System.Text.Encoding.UTF8.GetString(data));
|
if (this.listAlarmInfo == null)
|
{
|
this.listAlarmInfo = new List<SafeguardAlarmInfo>();
|
}
|
}
|
}
|
}
|
|
/// <summary>
|
/// 保存安防报警信息到本地
|
/// </summary>
|
/// <param name="device"></param>
|
public bool SaveSafeguardAlarmInfo(CommonDevice device)
|
{
|
int ZoneId = this.GetZoneIdByIASZone(device);
|
if (ZoneId == -1)
|
{
|
//这个传感器不存在于任何防区
|
return false;
|
}
|
var msgInfo = this.GetSensorAlarmInfo(device);
|
if (msgInfo == null)
|
{
|
//异常？？
|
return false;
|
}
|
|
//获取保存安防信息的文件名字
|
string fileName = this.GetSafeguardAlarmFileName();
|
|
var data = new SafeguardAlarmInfo();
|
data.AlarmType = SafeguardAlarmType.Sensor;
|
data.ZoneId = ZoneId;
|
data.DeviceAddr = device.DeviceAddr;
|
data.DeviceEpoint = device.DeviceEpoint;
|
data.DeviceName = device.DeviceName;
|
data.Time = DateTime.Now.ToString("HH:mm:ss");
|
data.RoomName = Common.Room.CurrentRoom.GetRoomNameByDevice(device);
|
//报警结束
|
data.AlarmMsg = msgInfo.AlarmMsg != string.Empty ? msgInfo.AlarmMsg : Language.StringByID(R.MyInternationalizationString.uAlarmFinish);
|
//电池报警
|
data.BatteryMsg = msgInfo.BatteryMsg;
|
//被拆报警
|
data.DemolishmentMsg = msgInfo.DemolishmenMsg;
|
|
//限制它的长度
|
this.listAlarmInfo.Insert(0, data);
|
if (this.listAlarmInfo.Count > 10)
|
{
|
this.listAlarmInfo.RemoveAt(this.listAlarmInfo.Count - 1);
|
}
|
|
lock (objLock)
|
{
|
//保存到本地
|
var saveData = JsonConvert.SerializeObject(this.listAlarmInfo);
|
var byteData = System.Text.Encoding.UTF8.GetBytes(saveData);
|
string dir = System.IO.Path.Combine(DirNameResourse.LocalMemoryDirectory, DirNameResourse.SafeguardAlarmDirectory);
|
Global.WriteFileToDirectoryByBytes(dir, fileName, byteData);
|
return true;
|
}
|
}
|
|
/// <summary>
|
/// 保存布防操作信息到本地
|
/// </summary>
|
/// <param name="garrison"></param>
|
public void SaveSafeguardAlarmInfo(GarrisonMode garrison)
|
{
|
if (garrison == GarrisonMode.None)
|
{
|
return;
|
}
|
//获取保存安防信息的文件名字
|
string fileName = this.GetSafeguardAlarmFileName();
|
|
var data = new SafeguardAlarmInfo();
|
data.Time = DateTime.Now.ToString("HH:mm:ss");
|
data.AlarmType = SafeguardAlarmType.Safeguard;
|
if (garrison == GarrisonMode.AtHome)
|
{
|
//没有内部防区
|
if (this.IsHadInternalDefenseArea() == false)
|
{
|
//布防已执行
|
data.AlarmMsg = Language.StringByID(R.MyInternationalizationString.uExecuteGarrison);
|
}
|
else
|
{
|
//在家布防已执行
|
data.AlarmMsg = Language.StringByID(R.MyInternationalizationString.uExecuteAtHomeGarrison);
|
}
|
}
|
else if (garrison == GarrisonMode.RemoveHome)
|
{
|
//离家布防已执行
|
data.AlarmMsg = Language.StringByID(R.MyInternationalizationString.uExecuteRemoveHomeGarrison);
|
}
|
else if (garrison == GarrisonMode.RemoveGarrison)
|
{
|
//撤防已执行
|
data.AlarmMsg = Language.StringByID(R.MyInternationalizationString.uExecuteWithdrawGarrison);
|
}
|
else
|
{
|
return;
|
}
|
//限制它的长度
|
this.listAlarmInfo.Insert(0, data);
|
if (this.listAlarmInfo.Count > 10)
|
{
|
this.listAlarmInfo.RemoveAt(this.listAlarmInfo.Count - 1);
|
}
|
|
lock (objLock)
|
{
|
//保存到本地
|
var saveData = JsonConvert.SerializeObject(this.listAlarmInfo);
|
var byteData = System.Text.Encoding.UTF8.GetBytes(saveData);
|
string dir = System.IO.Path.Combine(DirNameResourse.LocalMemoryDirectory, DirNameResourse.SafeguardAlarmDirectory);
|
Global.WriteFileToDirectoryByBytes(dir, fileName, byteData);
|
}
|
}
|
|
/// <summary>
|
/// 获取保存安防信息的文件名字
|
/// </summary>
|
/// <returns></returns>
|
private string GetSafeguardAlarmFileName()
|
{
|
string fileName = DateTime.Now.ToString("yyyyMMdd");
|
if (fileName != oldDeviceAlarmFile)
|
{
|
//考虑到用户有可能24点的时候不退出APP,这个时候直接刷新
|
this.RefreshAlarmInfo();
|
}
|
oldDeviceAlarmFile = fileName;
|
return fileName;
|
}
|
|
/// <summary>
|
/// 获取
|
/// </summary>
|
/// <returns></returns>
|
public Dictionary<string, List<SafeguardAlarmInfo>> GetSafeguardAlarmInfo()
|
{
|
lock (objLock)
|
{
|
string fullPath = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.SafeguardAlarmDirectory);
|
//借用一下自动备份获取指定目录下面的文件的函数
|
List<string> listFile = HdlAutoBackupLogic.GetFileFromDirectory(fullPath);
|
//升序
|
listFile.Sort();
|
var dic = new Dictionary<string, List<SafeguardAlarmInfo>>();
|
string dir = System.IO.Path.Combine(DirNameResourse.LocalMemoryDirectory, DirNameResourse.SafeguardAlarmDirectory);
|
for (int i = listFile.Count - 1; i >= 0; i--)
|
{
|
var data = Global.ReadFileByDirectory(dir, listFile[i]);
|
var info = JsonConvert.DeserializeObject<List<SafeguardAlarmInfo>>(System.Text.Encoding.UTF8.GetString(data));
|
if (info == null)
|
{
|
continue;
|
}
|
var listInfo = new List<SafeguardAlarmInfo>();
|
for (int j = 0; j < info.Count; j++)
|
{
|
if (j == 10)
|
{
|
//每天最多十条数据
|
break;
|
}
|
listInfo.Add(info[j]);
|
}
|
dic[listFile[i]] = listInfo;
|
|
if (dic.Count == 3)
|
{
|
//只要三天的量
|
break;
|
}
|
}
|
return dic;
|
}
|
}
|
|
#endregion
|
|
#region ■ 重置管理员密码_____________________
|
|
/// <summary>
|
/// 重置管理员密码(内部会弹出错误信息)
|
/// </summary>
|
/// <param name="password">新密码</param>
|
/// <returns></returns>
|
public async Task<bool> DoResetAdministratorPsw(string password)
|
{
|
var realWay = ZigBee.Device.ZbGateway.MainGateWay;
|
if (realWay == null)
|
{
|
//错误:网关对象丢失
|
string msg = Language.StringByID(R.MyInternationalizationString.uErrorGatewayLostMsg);
|
this.ShowTipMsg(msg);
|
return false;
|
}
|
//是否达成中断的时机
|
bool canBreak = false;
|
bool success = false;
|
//超时时间
|
int TimeOut = 0;
|
string checkTopic = Common.LocalGateway.Current.GetGatewayId(realWay) + "/Security/AdminSetNewPassword_Respon";
|
Action<string, string> getResultAction = (topic, message) =>
|
{
|
try
|
{
|
if (topic == checkTopic)
|
{
|
TimeOut = 0;
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
var result = JsonConvert.DeserializeObject<int>(jobject["Data"]["Result"].ToString());
|
success = result == 0;
|
canBreak = true;
|
}
|
}
|
catch { }
|
};
|
|
realWay.Actions += getResultAction;
|
try
|
{
|
var jObject = new Newtonsoft.Json.Linq.JObject { { "Cluster_ID", 0 }, { "Command", 4033 } };
|
var data = new Newtonsoft.Json.Linq.JObject { { "HomeId", Common.Config.Instance.HomeId }, { "Password", password } };
|
jObject.Add("Data", data);
|
await realWay.Send("Security/AdminSetNewPassword", jObject.ToString());
|
}
|
catch
|
{
|
canBreak = true;
|
//出现未知错误,请稍后再试
|
string msg = Language.StringByID(R.MyInternationalizationString.uUnKnowErrorAndResetAgain);
|
this.ShowTipMsg(msg);
|
}
|
|
while (canBreak == false && TimeOut < 60)
|
{
|
await Task.Delay(100);
|
TimeOut++;
|
}
|
|
realWay.Actions -= getResultAction;
|
if (TimeOut >= 60)
|
{
|
//重置管理员密码失败(网关回复超时)
|
string msg = Language.StringByID(R.MyInternationalizationString.uResetAdministratorPswFail);
|
msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, "回复超时");
|
this.ShowTipMsg(msg);
|
return false;
|
}
|
if (success == false)
|
{
|
//重置管理员密码失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uResetAdministratorPswFail);
|
this.ShowTipMsg(msg);
|
}
|
return success;
|
}
|
|
#endregion
|
|
#region ■ 一般方法___________________________
|
|
/// <summary>
|
/// 获取所有防区的ID(默认是1～5)
|
/// </summary>
|
/// <returns></returns>
|
private List<int> GetAllZoneId()
|
{
|
//防区id
|
//1：24小时防区
|
//2：24小时静音防区
|
//3：出入防区
|
//4：内部防区
|
//5：周界防区
|
List<int> list = new List<int>() { 1, 2, 3, 4, 5 };
|
return list;
|
}
|
|
/// <summary>
|
/// 获取防区的翻译名字
|
/// </summary>
|
/// <param name="ZoneID"></param>
|
/// <returns></returns>
|
public string GetGarrisonText(int ZoneID)
|
{
|
if (ZoneID == 1)
|
{
|
//24小时防区
|
return Language.StringByID(R.MyInternationalizationString.u24HourSectors);
|
}
|
else if (ZoneID == 2)
|
{
|
//静音防区
|
return Language.StringByID(R.MyInternationalizationString.uMuteSectors);
|
}
|
else if (ZoneID == 3)
|
{
|
//出入防区
|
return Language.StringByID(R.MyInternationalizationString.uInAndOutSectors);
|
}
|
else if (ZoneID == 4)
|
{
|
//内部防区
|
return Language.StringByID(R.MyInternationalizationString.uInteriorSectors);
|
}
|
else if (ZoneID == 5)
|
{
|
//周界防区
|
return Language.StringByID(R.MyInternationalizationString.uPerimeterSectors);
|
}
|
return string.Empty;
|
}
|
|
/// <summary>
|
/// 显示错误信息窗口
|
/// </summary>
|
/// <param name="msg"></param>
|
private void ShowErrorMsg(string msg)
|
{
|
Application.RunOnMainThread(() =>
|
{
|
var contr = new ErrorMsgControl(msg);
|
contr.Show();
|
});
|
}
|
|
/// <summary>
|
/// 显示正常信息窗口
|
/// </summary>
|
/// <param name="msg"></param>
|
private void ShowNormalMsg(string msg)
|
{
|
Application.RunOnMainThread(() =>
|
{
|
var contr = new NormalMsgControl(msg);
|
contr.Show();
|
});
|
}
|
|
/// <summary>
|
/// 显示Tip窗口
|
/// </summary>
|
/// <param name="msg"></param>
|
private void ShowTipMsg(string msg)
|
{
|
Application.RunOnMainThread(() =>
|
{
|
var contr = new TipViewControl(msg);
|
contr.ShowView();
|
});
|
}
|
|
/// <summary>
|
/// 加密密码
|
/// </summary>
|
/// <param name="strPsw"></param>
|
/// <returns></returns>
|
private string EncryptPassword(string strPsw)
|
{
|
string sKey = "hdljkdrt";
|
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
|
byte[] inputByteArray = Encoding.Default.GetBytes(strPsw);
|
des.Key = ASCIIEncoding.ASCII.GetBytes(sKey);
|
des.IV = ASCIIEncoding.ASCII.GetBytes(sKey);
|
MemoryStream ms = new MemoryStream();
|
CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), 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();
|
}
|
|
/// <summary>
|
/// 解密密码
|
/// </summary>
|
/// <param name="strPsw"></param>
|
/// <returns></returns>
|
private string DecryptPassword(string strPsw)
|
{
|
string sKey = "hdljkdrt";
|
|
DESCryptoServiceProvider des = new 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(sKey);
|
des.IV = ASCIIEncoding.ASCII.GetBytes(sKey);
|
MemoryStream ms = new MemoryStream();
|
CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
|
cs.Write(inputByteArray, 0, inputByteArray.Length);
|
cs.FlushFinalBlock();
|
|
StringBuilder ret = new StringBuilder();
|
|
return System.Text.Encoding.Default.GetString(ms.ToArray());
|
}
|
|
|
/// <summary>
|
/// 获取设备的唯一主键
|
/// </summary>
|
/// <param name="device"></param>
|
/// <returns></returns>
|
private string GetDeviceMainKeys(CommonDevice device)
|
{
|
return Common.LocalDevice.Current.GetDeviceMainKeys(device);
|
}
|
|
/// <summary>
|
/// 获取登陆者的Token(好像管理员登陆的时候,需要变更Token,所以暂且定义一个函数出来)
|
/// </summary>
|
/// <returns></returns>
|
private string GetLoginToken()
|
{
|
return Shared.Common.Config.Instance.Token;
|
}
|
|
#endregion
|
}
|
|
/// <summary>
|
/// 安防本地缓存(生成本地保存文件使用)
|
/// </summary>
|
public class LocalSafeguardData
|
{
|
#region ■ 变量声明___________________________
|
|
/// <summary>
|
/// 安防文件
|
/// </summary>
|
public const string LocalSecurityFile = "LocalSecurityFile.json";
|
/// <summary>
|
/// 防区的信息(Keys:防区ID, value:防区的信息)
|
/// </summary>
|
public Dictionary<int, SafeguardZoneInfo> dicAllZoneInfo = new Dictionary<int, SafeguardZoneInfo>();
|
|
#endregion
|
|
#region ■ 保存方法___________________________
|
|
/// <summary>
|
/// 保存现阶段的网关信息到本地文件
|
/// </summary>
|
public void SaveToLocaltion()
|
{
|
var file = JsonConvert.SerializeObject(this);
|
|
var bytes = System.Text.Encoding.UTF8.GetBytes(file);
|
Global.WriteFileByBytesByHomeId(LocalSecurityFile, bytes);
|
}
|
|
#endregion
|
}
|
|
/// <summary>
|
/// 内部使用，安防防区的一些信息
|
/// </summary>
|
public class SafeguardZoneInfo
|
{
|
#region ■ 变量声明___________________________
|
|
/// <summary>
|
/// 防区id。
|
/// </summary>
|
public int ZoneId;
|
/// <summary>
|
/// 布防防区名称 ，最大32个字符
|
/// </summary>
|
public string ZoneName;
|
/// <summary>
|
/// 信息推送 0:推送 1:不推送 (只有防区ID:1,2,3才会有。4,5的都归为3,因为它是以防区模式ID(ActionType)为单位的)
|
/// </summary>
|
public int InformationPush = 1;
|
/// <summary>
|
/// 传感器设备的信息(keys:设备主键)
|
/// </summary>
|
public Dictionary<string, Safeguard.ZoneDeviceListData> dicSensor = new Dictionary<string, Safeguard.ZoneDeviceListData>();
|
/// <summary>
|
/// 该防区下全部设备文件路径(keys:设备主键,value:设备文件路径)
|
/// </summary>
|
public Dictionary<string, string> dicAllDevice = new Dictionary<string, string>();
|
/// <summary>
|
/// 该防区下面的报警设备(keys:设备主键),＜只有防区ID:1,2,3才会有。4,5的都归为3,因为它是以防区模式ID(ActionType)为单位的＞
|
/// </summary>
|
public Dictionary<string, Safeguard.CatActionResponseObj> dicAlarmDevice = new Dictionary<string, Safeguard.CatActionResponseObj>();
|
/// <summary>
|
/// 该防区下面的场景(keys:场景No),＜只有防区ID:1,2,3才会有。4,5的都归为3,因为它是以防区模式ID(ActionType)为单位的＞
|
/// </summary>
|
public Dictionary<int, string> dicScenes = new Dictionary<int, string>();
|
|
#endregion
|
}
|
}
|
