using System;
|
using System.Collections.Generic;
|
using System.Text;
|
using Newtonsoft.Json.Linq;
|
|
namespace ZigBee.Device
|
{
|
[System.Serializable]
|
public class Scene
|
{
|
/// <summary>
|
/// 当前主网关的ID
|
/// </summary>
|
public string GateWayId;
|
|
/// <summary>
|
/// 网关返回场景的命令标识
|
/// </summary>
|
public int DataID;
|
|
/// <summary>
|
/// 网关反馈的时间戳
|
/// </summary>
|
public int Time;
|
|
/// <summary>
|
/// 当前场景的ID
|
/// </summary>
|
[System.Serializable]
|
public class SceneBase
|
{
|
/// <summary>
|
/// 场景的I
|
/// </summary>
|
public int SceneId;
|
}
|
|
/// <summary>
|
/// 等待从网关接收数据的时间
|
/// </summary>
|
/// <value>The wait receive data time.</value>
|
public static int WaitReceiveDataTime
|
{
|
get
|
{
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
return 3000;
|
}
|
else if (mainGateway.IsVirtual)
|
{
|
return 6000;
|
}
|
else
|
{
|
return 3000;
|
}
|
}
|
}
|
|
/// <summary>
|
/// 网关信息错误反馈的内容
|
/// </summary>
|
static string ErrorMess(int err)
|
{
|
string message = "";
|
switch (err)
|
{
|
case 1:
|
message = " 网关无法解析命令数据。";
|
break;
|
case 2:
|
message = " 协调器正在升级或备份 / 恢复数据。";
|
break;
|
case 3:
|
message = "操作设备 / 组 / 场景不存在";
|
break;
|
case 4:
|
message = " 其他错误";
|
break;
|
case 5:
|
message = " 数据传输错误（在某次客户端向网关发送数据的过程中，网关在合理时间范围内接收客户端数据不完整导致该错误发生。如客户端向网关一次发送100个字节的数据，但网关等待接收了一秒只接收了80个字节。发生该错误，网关将主动关闭客户端连接）";
|
break;
|
default:
|
break;
|
}
|
return message;
|
}
|
|
#region 在从网关中发场景的命令的反馈
|
/// <summary>
|
///在从网关中发场景的命令的反馈
|
/// </summary>
|
public SceneErrorRespon sceneErrorRespon;
|
/// <summary>
|
///在从网关中发场景的命令的反馈
|
/// </summary>
|
[System.Serializable]
|
public class SceneErrorRespon
|
{
|
/// <summary>
|
/// 非主网关不能使用场景指令。
|
/// </summary>
|
public int Data_ID;
|
|
}
|
#endregion
|
|
#region 创建一个空场景
|
///<summary >
|
/// 创建一个空场景.(仅用于主网关接口）
|
/// <para>sceneName:取该场景的名字</para>
|
/// </summary>
|
public static async System.Threading.Tasks.Task<GetSceneIdAllData> GetSceneNewIdAsync(string sceneName)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
GetSceneIdAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new GetSceneIdAllData {errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new GetSceneIdAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new GetSceneIdAllData { errorResponData = temp , errorMessageBase = ErrorMess(temp.Error)};
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Scene/GetNewId_Respon")
|
{
|
var getSceneIdData = Newtonsoft.Json.JsonConvert.DeserializeObject<Scene.GetSceneIdData>(jobject["Data"].ToString());
|
if (getSceneIdData == null)
|
{
|
d = new GetSceneIdAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
GetSceneAllInfoAsync();
|
d = new GetSceneIdAllData { getSceneIdData = getSceneIdData };
|
System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
|
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Scene/GetNewId_Actions 启动" + System.DateTime.Now.ToString());
|
try{
|
var bytes = new byte[32];
|
var reamarkGwBytes = System.Text.Encoding.UTF8.GetBytes(sceneName);
|
System.Array.Copy(reamarkGwBytes, 0, bytes, 0, 32 < reamarkGwBytes.Length ? 32 : reamarkGwBytes.Length);
|
sceneName = System.Text.Encoding.UTF8.GetString(bytes);
|
|
var jObject = new Newtonsoft.Json.Linq.JObject() {
|
{ "Cluster_ID", 0 },
|
{ "Command", 800 }
|
};
|
var data = new JObject { { "ScenesName", sceneName } };
|
jObject.Add("Data", data);
|
mainGateway.Send("Scene/GetNewId", jObject.ToString());
|
|
}
|
catch
|
{ }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new GetSceneIdAllData { errorMessageBase = " 回复超时，请重新操作" };
|
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Scene/GetNewId_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 创建一个空场景返回的数据,网关反馈信息
|
/// </summary>
|
public GetSceneIdAllData getSceneIdAllData;
|
/// <summary>
|
/// 创建一个空场景返回的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class GetSceneIdAllData:CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 创建一个空场景返回的数据
|
/// </summary>
|
public GetSceneIdData getSceneIdData;
|
}
|
|
/// <summary>
|
/// 创建一个空场景返回的数据
|
/// </summary>
|
public GetSceneIdData getSceneIdData;
|
/// <summary>
|
/// 创建一个空场景返回的数据
|
/// </summary>
|
[System.Serializable]
|
public class GetSceneIdData
|
{
|
/// <summary>
|
/// 新的场景id
|
/// </summary>
|
public int NewScenesId;
|
/// <summary>
|
/// 场景名称 ，不大于32个字节。
|
/// </summary>
|
public string ScenesName;
|
}
|
#endregion
|
|
#region 获取一个场景的所有信息
|
///<summary >
|
///获取一个场景的所有信息 .
|
///</summary>
|
public static async System.Threading.Tasks.Task<GetSceneAllData> GetSceneAllInfoAsync()
|
{
|
return await System.Threading.Tasks.Task.Run(async () => {
|
GetSceneAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new GetSceneAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
|
var dateTime = DateTime.Now;
|
Action<string, string> action = (topic, message) => {
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new GetSceneAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new GetSceneAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error)};
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Scene/GetAllInfo_Respon")
|
{
|
dateTime = DateTime.Now;
|
var sceneGetAllInfo = Newtonsoft.Json.JsonConvert.DeserializeObject<GetSceneAllInfo>(jobject["Data"].ToString());
|
|
if (sceneGetAllInfo == null)
|
{
|
d = new GetSceneAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
d = new GetSceneAllData { getSceneAllInfo = sceneGetAllInfo };
|
System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
|
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Scene/GetAllInfo_Actions 启动" + System.DateTime.Now.ToString());
|
try{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 807 } };
|
mainGateway.Send(("Scene/GetAllInfo"), jObject.ToString());
|
}
|
catch {}
|
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(100);
|
}
|
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Scene/GetAllInfo_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
/// <summary>
|
/// 获取所有场景的所有信息,网关反馈信息
|
/// </summary>
|
public GetSceneAllData getSceneAllData;
|
/// <summary>
|
/// 获取所有场景的所有信息,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class GetSceneAllData:CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 获取所有场景的所有信息
|
/// </summary>
|
public GetSceneAllInfo getSceneAllInfo;
|
}
|
/// <summary>
|
/// 获取所有场景的所有信息
|
/// </summary>
|
public GetSceneAllInfo sceneGetAllInfo;
|
/// <summary>
|
/// 获取所有场景的所有信息
|
/// </summary>
|
[System.Serializable]
|
public class GetSceneAllInfo
|
{
|
/// <summary>
|
///场景总数
|
/// </summary>
|
public int ScenesSum;
|
|
/// <summary>
|
///表示当前发送的是第几个场景信息。ScenesNum从0开始，每发送一个场景信息将自加1，当ScenesNum等于ScenesSum时，表示所有信息发送完毕。
|
/// </summary>
|
public int ScenesNum;
|
|
/// <summary>
|
/// 场景ID
|
/// </summary>
|
public int ScenesId;
|
|
/// <summary>
|
/// 场景是否处于开启状态
|
/// <para>0：场景没有开启</para>
|
///<para>1：场景处于开启状态</para>
|
/// </summary>
|
public int IsOpen;
|
|
/// <summary>
|
/// 场景名称
|
/// </summary>
|
public string ScenesName;
|
|
/// <summary>
|
/// 当前场景的设备数量
|
/// </summary>
|
public int DeviceSum;
|
|
/// <summary>
|
/// 场景列表
|
/// </summary>
|
public List<DeviceListData> DeviceList = new List<DeviceListData>();
|
}
|
/// <summary>
|
/// 场景列表数据
|
/// </summary>
|
[System.Serializable]
|
public class DeviceListData
|
{
|
/// <summary>
|
/// 成员类型
|
///<para>0：设备成员</para>
|
///<para>1：场景成员</para>
|
///<para>2：延时成员</para>
|
/// </summary>
|
public int Type;
|
/// <summary>
|
/// 设备mac地址 ，
|
///<para>当Type=0时存在。</para>
|
/// </summary>
|
public string DeviceAddr;
|
/// <summary>
|
/// 设备端口号
|
///<para>当Type=0时存在。</para>
|
/// </summary>
|
public int Epoint;
|
/// <summary>
|
/// 设备列表
|
/// 当Type=0时存在
|
/// </summary>
|
public List<Safeguard.TaskListInfo> TaskList = new List<Safeguard.TaskListInfo>();
|
/// <summary>
|
/// 场景成员的场景id
|
/// <para>当Type=1时存在</para>
|
/// </summary>
|
public int ElseScenesId;
|
/// <summary>
|
///延时执行时间，单位秒。
|
/// </summary>
|
public int DelayTime;
|
/// <summary>
|
/// 场景动作序号，表示第几个动作
|
/// </summary>
|
public int MemberNumber;
|
}
|
|
#endregion
|
|
#region 只能获取场景信息，没有场景中的设备信息
|
/// <summary>
|
/// 只能获取场景信息，没有场景中的设备信息
|
/// </summary>
|
/// <returns></returns>
|
//static async System.Threading.Tasks.Task<GetOnlySceneAllData> GetSceneInfoAsync()
|
//{
|
//if (ZbGateway.MainGateWay == null)
|
//{
|
// return null;
|
//}
|
//return await System.Threading.Tasks.Task.Run(async () =>
|
//{
|
//var d = new GetOnlySceneAllData { };
|
//Action<string, string> action = (topic, message) =>
|
//{
|
//var gatewayID = topic.Split('/')[0];
|
//var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
//if (topic == gatewayID + "/" + "Error_Respon")
|
//{
|
// var gatewayTemp = new ZbGateway() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), CurrentGateWayId = ZbGateway.MainGateWay.GwId };
|
// var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<ErrorResponData>(jobject["Data"].ToString());
|
|
// if (temp == null)
|
// {
|
// d.errorMessageBase = "网关错误回复，且数据是空";
|
// }
|
// else
|
// {
|
// d.errorResponData = temp;
|
// d.errorMessageBase = ErrorMess(temp.Error);
|
// }
|
//}
|
|
//if (topic == gatewayID + "/" + "Scene/GetInfo_Respon")
|
//{
|
//var scene = new Scene() { DataID = jobject.Value<int>("Data_ID"), GateWayId = ZbGateway.MainGateWay?.CurrentGateWayId };
|
//scene.sceneGetInfo = Newtonsoft.Json.JsonConvert.DeserializeObject<GetSceneInfo>(jobject["Data"].ToString());
|
|
//if (scene.sceneGetInfo == null)
|
//{
|
// d.errorMessageBase = "网关返回的数据为空";
|
//}
|
//else
|
//{
|
//if (ZbGateway.MainGateWay?.SceneList.Count == 0)
|
//{
|
// ZbGateway.MainGateWay.SceneList.Add(scene.sceneGetInfo);
|
//}
|
//else
|
//{
|
// foreach (var a in ZbGateway.MainGateWay.SceneList)
|
// {
|
// a.ScenesList = scene.sceneGetInfo.ScenesList;
|
// }
|
//}
|
//d.getSceneInfo = scene.sceneGetInfo;
|
// }
|
// }
|
//};
|
//ZbGateway.MainGateWay.Actions += action;
|
//System.Console.WriteLine("Scene/GetInfo_Actions 启动" + System.DateTime.Now.ToString());
|
|
//var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 805 } };
|
//ZbGateway.MainGateWay?.Send(("Scene/GetInfo"),System.Text.Encoding.UTF8.GetBytes(jObject.ToString()));
|
|
//var dateTime = DateTime.Now;
|
//while ((DateTime.Now - dateTime).TotalMilliseconds < 1000)
|
//{
|
// await System.Threading.Tasks.Task.Delay(10);
|
// if (d.getSceneInfo != null)
|
// {
|
// break;
|
// }
|
//}
|
//if ((DateTime.Now - dateTime).TotalMilliseconds > 10000)
|
//{
|
// d.errorMessageBase = " 回复超时，请重新操作";
|
//}
|
//ZbGateway.MainGateWay.Actions -= action;
|
//System.Console.WriteLine("Scene/GetInfo_Actions 退出" + System.DateTime.Now.ToString());
|
|
//return d;
|
//});
|
// }
|
|
/// <summary>
|
///获取场景信息,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
class GetOnlySceneAllData:CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 获取场景信息
|
/// </summary>
|
public GetSceneInfo getSceneInfo;
|
}
|
|
/// <summary>
|
/// 获取场景信息
|
/// </summary>
|
public GetSceneInfo sceneGetInfo;
|
/// <summary>
|
/// 获取场景信息
|
/// </summary>
|
[System.Serializable]
|
public class GetSceneInfo
|
{
|
/// <summary>
|
///场景总数
|
/// </summary>
|
public int ScenesSum;
|
|
/// <summary>
|
/// 场景列表
|
/// </summary>
|
public List<ScenesListInfo> ScenesList = new List<ScenesListInfo>();
|
}
|
|
/// <summary>
|
/// 场景列表中的具体信息
|
/// </summary>
|
[System.Serializable]
|
public class ScenesListInfo:CommonDevice
|
{
|
/// <summary>
|
/// 场景ID
|
/// </summary>
|
public int ScenesId;
|
|
/// <summary>
|
/// 名称
|
/// </summary>
|
public string ScenesName;
|
|
/// <summary>
|
/// 是否处于开启状态
|
///0：场景没有被开启
|
///1：场景处于开启状态
|
/// </summary>
|
public int IsOpen;
|
}
|
#endregion
|
|
#region 获取当前场景中的设备列表信息
|
///<summary >
|
///获取当前场景中的设备列表信息
|
/// </summary>
|
public static async System.Threading.Tasks.Task<GetSceneDeviceListAllInfo> GetSceneDeviceListAsync(int scenesId)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
GetSceneDeviceListAllInfo d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new GetSceneDeviceListAllInfo { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new GetSceneDeviceListAllInfo { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new GetSceneDeviceListAllInfo { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Scene/GetDeviceList_Respon")
|
{
|
var sceneGetDeviceListObj = Newtonsoft.Json.JsonConvert.DeserializeObject<GetSceneDeviceListInfo>(jobject["Data"].ToString());
|
|
if (sceneGetDeviceListObj == null)
|
{
|
d = new GetSceneDeviceListAllInfo { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
d = new GetSceneDeviceListAllInfo { getSceneDeviceListInfo = sceneGetDeviceListObj };
|
System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
|
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Scene/GetDeviceList_Actions 启动" + System.DateTime.Now.ToString());
|
try
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 806 } };
|
var data = new JObject { { "ScenesId", scenesId } };
|
jObject.Add("Data", data);
|
mainGateway.Send(("Scene/GetDeviceList"),System.Text.Encoding.UTF8.GetBytes(jObject.ToString()));
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
|
await System.Threading.Tasks.Task.Delay(10);
|
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new GetSceneDeviceListAllInfo { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Scene/GetDeviceList_Actions退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
///获取场景的设备列表信息,网关反馈信息
|
/// </summary>
|
public GetSceneDeviceListAllInfo getSceneDeviceListAllInfo;
|
/// <summary>
|
///获取场景的设备列表信息,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class GetSceneDeviceListAllInfo : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 获取场景的设备列表信息
|
/// </summary>
|
public GetSceneDeviceListInfo getSceneDeviceListInfo;
|
}
|
|
/// <summary>
|
/// 获取场景的设备列表信息
|
/// </summary>
|
public GetSceneDeviceListInfo sceneGetDeviceListObj;
|
/// <summary>
|
/// 获取场景的设备列表信息
|
/// </summary>
|
[System.Serializable]
|
public class GetSceneDeviceListInfo
|
{
|
/// <summary>
|
///场景ID
|
/// </summary>
|
public int ScenesId;
|
|
/// <summary>
|
///场景是否处于开启状态
|
///0：场景没有开启
|
///1：场景处于开启状态
|
/// </summary>
|
public int IsOpen;
|
|
/// <summary>
|
///场景的设备数量
|
/// </summary>
|
public int DeviceSum;
|
|
/// <summary>
|
/// 设备列表
|
/// </summary>
|
public List<DeviceListData> DeviceList = new List<DeviceListData>();
|
|
}
|
#endregion
|
|
#region 场景中添加的成员
|
/// <summary>
|
/// 添加目标到网关到场景中。
|
/// <para>返回结果Result 1 加入成功</para>
|
/// <para>返回结果Result 0 加入失败</para>
|
/// </summary>
|
/// <returns>The scene member.</returns>
|
/// <param name="scenesId">Scenes identifier.</param>
|
public static async System.Threading.Tasks.Task<AddSceneMemberResponseAllData> AddSceneMemberAsync(AddSceneMemberData sceneMemberData)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
AddSceneMemberResponseAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new AddSceneMemberResponseAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new AddSceneMemberResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new AddSceneMemberResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Scene/AddMember_Respon")
|
{
|
var addSceneMemberData = Newtonsoft.Json.JsonConvert.DeserializeObject<AddSceneMemberResponseData>(jobject["Data"].ToString());
|
|
if (addSceneMemberData == null)
|
{
|
d = new AddSceneMemberResponseAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
d = new AddSceneMemberResponseAllData { addSceneMemberResponseData = addSceneMemberData };
|
System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
|
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Scene/AddMember_Actions 启动" + System.DateTime.Now.ToString());
|
try{
|
if (sceneMemberData != null)
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 820 } };
|
var data = new JObject { };
|
if (sceneMemberData.Type == 0)
|
{
|
var taskList = new JArray { };
|
foreach (var taskInfo in sceneMemberData.TaskList)
|
{
|
var tInfo = new JObject{
|
{ "TaskType", taskInfo.TaskType},
|
{ "Data1", taskInfo.Data1},
|
{ "Data2",taskInfo.Data2}
|
};
|
taskList.Add(tInfo);
|
}
|
|
data = new JObject {
|
{ "ScenesId",sceneMemberData.ScenesId},
|
{ "Type", sceneMemberData.Type} ,
|
{ "DeviceAddr",sceneMemberData.DeviceAddr} ,
|
{ "Epoint", sceneMemberData.Epoint} ,
|
{ "TaskList", taskList },
|
{ "DelayTime", sceneMemberData.DelayTime} ,
|
{ "MemberNumber",sceneMemberData.MemberNumber},
|
};
|
}
|
else if (sceneMemberData.Type == 1)
|
{
|
data = new JObject {
|
{ "ScenesId",sceneMemberData.ScenesId},
|
{ "Type", sceneMemberData.Type} ,
|
{ "ElseScenesId", sceneMemberData.ElseScenesId },
|
{ "DelayTime", sceneMemberData.DelayTime} ,
|
{ "MemberNumber",sceneMemberData.MemberNumber},
|
};
|
}
|
else if (sceneMemberData.Type == 2)
|
{
|
data = new JObject {
|
{ "Type", sceneMemberData.Type} ,
|
{ "ScenesId",sceneMemberData.ScenesId},
|
{ "DelayTime", sceneMemberData.DelayTime} ,
|
{ "MemberNumber",sceneMemberData.MemberNumber},
|
};
|
}
|
|
jObject.Add("Data", data);
|
mainGateway.Send(("Scene/AddMember"),System.Text.Encoding.UTF8.GetBytes(jObject.ToString()));
|
}
|
}
|
catch{}
|
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new AddSceneMemberResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Scene/AddMember_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
|
/// <summary>
|
/// 获取场景中添加的成员,网关反馈信息
|
/// </summary>
|
public AddSceneMemberResponseAllData addSceneMemberResponseAllData;
|
/// <summary>
|
/// 获取场景中添加的成员,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class AddSceneMemberResponseAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 获取场景中添加的成员
|
/// </summary>
|
public AddSceneMemberResponseData addSceneMemberResponseData;
|
}
|
|
/// <summary>
|
/// 获取场景中添加的成员
|
/// </summary>
|
public AddSceneMemberResponseData addSceneMemberData;
|
/// <summary>
|
/// 获取添加成员到场景或更新场景
|
/// </summary>
|
[System.Serializable]
|
public class AddSceneMemberResponseData
|
{
|
/// <summary>
|
/// 1 加入成功
|
/// <para>0 加入失败</para>
|
/// </summary>
|
public int Result;
|
|
/// <summary>
|
/// 场景ID
|
/// </summary>
|
public int ScenesId;
|
|
/// <summary>
|
/// 延时执行时间，单位秒
|
/// </summary>
|
public int DelayTime;
|
|
/// <summary>
|
/// 0：加入成员为节点设备
|
/// <para>1：加入成员为其他场景</para>
|
/// </summary>
|
public int Type;
|
|
/// <summary>
|
/// 其他场景id
|
/// <para>当Type=1时，该字段存在</para>
|
/// </summary>
|
public int ElseScenesId;
|
|
/// <summary>
|
/// 设备mac地址
|
/// </summary>
|
public string DeviceAddr;
|
|
/// <summary>
|
/// 设备端口号
|
/// </summary>
|
public int Epoint;
|
|
/// <summary>
|
/// 设备名称 ，当Type=0时，该字段存在
|
/// </summary>
|
public string DeviceName;
|
}
|
|
/// <summary>
|
/// 添加成员到场景或更新场景
|
/// </summary>
|
public AddSceneMemberData setAddMember;
|
/// <summary>
|
/// 添加成员到场景或更新场景
|
/// </summary>
|
[System.Serializable]
|
public class AddSceneMemberData
|
{
|
/// <summary>
|
/// 场景ID
|
/// <para>0：新增场景，网关将自动为该场景分配一个未被使用的场景id。</para>
|
/// <para>其他：设备要加入的场景。如果场景id不存在，则网关新建一个场景并用该字段值作为场景id。</para>
|
/// </summary>
|
public int ScenesId;
|
|
/// <summary>
|
/// 添加成员类型
|
///<para>0：节点设备</para>
|
///<para>1：其他场景</para>
|
///<para>2：延时类型</para>
|
/// </summary>
|
public int Type;
|
|
/// <summary>
|
/// 延时执行时间，单位秒
|
/// 当Type=2时存在
|
/// </summary>
|
public int DelayTime;
|
/// <summary>
|
/// 延时执行序号，表示延时索引
|
///当Type=2时存在
|
/// </summary>
|
public int MemberNumber;
|
|
/// <summary>
|
/// 作为成员的其他场景id。
|
///<para>当Type=1时，该字段才存在。</para>
|
/// </summary>
|
public int ElseScenesId;
|
|
/// <summary>
|
/// 设备mac地址
|
/// <para>Type=0时存在</para>
|
/// </summary>
|
public string DeviceAddr;
|
/// <summary>
|
/// 设备端口号
|
/// <para>Type=0时存在</para>
|
/// </summary>
|
public int Epoint;
|
/// <summary>
|
/// 设备列表
|
/// <para>Type=0时存在</para>
|
/// </summary>
|
public List<Safeguard.TaskListInfo> TaskList = new List<Safeguard.TaskListInfo>();
|
}
|
#endregion
|
|
#region 从网关的场景中移除设备
|
/// <summary>
|
/// 从网关的场景中移除设备.
|
/// <para>返回结果Result/RemoveResult 1：移除失败，成员不存在场景中</para>
|
/// <para>返回结果Result/RemoveResult 0：移除成功败</para>
|
/// </summary>
|
/// <returns>The scene member.</returns>
|
/// <param name="scenesId">Scenes identifier.</param>
|
public static async System.Threading.Tasks.Task<RemoveSceneMemberResponseAllData> RemoveSceneMemberAsync(SceneRemoveMemberData sceneRemoveMemberData)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
RemoveSceneMemberResponseAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new RemoveSceneMemberResponseAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new RemoveSceneMemberResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new RemoveSceneMemberResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
if (topic == gatewayID + "/" + "Scene/RemoveMember_Respon")
|
{
|
var removeSceneMemberResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<RemoveSceneMemberResponseData>(jobject["Data"].ToString());
|
|
if (removeSceneMemberResponseData == null)
|
{
|
d = new RemoveSceneMemberResponseAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
d = new RemoveSceneMemberResponseAllData { removeSceneMemberResponseData = removeSceneMemberResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
|
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Scene/RemoveMember_Actions 启动" + "_" + mainGateway.GwId + System.DateTime.Now.ToString());
|
|
try{
|
if (sceneRemoveMemberData != null)
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 802 } };
|
var deviceList = new JArray { };
|
foreach (var deviceInfo in sceneRemoveMemberData.DeviceList)
|
{
|
if (deviceInfo.Type == 0)
|
{
|
var dInfo = new JObject{
|
{ "Type", deviceInfo.Type},
|
{ "DeviceAddr",deviceInfo.DeviceAddr},
|
{ "Epoint",deviceInfo.Epoint},
|
{ "DelayTime", deviceInfo.DelayTime} ,
|
{ "MemberNumber",deviceInfo.MemberNumber},
|
};
|
deviceList.Add(dInfo);
|
}
|
else if (deviceInfo.Type == 1)
|
{
|
var dInfo = new JObject{
|
{ "Type", deviceInfo.Type},
|
{ "ElseScenesId",deviceInfo.ElseScenesId},
|
{ "DelayTime", deviceInfo.DelayTime} ,
|
{ "MemberNumber",deviceInfo.MemberNumber},
|
};
|
deviceList.Add(dInfo);
|
}
|
else if (deviceInfo.Type == 2)
|
{
|
var dInfo = new JObject{
|
{ "Type", deviceInfo.Type},
|
{ "DelayTime", deviceInfo.DelayTime} ,
|
{ "MemberNumber",deviceInfo.MemberNumber},
|
};
|
deviceList.Add(dInfo);
|
}
|
|
}
|
|
var data = new JObject {
|
{"ScenesId",sceneRemoveMemberData.ScenesId},
|
{ "DeviceList", deviceList }
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send(("Scene/RemoveMember"),System.Text.Encoding.UTF8.GetBytes(jObject.ToString()));
|
|
}
|
}
|
catch{}
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new RemoveSceneMemberResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Scene/RemoveMember_Actions 退出" + "_" + mainGateway.GwId + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
/// <summary>
|
/// 从场景中移除成员
|
/// </summary>
|
public SceneRemoveMemberData sceneRemoveMemberData;
|
/// <summary>
|
/// 从场景中移除成员
|
/// </summary>
|
[System.Serializable]
|
public class SceneRemoveMemberData
|
{
|
/// <summary>
|
/// 场景ID
|
/// </summary>
|
public int ScenesId;
|
|
/// <summary>
|
/// 设备列表 ，要移除的设备
|
/// </summary>
|
public List<RemoveSceneDeviceListInfo> DeviceList = new List<RemoveSceneDeviceListInfo>();
|
}
|
|
/// <summary>
|
/// 移除场景成员信息
|
/// </summary>
|
[System.Serializable]
|
public class RemoveSceneDeviceListInfo
|
{
|
/// <summary>
|
/// 移除成员类型
|
///<para >0：设备成员</para>
|
///<para >1：场景成员</para>
|
///<para >2：延时类型</para>
|
/// </summary>
|
public int Type;
|
|
/// <summary>
|
/// 设备mac地址
|
/// <para>当Type=0时存在</para>
|
/// </summary>
|
public string DeviceAddr;
|
|
/// <summary>
|
/// 设备端口号
|
/// 当Type=0时存在
|
/// </summary>
|
public int Epoint;
|
|
/// <summary>
|
/// 场景成员id
|
/// 当Type=1时存在
|
/// </summary>
|
public int ElseScenesId;
|
|
/// <summary>
|
/// 延时执行时间，单位秒
|
/// 当Type=2时存在
|
/// </summary>
|
public int DelayTime;
|
/// <summary>
|
/// 延时执行序号，表示延时索引
|
///当Type=2时存在
|
/// </summary>
|
public int MemberNumber;
|
}
|
|
/// <summary>
|
/// 移除场景成员信息反馈,网关反馈信息
|
/// </summary>
|
public RemoveSceneMemberResponseAllData removeSceneMemberResponseAllData;
|
/// <summary>
|
/// 移除场景成员信息反馈,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class RemoveSceneMemberResponseAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 移除场景成员信息反馈
|
/// </summary>
|
public RemoveSceneMemberResponseData removeSceneMemberResponseData;
|
}
|
|
/// <summary>
|
/// 移除场景成员信息反馈
|
/// </summary>
|
public RemoveSceneMemberResponseData removeSceneMemberResponseData;
|
/// <summary>
|
/// 移除场景成员信息反馈
|
/// </summary>
|
[System.Serializable]
|
public class RemoveSceneMemberResponseData
|
{
|
/// <summary>
|
/// 0 移除成功
|
///<para>1 场景ID不存在</para>
|
/// </summary>
|
public int Result = 2;
|
|
/// <summary>
|
/// 场景ID
|
/// </summary>
|
public int ScenesId;
|
/// <summary>
|
/// 移除设备列表 ，Result=0时存在。
|
/// </summary>
|
public List<RemoveSceneDeviceListResponseInfo> RemoveList = new List<RemoveSceneDeviceListResponseInfo>();
|
}
|
|
/// <summary>
|
/// 移除场景成员信息
|
/// </summary>
|
[System.Serializable]
|
public class RemoveSceneDeviceListResponseInfo
|
{
|
/// <summary>
|
/// 0：移除成功
|
///<para >1：移除失败，成员不存在场景中</para>
|
/// </summary>
|
public int RemoveResult = 999;
|
/// <summary>
|
/// 移除成员类型
|
///<para >0：设备成员</para>
|
///<para >1：其他场景</para>
|
/// </summary>
|
public int Type;
|
|
/// <summary>
|
/// 设备mac地址
|
/// <para>当Type=0时存在</para>
|
/// </summary>
|
public string DeviceAddr;
|
|
/// <summary>
|
/// 设备端口号 当Type=0时存在
|
/// </summary>
|
public int Epoint;
|
|
/// <summary>
|
/// 场景成员id，当Type=1时存在
|
/// </summary>
|
public int ElseScenesId;
|
}
|
#endregion
|
|
#region 修改场景名称
|
///<summary >
|
/// 修改场景名称.
|
/// </summary>
|
public static async System.Threading.Tasks.Task<SceneRenameResponseAllData> RenameSceneAsync(int scenesId, string scenesName)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
SceneRenameResponseAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new SceneRenameResponseAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new SceneRenameResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new SceneRenameResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Scene/Rename_Respon")
|
{
|
var sceneRenameResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<SceneRenameResponseData>(jobject["Data"].ToString());
|
|
if (sceneRenameResponseData == null)
|
{
|
d = new SceneRenameResponseAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
d = new SceneRenameResponseAllData { sceneRenameResponseData = sceneRenameResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
|
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Scene/Rename_Actions 启动" + "_" + mainGateway.GwId + System.DateTime.Now.ToString());
|
try{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 804 } };
|
var data = new JObject { { "ScenesId", scenesId }, { "ScenesName", scenesName } };
|
jObject.Add("Data", data);
|
mainGateway.Send(("Scene/Rename"),System.Text.Encoding.UTF8.GetBytes(jObject.ToString()));
|
}
|
catch {}
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new SceneRenameResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Scene/Rename_Actions 退出" + "_" + mainGateway.GwId + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 修改场景名称,网关反馈信息
|
/// </summary>
|
public SceneRenameResponseAllData sceneRenameResponseAllData;
|
///<summary >
|
/// 修改场景名称
|
/// </summary>
|
[System.Serializable]
|
public class SceneRenameResponseAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 修改场景名称
|
/// </summary>
|
public SceneRenameResponseData sceneRenameResponseData;
|
}
|
|
///<summary >
|
/// 修改场景名称
|
/// </summary>
|
public SceneRenameResponseData sceneRenameResponseData;
|
///<summary >
|
/// 修改场景名称
|
/// </summary>
|
[System.Serializable]
|
public class SceneRenameResponseData
|
{
|
/// <summary>
|
///结果
|
///<para>0 修改失败</para>
|
///<para>1 修改成功</para>
|
///<para>2 没有在该场景</para>
|
/// </summary>
|
public int Result=999;
|
|
/// <summary>
|
/// 场景ID
|
/// </summary>
|
public int ScenesId;
|
|
/// <summary>
|
/// 场景名称
|
/// </summary>
|
public string ScenesName;
|
}
|
#endregion
|
|
#region 删除场景
|
///<summary >
|
/// 删除场景
|
/// <para>返回结果 0 移除失败</para>
|
///<para>返回结果 1 移除成功</para>
|
///<para>返回结果 2 没有该场景</para>
|
/// </summary>
|
public static async System.Threading.Tasks.Task<RemoveSceneAllData> DeleteSceneAsync(int scenesId)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
RemoveSceneAllData d =null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new RemoveSceneAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new RemoveSceneAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new RemoveSceneAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Scene/Remove_Respon")
|
{
|
var removeSceneData = Newtonsoft.Json.JsonConvert.DeserializeObject<RemoveSceneData>(jobject["Data"].ToString());
|
if (removeSceneData == null)
|
{
|
d = new RemoveSceneAllData { errorMessageBase = "网关返回的数据为空" };
|
return;
|
}
|
else
|
{
|
d = new RemoveSceneAllData { removeSceneData = removeSceneData };
|
System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
|
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Scene/Remove_Actions 启动" + "_" + mainGateway.GwId + System.DateTime.Now.ToString());
|
try{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 803 } };
|
var data = new JObject { { "ScenesId", scenesId } };
|
jObject.Add("Data", data);
|
mainGateway.Send(("Scene/Remove"),jObject.ToString());
|
}
|
catch {}
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new RemoveSceneAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Scene/Remove_Actions 退出" + "_" + mainGateway.GwId + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 移除场景,网关反馈信息
|
/// </summary>
|
public RemoveSceneAllData removeSceneAllData;
|
/// <summary>
|
/// 移除场景,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class RemoveSceneAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 移除场景
|
/// </summary>
|
public RemoveSceneData removeSceneData;
|
}
|
|
/// <summary>
|
/// 移除场景数据
|
/// </summary>
|
public RemoveSceneData removeSceneData;
|
/// <summary>
|
/// 移除场景数据
|
/// </summary>
|
[System.Serializable]
|
public class RemoveSceneData
|
{
|
/// <summary>
|
///0 移除失败
|
///<para>1 移除成功</para>
|
///<para>2 没有该场景</para>
|
/// </summary>
|
public int Result=999;
|
|
/// <summary>
|
/// 场景ID
|
/// </summary>
|
public int ScenesId;
|
}
|
#endregion
|
|
#region 调用场景
|
///<summary >
|
///调用场景
|
/// <para>DelayTime:延时执行时间，单位秒</para>
|
/// </summary>
|
public static async System.Threading.Tasks.Task<SceneOpenAllData> ControlSceneAsync(int ScenesId,int delayTime)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
SceneOpenAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new SceneOpenAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new SceneOpenAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new SceneOpenAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Scene/Open_Respon")
|
{
|
var sceneOpen = Newtonsoft.Json.JsonConvert.DeserializeObject<SceneOpenData>(jobject["Data"].ToString());
|
if (sceneOpen == null)
|
{
|
d = new SceneOpenAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
d = new SceneOpenAllData { sceneOpenData = sceneOpen };
|
System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
|
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Scene/Open_Actions 启动" + "_" + mainGateway.GwId + System.DateTime.Now.ToString());
|
try{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 821 } };
|
var data = new JObject { { "ScenesId", ScenesId }, { "DelayTime", delayTime } };
|
jObject.Add("Data", data);
|
mainGateway.Send(("Scene/Open"),System.Text.Encoding.UTF8.GetBytes(jObject.ToString()));
|
}
|
catch {}
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime )
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new SceneOpenAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Scene/Open_Actions退出" + "_" + mainGateway.GwId + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 调用场景,网关反馈信息
|
/// <para>返回Result 0：调用失败</para>
|
///<para>Result 1：调用成功<para>
|
/// </summary>
|
public SceneOpenAllData sceneOpenAllData;
|
/// <summary>
|
/// 调用场景,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class SceneOpenAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 调用场景
|
/// </summary>
|
public SceneOpenData sceneOpenData;
|
}
|
|
///<summary >
|
/// 调用场景
|
/// </summary>
|
public SceneOpenData sceneOpen;
|
///<summary >
|
/// 调用场景
|
/// </summary>
|
[System.Serializable]
|
public class SceneOpenData
|
{
|
/// <summary>
|
/// 场景ID
|
/// </summary>
|
public int ScenesId;
|
|
/// <summary>
|
///结果
|
///<para>Result 0：调用失败</para>
|
///<para>Result 1：调用成功<para>
|
/// </summary>
|
public int Result=999;
|
|
/// <summary>
|
/// 延时时间
|
/// </summary>
|
public int DelayTime;
|
|
}
|
#endregion
|
|
#region 查看正在延时的场景
|
/// <summary>
|
/// 查看正在延时的场景.
|
/// </summary>
|
public static async System.Threading.Tasks.Task<CatDelaySceneResponseAllData> CatDelaySceneAsync()
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
CatDelaySceneResponseAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new CatDelaySceneResponseAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new CatDelaySceneResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new CatDelaySceneResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
if (topic == gatewayID + "/" + "Scene/CatDelayScene_Respon")
|
{
|
var catDelaySceneResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<CatDelaySceneResponseData>(jobject["Data"].ToString());
|
|
if (catDelaySceneResponseData == null)
|
{
|
d = new CatDelaySceneResponseAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
d = new CatDelaySceneResponseAllData { catDelaySceneResponseData = catDelaySceneResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Scene/CatDelayScene_Actions 启动" + "_" + mainGateway.GwId + System.DateTime.Now.ToString());
|
try
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 811 } };
|
mainGateway.Send(("Scene/CatDelayScene"),System.Text.Encoding.UTF8.GetBytes(jObject.ToString()));
|
}catch {}
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new CatDelaySceneResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Scene/CatDelayScene_Actions 退出" + "_" + mainGateway.GwId + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 查看正在延时的场景信息信息反馈,网关反馈信息
|
/// </summary>
|
public CatDelaySceneResponseAllData catDelaySceneResponseAllData;
|
/// <summary>
|
/// 查看正在延时的场景信息反馈,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class CatDelaySceneResponseAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 查看正在延时的场景信息信息反馈
|
/// </summary>
|
public CatDelaySceneResponseData catDelaySceneResponseData;
|
}
|
|
/// <summary>
|
/// 查看正在延时的场景信息反馈
|
/// </summary>
|
public CatDelaySceneResponseData catDelaySceneResponseData;
|
/// <summary>
|
/// 查看正在延时的场景信息反馈
|
/// </summary>
|
[System.Serializable]
|
public class CatDelaySceneResponseData
|
{
|
/// <summary>
|
/// 正在延时执行的场景
|
/// </summary>
|
public List<DelayScenesListResponseInfo> DelayScenesList = new List<DelayScenesListResponseInfo>();
|
}
|
|
/// <summary>
|
/// 正在延时执行的场景信息
|
/// </summary>
|
[System.Serializable]
|
public class DelayScenesListResponseInfo
|
{
|
/// <summary>
|
/// 场景ID
|
/// </summary>
|
public int ScenesId ;
|
/// <summary>
|
/// 延时时间
|
/// </summary>
|
public int DelayTime;
|
|
/// <summary>
|
/// 剩余触发时间，单位秒
|
/// </summary>
|
public int RemainTime;
|
}
|
#endregion
|
|
///<summary >
|
/// 场景被破坏反馈
|
/// </summary>
|
public SceneBreak sceneBreak;
|
///<summary >
|
/// 场景被破坏反馈
|
/// </summary>
|
[System.Serializable]
|
public class SceneBreak
|
{
|
/// <summary>
|
/// 场景ID
|
/// </summary>
|
public int ScenesId;
|
|
}
|
|
///<summary >
|
/// 场景动作被执行通知
|
/// </summary>
|
public SceneExecRespon sceneExecRespon;
|
///<summary >
|
/// 场景动作被执行通知
|
/// </summary>
|
[System.Serializable]
|
public class SceneExecRespon
|
{
|
/// <summary>
|
/// 场景ID
|
/// </summary>
|
public int ScenesId;
|
|
}
|
}
|
}
|
