using Shared.Common;
|
using System;
|
using System.Collections.Generic;
|
using System.Text;
|
using System.Threading.Tasks;
|
using ZigBee.Device;
|
|
namespace Shared.Phone.UserCenter
|
{
|
/// <summary>
|
/// 场景的逻辑
|
/// </summary>
|
public class HdlSceneLogic
|
{
|
#region ■ 变量声明___________________________
|
|
/// <summary>
|
/// 场景的逻辑
|
/// </summary>
|
private static HdlSceneLogic m_Current = null;
|
/// <summary>
|
/// 场景的逻辑
|
/// </summary>
|
public static HdlSceneLogic Current
|
{
|
get
|
{
|
if (m_Current == null)
|
{
|
m_Current = new HdlSceneLogic();
|
}
|
return m_Current;
|
}
|
}
|
|
/// <summary>
|
/// 场景对象
|
/// </summary>
|
private Dictionary<int, SceneUI> dicScenes = new Dictionary<int, SceneUI>();
|
|
#endregion
|
|
#region ■ 刷新场景___________________________
|
|
/// <summary>
|
/// 从本地刷新场景
|
/// </summary>
|
public void ReFreshByLocal()
|
{
|
//清空场景
|
this.dicScenes.Clear();
|
//获取全部文件
|
var listFile = this.GetAllSceneFile();
|
foreach (string fileName in listFile)
|
{
|
try
|
{
|
var jsonInfo = Encoding.UTF8.GetString(Global.ReadFileByHomeId(fileName));
|
var tempScene = Newtonsoft.Json.JsonConvert.DeserializeObject<SceneUI>(jsonInfo);
|
if (tempScene == null)
|
{
|
continue;
|
}
|
this.dicScenes[tempScene.Id] = tempScene;
|
}
|
catch(Exception ex)
|
{
|
HdlLogLogic.Current.WriteLog(ex);
|
try
|
{
|
//删掉错误文件
|
Global.DeleteFilebyHomeId(fileName);
|
}
|
catch { }
|
}
|
}
|
}
|
|
/// <summary>
|
/// 刷新本地的全部场景
|
/// </summary>
|
public bool RefreshSceneUIList()
|
{
|
//获取网关存在的场景
|
var sceneList = this.RefreshSceneListFromGateway();
|
if (sceneList == null)
|
{
|
return false;
|
}
|
var listEsxit = new HashSet<int>();
|
foreach (var scene in sceneList)
|
{
|
if (scene == null)
|
{
|
continue;
|
}
|
listEsxit.Add(scene.ScenesId);
|
//刷新scene的信息
|
this.RefreshScene(scene);
|
}
|
|
var listDelete = new List<SceneUI>();
|
foreach (var scId in this.dicScenes.Keys)
|
{
|
if (listEsxit.Contains(scId) == false)
|
{
|
//删除的对象
|
listDelete.Add(this.dicScenes[scId]);
|
}
|
}
|
foreach (var sceneui in listDelete)
|
{
|
//执行删除
|
this.DeleteLocalScene(sceneui);
|
}
|
|
return true;
|
}
|
|
/// <summary>
|
/// 刷新scene的信息
|
/// </summary>
|
/// <param name="sceneInfo"></param>
|
private void RefreshScene(Scene.GetSceneAllInfo sceneInfo)
|
{
|
if (this.dicScenes.ContainsKey(sceneInfo.ScenesId) == true)
|
{
|
var localScene = this.dicScenes[sceneInfo.ScenesId];
|
//只刷新名字和绑定表
|
localScene.Name = sceneInfo.ScenesName;
|
localScene.AdjustTargetList.Clear();
|
localScene.AdjustTargetList.AddRange(sceneInfo.DeviceList);
|
localScene.Save();
|
}
|
else
|
{
|
var newScene = new SceneUI();
|
newScene.Name = sceneInfo.ScenesName;
|
newScene.IconPath = "SceneIcon/0.png";
|
newScene.Id = sceneInfo.ScenesId;
|
newScene.AdjustTargetList.AddRange(sceneInfo.DeviceList);
|
//添加缓存
|
newScene.Save();
|
//加入缓存
|
this.dicScenes[newScene.Id] = newScene;
|
//备份
|
HdlAutoBackupLogic.AddOrEditorFile(newScene.FileName);
|
}
|
|
}
|
|
/// <summary>
|
/// 从网关重新刷新场景列表
|
/// </summary>
|
/// <returns></returns>
|
private List<Scene.GetSceneAllInfo> RefreshSceneListFromGateway()
|
{
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
//获取网关对象失败
|
this.ShowTipMsg(Language.StringByID(R.MyInternationalizationString.uGetGatewayTagartFail));
|
return null;
|
}
|
|
//超时时间
|
int TimeOut = 0;
|
bool receiptAll = false;
|
|
var listScene = new List<Scene.GetSceneAllInfo>();
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Scene/GetAllInfo_Respon")
|
{
|
var sceneGetAllInfo = Newtonsoft.Json.JsonConvert.DeserializeObject<Scene.GetSceneAllInfo>(jobject["Data"].ToString());
|
listScene.Add(sceneGetAllInfo);
|
|
if (sceneGetAllInfo.ScenesNum == sceneGetAllInfo.ScenesSum)
|
{
|
//接收完成
|
receiptAll = true;
|
TimeOut = 0;
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
|
var jObject = new Newtonsoft.Json.Linq.JObject { { "Cluster_ID", 0 }, { "Command", 807 } };
|
mainGateway.Send(("Scene/GetAllInfo"), System.Text.Encoding.UTF8.GetBytes(jObject.ToString()));
|
|
int waitTime = 20 * 6;
|
while (receiptAll == false && TimeOut < waitTime)
|
{
|
//全部接收才退出
|
System.Threading.Thread.Sleep(50);
|
TimeOut++;
|
}
|
mainGateway.Actions -= action;
|
action = null;
|
if (receiptAll == false)
|
{
|
//网络不稳定，场景列表信息缺损
|
this.ShowTipMsg(Language.StringByID(R.MyInternationalizationString.uNetworkUnStableAndSceneInfoIsNotFull));
|
return null;
|
}
|
|
return listScene;
|
}
|
|
#endregion
|
|
#region ■ 添加场景___________________________
|
|
/// <summary>
|
/// 添加新场景到网关(返回null代表出错)
|
/// </summary>
|
/// <param name="sceneName">场景名称</param>
|
/// <param name="listAdjustTarget">执行目标</param>
|
/// <returns></returns>
|
public async Task<SceneUI> AddNewSceneToGateway(string sceneName, List<Scene.DeviceListData> listAdjustTarget)
|
{
|
int NewScenesId = -1;
|
//如果当前住宅不是虚拟住宅
|
if (Common.Config.Instance.Home.IsVirtually == false)
|
{
|
var result1 = await Scene.GetSceneNewIdAsync(sceneName);
|
//共通错误检测
|
string error = HdlCheckLogic.Current.CheckCommonErrorCode(result1);
|
if (error != null)
|
{
|
this.ShowErrorMsg(error);
|
return null;
|
}
|
if (result1 == null || result1.getSceneIdData == null)
|
{
|
//添加场景失败
|
string msg1 = Language.StringByID(R.MyInternationalizationString.AddSceneFail);
|
//拼接上【网关回复超时】的Msg
|
msg1 = UserCenterLogic.CombineGatewayTimeOutMsg(msg1, result1);
|
this.ShowTipMsg(msg1);
|
return null;
|
}
|
NewScenesId = result1.getSceneIdData.NewScenesId;
|
}
|
else
|
{
|
//虚拟场景ID
|
NewScenesId = Convert.ToInt32(DateTime.Now.ToString("HHmmss"));
|
}
|
//添加执行目标
|
var listSuccess = await this.AddTargetToScene(NewScenesId, listAdjustTarget);
|
if (listSuccess == null)
|
{
|
return null;
|
}
|
|
//创建场景对象
|
var newScene = new SceneUI();
|
newScene.Name = sceneName;
|
newScene.Id = NewScenesId;
|
newScene.AdjustTargetList.AddRange(listSuccess);
|
//添加缓存
|
newScene.Save();
|
//加入缓存
|
this.dicScenes[newScene.Id] = newScene;
|
|
return newScene;
|
}
|
|
/// <summary>
|
/// 添加执行目标到指定的场景(返回成功添加的执行目标)
|
/// </summary>
|
/// <param name="sceneId">场景Id</param>
|
/// <param name="listAdjustTarget">执行目标</param>
|
/// <returns></returns>
|
private async Task<List<Scene.DeviceListData>> AddTargetToScene(int sceneId, List<Scene.DeviceListData> listAdjustTarget)
|
{
|
//如果当前住宅是虚拟住宅的话
|
if (Common.Config.Instance.Home.IsVirtually == true)
|
{
|
//不需要更新网关
|
return listAdjustTarget;
|
}
|
var listSuccess = new List<Scene.DeviceListData>();
|
for (int i = 0; i < listAdjustTarget.Count; i++)
|
{
|
var data = listAdjustTarget[i];
|
var addData = new Scene.AddSceneMemberData();
|
if (data.Type == 0)
|
{
|
//设备
|
addData.Type = 0;
|
addData.ScenesId = sceneId;
|
addData.DeviceAddr = data.DeviceAddr;
|
addData.Epoint = data.Epoint;
|
addData.TaskList = data.TaskList;
|
addData.DelayTime = 0;
|
addData.MemberNumber = i + 1;
|
}
|
else if (data.Type == 1)
|
{
|
//场景
|
addData.Type = 1;
|
addData.ScenesId = sceneId;
|
addData.ElseScenesId = data.ElseScenesId;
|
addData.DelayTime = 0;
|
addData.MemberNumber = i + 1;
|
}
|
else
|
{
|
//延时
|
addData.Type = 2;
|
addData.ScenesId = sceneId;
|
addData.DelayTime = data.DelayTime;
|
addData.MemberNumber = i + 1;
|
}
|
|
//添加新成员 返回结果
|
var result2 = await Scene.AddSceneMemberAsync(addData);
|
if (result2 == null || result2.addSceneMemberResponseData == null
|
|| result2.addSceneMemberResponseData.Result != 1)
|
{
|
continue;
|
}
|
//拥有成功的
|
listSuccess.Add(data);
|
}
|
if (listSuccess.Count == 0)
|
{
|
//添加执行目标失败
|
string msg1 = Language.StringByID(R.MyInternationalizationString.uAddAdjustTargetFail);
|
this.ShowTipMsg(msg1);
|
return null;
|
}
|
//如果不是全部成功的话,提示
|
if (listSuccess.Count != listAdjustTarget.Count)
|
{
|
//个别执行目标添加失败
|
string msg1 = Language.StringByID(R.MyInternationalizationString.uSomeAdjustTargetAddFail);
|
this.ShowTipMsg(msg1);
|
}
|
return listSuccess;
|
}
|
|
/// <summary>
|
/// 添加场景(这个单纯只改房间)
|
/// </summary>
|
/// <param name="scene">Scene.</param>
|
public void AddSceneToRoom(Room i_room, SceneUI scene)
|
{
|
//添加缓存
|
if (i_room.ListSceneId.Contains(scene.Id) == false)
|
{
|
i_room.ListSceneId.Add(scene.Id);
|
i_room.Save();
|
}
|
}
|
|
/// <summary>
|
/// 改变场景房间
|
/// </summary>
|
/// <param name="scene">场景对象</param>
|
/// <param name="newRoomId">新的房间的ID</param>
|
public void ChangedSceneRoom(SceneUI scene, string newRoomId)
|
{
|
var room = HdlRoomLogic.Current.GetRoomBySceneId(scene.Id);
|
if (room != null)
|
{
|
//房间没有改变
|
if (room.Id == newRoomId)
|
{
|
return;
|
}
|
//从房间中移除缓存
|
this.DeleteSceneFromRoom(room, scene);
|
}
|
//添加进新房间
|
var newRoom = HdlRoomLogic.Current.GetRoomById(newRoomId);
|
this.AddSceneToRoom(newRoom, scene);
|
}
|
|
/// <summary>
|
/// 添加搜藏场景
|
/// </summary>
|
/// <param name="scene">Scene.</param>
|
public void AddLoveScene(SceneUI scene)
|
{
|
var nowRoom = HdlRoomLogic.Current.GetLoveRoom();
|
//添加缓存
|
if (nowRoom.ListSceneId.Contains(scene.Id) == false)
|
{
|
nowRoom.ListSceneId.Add(scene.Id);
|
nowRoom.Save();
|
}
|
}
|
|
/// <summary>
|
/// 添加虚拟场景
|
/// </summary>
|
/// <param name="sceneId">指定场景id,如果为-1,则会内部自动编号(可能会重复)</param>
|
/// <param name="sceneName">场景名字</param>
|
/// <param name="listAdjustTarget">绑定目标</param>
|
/// <returns></returns>
|
public SceneUI AddVirtualScene(int sceneId, string sceneName, List<Scene.DeviceListData> listAdjustTarget)
|
{
|
if (sceneId == -1)
|
{
|
sceneId = Convert.ToInt32(DateTime.Now.ToString("HHmmss"));
|
}
|
//创建场景对象
|
var newScene = new SceneUI();
|
newScene.Name = sceneName;
|
newScene.IconPath = "SceneIcon/0.png";
|
//虚拟场景ID
|
newScene.Id = sceneId;
|
if (listAdjustTarget != null)
|
{
|
newScene.AdjustTargetList.AddRange(listAdjustTarget);
|
}
|
//添加缓存
|
newScene.Save();
|
//加入缓存
|
this.dicScenes[newScene.Id] = newScene;
|
|
return newScene;
|
}
|
|
#endregion
|
|
#region ■ 修改场景___________________________
|
|
/// <summary>
|
/// 修改网关的场景
|
/// </summary>
|
/// <param name="sceneUI">场景对象</param>
|
/// <param name="listAdjustTarget">全部的执行目标</param>
|
/// <returns></returns>
|
public async Task<bool> EditorSceneFromGateway(SceneUI sceneUI, List<Scene.DeviceListData> listAdjustTarget)
|
{
|
//如果当前住宅是虚拟住宅的话
|
if (Common.Config.Instance.Home.IsVirtually == true)
|
{
|
//清空场景的执行目标列表的缓存
|
sceneUI.AdjustTargetList.Clear();
|
sceneUI.AdjustTargetList.AddRange(listAdjustTarget);
|
sceneUI.Save();
|
return true;
|
}
|
|
//先清空全部的执行目标
|
var deleteData = new Scene.SceneRemoveMemberData();
|
var deleteTargetData = new List<Scene.RemoveSceneDeviceListInfo>();
|
for (int i = 0; i < sceneUI.AdjustTargetList.Count; i++)
|
{
|
var data = sceneUI.AdjustTargetList[i];
|
var removeData = new Scene.RemoveSceneDeviceListInfo();
|
if (data.Type == 0)
|
{
|
//设备
|
removeData.Type = 0;
|
removeData.DeviceAddr = data.DeviceAddr;
|
removeData.Epoint = data.Epoint;
|
removeData.MemberNumber = data.MemberNumber;
|
}
|
else if (data.Type == 1)
|
{
|
//场景
|
removeData.Type = 1;
|
removeData.ElseScenesId = data.ElseScenesId;
|
removeData.MemberNumber = data.MemberNumber;
|
}
|
else
|
{
|
//延时
|
removeData.Type = 2;
|
removeData.DelayTime = data.DelayTime;
|
removeData.MemberNumber = data.MemberNumber;
|
}
|
//拥有成功的
|
deleteTargetData.Add(removeData);
|
}
|
deleteData.DeviceList = deleteTargetData;
|
deleteData.ScenesId = sceneUI.Id;
|
//执行清空
|
var result = await Scene.RemoveSceneMemberAsync(deleteData);
|
if (result == null || result.removeSceneMemberResponseData == null)
|
{
|
//初始化执行目标失败
|
string msg1 = Language.StringByID(R.MyInternationalizationString.uInitAdjustTargetFail);
|
//拼接上【网关回复超时】的Msg
|
msg1 = UserCenterLogic.CombineGatewayTimeOutMsg(msg1, result);
|
this.ShowTipMsg(msg1);
|
return false;
|
}
|
if (result.removeSceneMemberResponseData.Result != 0)
|
{
|
//初始化执行目标失败
|
string msg1 = Language.StringByID(R.MyInternationalizationString.uInitAdjustTargetFail);
|
this.ShowTipMsg(msg1);
|
return false;
|
}
|
//清空场景的执行目标列表的缓存
|
sceneUI.AdjustTargetList.Clear();
|
|
//然后重新添加
|
var listSuccess = await this.AddTargetToScene(sceneUI.Id, listAdjustTarget);
|
if (listSuccess == null)
|
{
|
return false;
|
}
|
sceneUI.AdjustTargetList.AddRange(listSuccess);
|
sceneUI.Save();
|
|
return true;
|
}
|
|
/// <summary>
|
/// 修改网关的场景名称
|
/// </summary>
|
/// <param name="scene">场景对象</param>
|
/// <param name="newName">新的名字</param>
|
/// <returns></returns>
|
public async Task<bool> EditorSceneNameFromGateway(SceneUI scene, string newName)
|
{
|
//如果当前住宅是虚拟住宅的话
|
if (Common.Config.Instance.Home.IsVirtually == true)
|
{
|
//不需要更新网关
|
return true;
|
}
|
var result1 = await Scene.RenameSceneAsync(scene.Id, newName);
|
//共通错误检测
|
string error = HdlCheckLogic.Current.CheckCommonErrorCode(result1);
|
if (error != null)
|
{
|
this.ShowErrorMsg(error);
|
return false;
|
}
|
if (result1 == null || result1.sceneRenameResponseData == null)
|
{
|
//修改场景名称失败
|
string msg1 = Language.StringByID(R.MyInternationalizationString.uEditorSceneNameFail);
|
//拼接上【网关回复超时】的Msg
|
msg1 = UserCenterLogic.CombineGatewayTimeOutMsg(msg1, result1);
|
this.ShowTipMsg(msg1);
|
return false;
|
}
|
if (result1.sceneRenameResponseData.Result == 2)
|
{
|
//目标场景不存在
|
string msg1 = Language.StringByID(R.MyInternationalizationString.uTargetSceneIsNotExsit);
|
this.ShowTipMsg(msg1);
|
return false;
|
}
|
if (result1.sceneRenameResponseData.Result != 1)
|
{
|
//修改场景名称失败
|
string msg1 = Language.StringByID(R.MyInternationalizationString.uEditorSceneNameFail);
|
this.ShowTipMsg(msg1);
|
return false;
|
}
|
return true;
|
}
|
|
#endregion
|
|
#region ■ 删除场景___________________________
|
|
/// <summary>
|
/// 删除本地场景数据
|
/// </summary>
|
/// <param name="sceneUI">Scene user interface.</param>
|
public void DeleteLocalScene(SceneUI sceneUI)
|
{
|
//移除缓存
|
this.dicScenes.Remove(sceneUI.Id);
|
var room = HdlRoomLogic.Current.GetRoomBySceneId(sceneUI.Id);
|
if (room != null)
|
{
|
room.ListSceneId.Remove(sceneUI.Id);
|
room.Save();
|
}
|
|
//移除喜爱
|
var roomLove = HdlRoomLogic.Current.GetLoveRoom();
|
if (roomLove.ListSceneId.Contains(sceneUI.Id) == true)
|
{
|
roomLove.ListSceneId.Remove(sceneUI.Id);
|
roomLove.Save();
|
}
|
|
//删除文件
|
if (Global.IsExistsByHomeId(sceneUI.FileName) == true)
|
{
|
Global.DeleteFilebyHomeId(sceneUI.FileName);
|
HdlAutoBackupLogic.DeleteFile(sceneUI.FileName);
|
}
|
//删除图片
|
if (sceneUI.IconPathType == 1 || sceneUI.IconPathType == 2)
|
{
|
if (Global.IsExistsByHomeId(sceneUI.IconPath))
|
{
|
Global.DeleteFilebyHomeId(sceneUI.IconPath);
|
HdlAutoBackupLogic.DeleteFile(sceneUI.IconPath);
|
}
|
}
|
}
|
|
/// <summary>
|
/// 删除场景(这个只移除内存)
|
/// </summary>
|
/// <param name="scene"></param>
|
public void DeleteSceneFromRoom(Room i_room, SceneUI scene)
|
{
|
//移除缓存
|
if (i_room.ListSceneId.Contains(scene.Id) == true)
|
{
|
i_room.ListSceneId.Remove(scene.Id);
|
i_room.Save();
|
}
|
}
|
|
/// <summary>
|
/// 删除搜藏场景
|
/// </summary>
|
/// <param name="scene"></param>
|
public void DeleteLoveScene(SceneUI scene)
|
{
|
var nowRoom = HdlRoomLogic.Current.GetLoveRoom();
|
//移除缓存
|
if (nowRoom.ListSceneId.Contains(scene.Id) == true)
|
{
|
nowRoom.ListSceneId.Remove(scene.Id);
|
nowRoom.Save();
|
}
|
}
|
|
#endregion
|
|
#region ■ 获取场景___________________________
|
|
/// <summary>
|
/// 通过场景id获取场景
|
/// </summary>
|
/// <returns>The scene UIB y scene identifier.</returns>
|
/// <param name="sceneId">Scene identifier.</param>
|
public SceneUI GetSceneUIBySceneId(int sceneId)
|
{
|
if (this.dicScenes.ContainsKey(sceneId) == true)
|
{
|
return this.dicScenes[sceneId];
|
}
|
return null;
|
}
|
|
/// <summary>
|
/// 获取该楼层所有场景
|
/// </summary>
|
/// <param name="floorId"></param>
|
/// <returns></returns>
|
public List<SceneUI> GetSameFloorScenes(string floorId)
|
{
|
List<SceneUI> sceneUIs = new List<SceneUI>();
|
var rooms = HdlRoomLogic.Current.GetRoomsByFloorId(floorId);
|
foreach (var r in rooms)
|
{
|
foreach (int sceneId in r.ListSceneId)
|
{
|
if (this.dicScenes.ContainsKey(sceneId) == true)
|
{
|
sceneUIs.Add(this.dicScenes[sceneId]);
|
}
|
}
|
}
|
return sceneUIs;
|
}
|
|
/// <summary>
|
/// 根据场景Id，获取楼层和房间名字(楼层,房间名字)
|
/// </summary>
|
/// <returns></returns>
|
public string GetZoneById(int sceneId)
|
{
|
var room = HdlRoomLogic.Current.GetRoomBySceneId(sceneId);
|
if (room == null)
|
{
|
return null;
|
}
|
var floorName = HdlResidenceLogic.Current.GetFloorNameById(room.FloorId);
|
//更改代码：如果floorName=“”也要判断，否则有“，”
|
if (string.IsNullOrEmpty(floorName))
|
{
|
return room.Name;
|
}
|
return $"{floorName},{room.Name}";
|
}
|
|
/// <summary>
|
/// 获取未分配区域场景
|
/// </summary>
|
/// <returns></returns>
|
public List<SceneUI> GetUnalloctedScenes()
|
{
|
List<SceneUI> sceneUIs = new List<SceneUI>();
|
//已经存在的场景
|
var listEsxit = new HashSet<int>();
|
var listAllRoom = HdlRoomLogic.Current.GetAllListRooms();
|
foreach (var room in listAllRoom)
|
{
|
if (room.IsLove == true)
|
{
|
//不包含收藏房间
|
continue;
|
}
|
foreach (int sceneId in room.ListSceneId)
|
{
|
if (listEsxit.Contains(sceneId) == false)
|
{
|
listEsxit.Add(sceneId);
|
}
|
}
|
}
|
foreach (var myScene in this.dicScenes.Values)
|
{
|
if (listEsxit.Contains(myScene.Id) == false)
|
{
|
sceneUIs.Add(myScene);
|
}
|
}
|
return sceneUIs;
|
}
|
|
/// <summary>
|
/// 获取全部房间的全部场景
|
/// </summary>
|
/// <returns></returns>
|
public List<SceneUI> GetAllRoomSceneList()
|
{
|
List<SceneUI> sceneUIs = new List<SceneUI>();
|
var listAllRoom = HdlRoomLogic.Current.GetAllListRooms();
|
foreach (var room in listAllRoom)
|
{
|
if (room.IsLove == true)
|
{
|
//不包含收藏房间
|
continue;
|
}
|
foreach (int sceneId in room.ListSceneId)
|
{
|
if (this.dicScenes.ContainsKey(sceneId) == true)
|
{
|
sceneUIs.Add(this.dicScenes[sceneId]);
|
}
|
}
|
}
|
|
return sceneUIs;
|
}
|
|
/// <summary>
|
/// 获取指定房间的全部场景
|
/// </summary>
|
/// <returns></returns>
|
public List<SceneUI> GetRoomSceneList(Room i_room)
|
{
|
List<SceneUI> sceneUIs = new List<SceneUI>();
|
foreach (int sceneId in i_room.ListSceneId)
|
{
|
if (this.dicScenes.ContainsKey(sceneId) == true)
|
{
|
sceneUIs.Add(this.dicScenes[sceneId]);
|
}
|
}
|
|
return sceneUIs;
|
}
|
|
#endregion
|
|
#region ■ 调用场景___________________________
|
|
/// <summary>
|
/// 调用场景
|
/// </summary>
|
/// <param name="scene"></param>
|
/// <returns></returns>
|
public async Task<bool> ControlScene(SceneUI scene)
|
{
|
if (scene.RemainTime > 0)
|
{
|
HdlThreadLogic.Current.RunMain(() =>
|
{
|
//该场景正在延时，请稍后
|
var msgContr = new ShowMsgControl(ShowMsgType.Tip, Language.StringByID(R.MyInternationalizationString.TheSceneIsDelaying));
|
msgContr.Show();
|
});
|
return false;
|
}
|
//如果是虚拟住宅
|
if (Common.Config.Instance.Home.IsVirtually == true)
|
{
|
//不调用网关
|
return true;
|
}
|
|
//执行调用场景
|
var result = await Scene.ControlSceneAsync(scene.Id, scene.SceneDelayTime);
|
if (result == null || result.sceneOpenData == null)
|
{
|
//控制场景失败
|
string msg = Language.StringByID(R.MyInternationalizationString.ControlSceneFail);
|
//拼接上【网关回复超时】的Msg
|
msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result);
|
HdlThreadLogic.Current.RunMain(() =>
|
{
|
//该场景正在延时，请稍后
|
var msgContr = new ShowMsgControl(ShowMsgType.Tip, msg);
|
msgContr.Show();
|
});
|
return false;
|
}
|
if (result.sceneOpenData.Result == 0)
|
{
|
//控制场景失败
|
string msg = Language.StringByID(R.MyInternationalizationString.ControlSceneFail);
|
HdlThreadLogic.Current.RunMain(() =>
|
{
|
//该场景正在延时，请稍后
|
var msgContr = new ShowMsgControl(ShowMsgType.Tip, msg);
|
msgContr.Show();
|
});
|
return false;
|
}
|
return true;
|
}
|
|
#endregion
|
|
#region ■ 获取场景的执行目标列表_____________
|
|
/// <summary>
|
/// 获取场景的执行目标列表
|
/// </summary>
|
/// <param name="i_scene">场景对象</param>
|
/// <returns></returns>
|
public async Task<List<Scene.DeviceListData>> GetAdjustTargetList(SceneUI i_scene)
|
{
|
//如果住宅为虚拟住宅
|
if (Common.Config.Instance.Home.IsVirtually == true)
|
{
|
var listAdjustTarget = new List<Scene.DeviceListData>();
|
listAdjustTarget.AddRange(i_scene.AdjustTargetList);
|
return listAdjustTarget;
|
}
|
|
var result = await Scene.GetSceneDeviceListAsync(i_scene.Id);
|
//共通错误检测
|
string error = HdlCheckLogic.Current.CheckCommonErrorCode(result);
|
if (error != null)
|
{
|
this.ShowErrorMsg(error);
|
return null;
|
}
|
if (result == null || result.getSceneDeviceListInfo == null)
|
{
|
//获取执行目标失败
|
string msg = Language.StringByID(R.MyInternationalizationString.uGetAdjustTargetFail);
|
//拼接上【网关回复超时】的Msg
|
msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result);
|
|
this.ShowTipMsg(msg);
|
return null;
|
}
|
i_scene.AdjustTargetList = result.getSceneDeviceListInfo.DeviceList;
|
//保存缓存
|
i_scene.Save(false);
|
|
var listData = new List<Scene.DeviceListData>();
|
listData.AddRange(result.getSceneDeviceListInfo.DeviceList);
|
|
return listData;
|
}
|
#endregion
|
|
#region ■ 延时时间线程_______________________
|
|
/// <summary>
|
/// 开启延时时间线程(旨在全部地方的同一场景时间同步)
|
/// </summary>
|
public void StartDelayTimeThread(SceneUI i_scene)
|
{
|
if (i_scene.RemainThreadAction == true)
|
{
|
//线程在运行中
|
return;
|
}
|
i_scene.RemainThreadAction = true;
|
|
HdlThreadLogic.Current.RunThread(() =>
|
{
|
while (i_scene.RemainTime > 0)
|
{
|
System.Threading.Thread.Sleep(1000);
|
i_scene.RemainTime--;
|
}
|
i_scene.RemainThreadAction = false;
|
});
|
}
|
|
#endregion
|
|
#region ■ 一般方法___________________________
|
|
/// <summary>
|
/// 获取本地全部的场景文件
|
/// </summary>
|
/// <returns></returns>
|
public List<string> GetAllSceneFile()
|
{
|
List<string> listSceneFile = new List<string>();
|
List<string> listAllFile = Global.FileListByHomeId();
|
|
foreach (string file in listAllFile)
|
{
|
if (file.StartsWith("Scene_") == false)
|
{
|
//如果不是场景文件
|
continue;
|
}
|
listSceneFile.Add(file);
|
}
|
return listSceneFile;
|
}
|
|
/// <summary>
|
/// 显示错误信息窗口
|
/// </summary>
|
/// <param name="msg"></param>
|
private void ShowErrorMsg(string msg)
|
{
|
Application.RunOnMainThread(() =>
|
{
|
var contr = new ShowMsgControl(ShowMsgType.Error, msg);
|
contr.Show();
|
});
|
}
|
|
/// <summary>
|
/// 显示Tip信息窗口
|
/// </summary>
|
/// <param name="msg"></param>
|
private void ShowTipMsg(string msg)
|
{
|
Application.RunOnMainThread(() =>
|
{
|
var contr = new ShowMsgControl(ShowMsgType.Tip, msg);
|
contr.Show();
|
});
|
}
|
|
#endregion
|
}
|
}
|
