using System;
using System.Collections.Generic;
using System.Text;
using Newtonsoft.Json.Linq;

namespace ZigBee.Device
{
    [System.Serializable]
    public class CommonDevice
    {
        #region 需要保存的变量

        /// <summary>
        /// 是否是自定义图片
        /// </summary>
        public bool IsCustomizeImage = false;
        /// <summary>
        /// 设备图片
        /// </summary>
        public string IconPath = string.Empty;
        /// <summary>
        /// 设备图片--在线或者选中状态
        /// </summary>
        /// <value>The online icon path.</value>
        [Newtonsoft.Json.JsonIgnore]
        public string OnlineIconPath
        {
            get
            {
                if (string.IsNullOrEmpty(IconPath))
                {
                    return string.Empty;
                }
                var pathArr = IconPath.Split('.');
                if (pathArr == null || string.IsNullOrEmpty(pathArr[0]))
                {
                    return string.Empty;
                }
                return $"{pathArr[0]}Selected.png";
            }
        }
        /// <summary>
        /// 当前网关的ID
        /// </summary>
        public string CurrentGateWayId;
        /// <summary>
        /// 当前设备类型
        /// </summary>
        [Newtonsoft.Json.JsonIgnore]
        public DeviceType Type = DeviceType.UnKown;
        /// <summary>
        /// 设备的功能类型(此类型目前只针对继电器回路有效,默认未指定)
        /// </summary>
        public DeviceFunctionType DfunctionType = DeviceFunctionType.A未定义;
        /// <summary>
        /// MAC地址
        /// </summary>
        public string DeviceAddr;
        /// <summary>
        /// 设备端口号
        /// </summary>
        public int DeviceEpoint;
        /// <summary>
        /// 实际的设备id
        /// <para>258:color dimmable light,调关灯 </para>
        /// <para>10:Door lock,门锁</para>
        /// <para>514:Window covering device,窗帘</para>
        /// <para>515:Window covering controller，窗帘控制器</para>
        /// <para>769:Thermostat,恒温面板/空调</para>
        /// <para>770:Temperature Sensor,温度传感器</para>
        /// <para>775:Temperature Sensor,湿度传感器</para>
        /// <para>262:Light sensor,光照传感器</para>
        /// <para>1026:sensor,传感器，具体类型的传感器DeviceType来区分</para>
        /// </summary>
        public int DeviceID;
        /// <summary>
        /// <para>2020.09.21追加:为了对应第三方设备,以及之后的多设备ID问题,追加的变量</para>
        /// <para>这是个特殊的,并且不保存在文件当中的ID, DeviceType由此值映射出来</para>
        /// <para>当设备是河东设备时,它与DeviceID相等</para>
        /// <para>当是真正的第三方设备时,它有可能与DeviceID不相等</para>
        /// <para>比如：2和256都是继电器,那么【DeviceID为2 或者 DeviceID为256】 而 【ExDeviceID固定为2】,【DeviceType为OnOffOutput】</para>
        /// <para>通俗来说：DeviceID是实际正确的ID,而【ExDeviceID是一种所属概念的ID】</para>
        /// </summary>
        [Newtonsoft.Json.JsonIgnore]
        public int ExDeviceID;
        /// <summary>
        /// 该字段主要针对IAS安防设备设立。所有IAS安防设备共用一个DeviceID为1026。所以要区分子设备类型，需要该字段。
        /// 瞬间数据上报的传感器 (MomentStatus=1    TriggerZoneStatus>=1＜报警＞)
        /// <para>13:Motion sensor (运动传感器）</para>
        /// <para>40 Fire sensor 烟雾传感器</para>
        /// <para>42 Water sensor 水侵传感器</para>
        /// <para>43 Carbon Monoxide (CO) 燃气传感器</para>
        /// <para>44 Personal emergency device 紧急按钮</para>
        /// <para>277 Key fob 钥匙扣</para>
        /// <para>持续数据上报(MomentStatus=0   TriggerZoneStatus>=1＜报警＞  TriggerZoneStatus=0＜取消报警＞)</para>
        /// <para>21: Door/Window 门窗传感器（有21和22，这里没有写错）</para>
        /// <para>22:Door/Window 门窗传感器（有21和22，这里没有写错</para>
        /// </summary>
        public int IasDeviceType;
        /// <summary>
        /// 设备名称,以设备的MAC命名
        /// </summary>
        public string DeviceName = "UnKown";
        /// <summary>
        /// 设备端点名称，以设备端点名称命名
        /// </summary>
        public string DeviceEpointName = "UnKown";
        /// <summary>
        /// 用于判断设备的zigbee协议版本。
        ///<para>49246：ZLL1.0标准设备。</para>
        ///<para>260： ZHA1.2标准设备、 Z3.0标准设备。</para>
        ///<para>41440：ZGP3.0标准设备。</para>
        ///<para>265：ZSE1.4标准设备。</para>
        /// </summary>
        [Newtonsoft.Json.JsonIgnore]
        public int Profile;
        /// <summary>
        /// 0：设备不在线
        /// <para>1：设备在线</para>
        /// </summary>
        public int IsOnline;
        /// <summary>
        /// 1：路由设备
        /// <para>2：终端设备，电池设备</para>
        /// </summary>
        public int ZigbeeType;
        /// <summary>
        /// 固件版本
        /// </summary>
        public int ImgVersion;
        /// <summary>
        /// 硬件版本
        /// </summary>
        public int HwVersion;
        /// <summary>
        /// 当前镜像类型id
        /// </summary>
        public int ImgTypeId;
        /// <summary>
        /// 驱动代码。为0时，表示zigbee协调器设备。其他值表示为虚拟驱动设备
        /// </summary>
        public int DriveCode;
        /// <summary>
        /// 生产商名字
        /// </summary>
        public string ManufacturerName = string.Empty;
        /// <summary>
        /// 模块ID（这个东西也叫【型号码】）
        /// </summary>
        public string ModelIdentifier = string.Empty;
        /// <summary>
        /// 生产日期
        /// </summary>
        public string ProductionDate = string.Empty;
        /// <summary>
        /// 电源
        /// </summary>
        public int PowerSource = -1;
        /// <summary>
        /// 序列号
        /// </summary>
        public string SerialNumber = string.Empty;
        /// <summary>
        /// 输入簇列表
        /// </summary>
        public List<InClusterObj> InClusterList = new List<InClusterObj>();
        /// <summary>
        /// 输出簇列表
        /// </summary>
        public List<OutClusterObj> OutClusterList = new List<OutClusterObj>();
        /// <summary>
        /// 用于记录设备最新上报的属性状态信息
        /// </summary>
        public List<AttributeStatusObj> AttributeStatus = new List<AttributeStatusObj>();

        [Newtonsoft.Json.JsonIgnore]
        public DateTime LastDateTime = DateTime.MinValue;
        /// <summary>
        /// 是否已经读取了设备状态(此属性是给主页使用的)
        /// </summary>
        [Newtonsoft.Json.JsonIgnore]
        public bool HadReadDeviceStatu = false;

        /// <summary>
        /// 是否是低电量(这个变量目前是给传感器用的)
        /// </summary>
        [Newtonsoft.Json.JsonIgnore]
        public bool IsBatteryDown = false;

        /// <summary>
        /// 等待从网关接收数据的时间
        /// </summary>
        /// <value>The wait receive data time.</value>
        [Newtonsoft.Json.JsonIgnore]
        public virtual int WaitReceiveDataTime
        {
            get
            {
                if (Device.ZbGateway.RemoteMqttClient != null && Device.ZbGateway.RemoteMqttClient.IsConnected)
                {
                    return 10000;
                }
                else
                {
                    return 3000;
                }
            }
        }

        /// <summary>
        /// 通过设备调用网关
        /// </summary>
        [Newtonsoft.Json.JsonIgnore]
        public ZbGateway Gateway
        {
            get
            {
                if (string.IsNullOrEmpty(CurrentGateWayId))
                {
                    return null;
                }
                var gateWay = ZbGateway.GateWayList.Find(obj => (obj != null) && (obj.GwId == CurrentGateWayId));
                if (gateWay == null)
                {
                    gateWay = new ZbGateway { IsVirtual = true, };
                    gateWay.GwId = CurrentGateWayId;
                    gateWay.HomeId = Shared.Common.Config.Instance.HomeId;
                    ZbGateway.GateWayList.Add(gateWay);
                }

                return gateWay;
            }
        }

        /// <summary>
        /// 保存设备数据的文件名
        /// </summary>
        [Newtonsoft.Json.JsonIgnore]
        public virtual string FilePath
        {
            get
            {
                //2020.09.21 对应第三方设备可以入网,设备文件名字,去掉 deviceType
                return "Device_" + DeviceAddr + "_" + DeviceEpoint.ToString().PadLeft(2, '0');
            }
        }

        #endregion

        #region 设备保存及生成

        /// <summary>
        /// 由设备字符串比特恢复设备对象
        /// </summary>
        /// <param name="intDeviceType">设备DeviceType的整型值</param>
        /// <param name="strDeviceByte">设备Json文件转为比特后再转为的字符串</param>
        /// <returns></returns>
        public static CommonDevice CommonDeviceByByteString(int intDeviceType, string strDeviceByte)
        {
            //这是河东的特殊端点,不需要处理
            if (intDeviceType == 49408)
            {
                return null;
            }

            CommonDevice device = null;
            if (intDeviceType == (int)DeviceType.DimmableLight || intDeviceType == 3)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<DimmableLight>(strDeviceByte);
                device.ExDeviceID = (int)DeviceType.DimmableLight;
            }
            else if (intDeviceType == (int)DeviceType.OnOffOutput || intDeviceType == 256)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<ToggleLight>(strDeviceByte);
                device.ExDeviceID = (int)DeviceType.OnOffOutput;
            }
            else if (intDeviceType == (int)DeviceType.ColorDimmerSwitch)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<ColorDimmerSwitch>(strDeviceByte);
            }
            else if (intDeviceType == (int)DeviceType.LevelControlSwitch)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<LevelControlSwitch>(strDeviceByte);
            }
            else if (intDeviceType == (int)DeviceType.WindowCoveringDevice)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<Rollershade>(strDeviceByte);
            }
            else if (intDeviceType == (int)DeviceType.WindowCoveringController)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<WindowCoveringController>(strDeviceByte);
            }
            else if (intDeviceType == (int)DeviceType.OnOffSwitch)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<Panel>(strDeviceByte);
            }
            else if (intDeviceType == (int)DeviceType.IASZone)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<IASZone>(strDeviceByte);
            }
            else if (intDeviceType == (int)DeviceType.OtaDevice || intDeviceType == (int)DeviceType.OtaPanelDevice)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<OTADevice>(strDeviceByte);
            }
            else if (intDeviceType == (int)DeviceType.AirSwitch)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<AirSwitch>(strDeviceByte);
            }
            else if (intDeviceType == (int)DeviceType.Repeater)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<Repeater>(strDeviceByte);
            }
            else if (intDeviceType == (int)DeviceType.Thermostat)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<AC>(strDeviceByte);
            }
            else if (intDeviceType == (int)DeviceType.Transverter)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<Transverter>(strDeviceByte);
            }
            else if (intDeviceType == (int)DeviceType.DoorLock)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<DoorLock>(strDeviceByte);
            }
            else if (intDeviceType == (int)DeviceType.TemperatureSensor)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<TemperatureSensor>(strDeviceByte);
            }
            else if (intDeviceType == (int)DeviceType.FreshAirHumiditySensor)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<HumiditySensor>(strDeviceByte);
            }
            else if (intDeviceType == (int)DeviceType.FreshAir)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<FreshAir>(strDeviceByte);
            }
            else if (intDeviceType == (int)DeviceType.PMSensor)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<PMSensor>(strDeviceByte);
            }
            else if (intDeviceType == (int)DeviceType.ColorTemperatureLight)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<ColorTemperatureLight>(strDeviceByte);
            }
            else if (intDeviceType == (int)DeviceType.Buzzer)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<Buzzer>(strDeviceByte);
            }
            else if (intDeviceType == (int)DeviceType.ColorDimmableLight)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<ColorDimmableLight>(strDeviceByte);
            }
            else if (intDeviceType == (int)DeviceType.DimmerSwitch)
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<DimmerSwitch>(strDeviceByte);
            }
            else
            {
                device = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice>(strDeviceByte);
            }

            //这是河东的特殊端点,不需要处理
            if (device.DeviceEpoint == 242 && intDeviceType == 97)
            {
                return null;
            }

            if (device.ExDeviceID == 0)
            {
                //赋初始值
                device.ExDeviceID = device.DeviceID;
            }

            //能少存一个变量就少存一个
            device.Type = (DeviceType)device.ExDeviceID;

            return device;
        }

        /// <summary>
        /// 保存设备
        /// </summary>
        public void Save()
        {
            if (Shared.Common.Global.IsExistsByHomeId(FilePath))
            {
                return;
            }
            ReSave();
        }

        /// <summary>
        /// 重新保存设备
        /// </summary>
        public void ReSave()
        {
            if (Shared.Common.Config.Instance.Home.IsShowTemplate == true)
            {
                //展示模板时,不允许保存文件(防止属性上报用的)
                return;
            }
            if (IconPath == string.Empty)
            {
                //保存设备图标(这里会保存一次,下面就不用保存了)
                this.SaveDeviceIcon();
                return;
            }
            Shared.Common.Global.WriteFileByBytesByHomeId(FilePath, System.Text.Encoding.UTF8.GetBytes(Newtonsoft.Json.JsonConvert.SerializeObject(this)));
        }

        /// <summary>
        /// 保存设备图标
        /// </summary>
        private void SaveDeviceIcon()
        {
            if (IconPath == string.Empty)
            {
                //干接点
                if (this.Type == DeviceType.OnOffSwitch)
                {
                    IconPath = "Device/DryContact.png";
                }
                else if (this.Type == DeviceType.ColorDimmableLight)
                {
                    //彩灯
                    IconPath = "Device/ColorLight.png";
                }
                else if (this.Type == DeviceType.DimmableLight)
                {
                    //调光器
                    IconPath = "Device/Light.png";
                }
                else if (this.Type == DeviceType.ColorTemperatureLight)
                {
                    //色温灯
                    IconPath = "Device/ColorLightTemperature.png";
                }
                else if (this.Type == DeviceType.OnOffOutput)
                {
                    //继电器
                    IconPath = "Device/RelayEpoint.png";
                }
                else if (this.Type == DeviceType.Thermostat)
                {
                    //空调 
                    IconPath = "Device/AirConditionerEpoint.png";
                }
                else if (this.Type == DeviceType.FreshAir)
                {
                    //新风 
                    IconPath = "Device/FreshAirEpoint.png";
                }
                else if (this.Type == DeviceType.PMSensor)
                {
                    //PM2.5空气质量传感器 
                    IconPath = "Device/AirQualitySensorEpoint.png";
                }
                else if (this.Type == DeviceType.FreshAirHumiditySensor)
                {
                    //湿度传感器
                    IconPath = "Device/SensorHumidity.png";
                }
                else if (this.Type == DeviceType.TemperatureSensor)
                {
                    if (((TemperatureSensor)this).SensorDiv == 1)
                    {
                        //温度传感器
                        IconPath = "Device/SensorTemperature.png";
                    }
                    else if (((TemperatureSensor)this).SensorDiv == 2)
                    {
                        //湿度传感器
                        IconPath = "Device/SensorHumidity.png";
                    }
                }
                else if (this.Type != DeviceType.UnKown)
                {
                    //其他的图标有点特殊
                    string unSelectPic = string.Empty;
                    string selectPic = string.Empty;
                    Shared.Phone.HdlDeviceCommonLogic.Current.GetDeviceObjectIcon(new List<CommonDevice> { this }, ref unSelectPic, ref selectPic);
                    IconPath = unSelectPic;
                }
                Shared.Common.Global.WriteFileByBytesByHomeId(FilePath, System.Text.Encoding.UTF8.GetBytes(Newtonsoft.Json.JsonConvert.SerializeObject(this)));
            }
        }

        #endregion

        #region 输入输出镞定义

        /// <summary>
        /// 设备最新上报的属性状态信息
        /// </summary>
        [System.Serializable]
        public class AttributeStatusObj
        {
            /// <summary>
            /// 属性簇id
            /// </summary>
            public int ClusterId;
            /// <summary>
            /// 属性id
            /// </summary>
            public int AttributeId;
            /// <summary>
            /// 属性值，这个东西不需要什么高位在后低位在前,它已经是转为了10进制
            /// </summary>
            public int AttributeData;
            /// <summary>
            /// 属性状态最后更新的utc时间戳
            /// </summary>
            public int ReportTime;
        }

        /// <summary>
        /// 输入簇
        /// </summary>
        [System.Serializable]
        public class InClusterObj
        {
            /// <summary>
            /// 设备支持的输入功能
            /// <para>0:Basic,设备支持“基础属性” </para>
            /// <para>3:Identify,设备支持“识别功能”</para>
            /// <para>4:Groups,设备支持“组功能”</para>
            /// <para>5:Scenes,设备支持“场景功能”</para>
            /// <para>6:on/off,设备支持“开关功能”</para>
            /// 开关功能的设备如：调关灯/继电器/窗帘等。。。
            /// <para>8:Level Control,设备支持“亮度调节功能”</para>
            /// 亮度调节功能的设备如：调关灯。。。
            /// <para>257:Door Lock,设备支持“门锁功能”</para>
            /// 门锁功能的设备如：门锁。。。
            ///  <para>258:Window Covering,设备支持“窗帘控制功能”</para>
            /// 窗帘控制功能的设备如：窗帘/开合帘/卷帘。。。
            /// <para>513:Thermostat,设备支持“恒温器功能”</para>
            /// 恒温器功能的设备如：空调。。。
            /// <para>768:Color Control,设备支持“颜色调节功能”</para>
            /// 颜色调节功能的设备如：调光灯。。。
            /// <para>1026:Temperature Measurement,设备支持“温度测量功能”</para>
            /// 温度测量功能的设备如：温度传感器。。。
            /// <para>1029:Relative Humidity Measurement,设备支持“湿度测量功能”</para>
            /// 湿度测量功能的设备如：湿度传感器。。。
            /// <para>1066:Pm2.5  Measurement,设备支持“pm2.5测量功能”</para>
            /// Pm2.5测量功能的设备如：Pm2.5传感器。。。
            /// </summary>
            public int InCluster;
        }

        /// <summary>
        /// 输出簇
        /// </summary>
        [System.Serializable]
        public class OutClusterObj
        {
            /// <summary>
            /// 设备支持的输出功能
            /// <para>0:Basic,设备支持“基础属性” </para>
            /// <para>3:Identify,设备支持“识别功能”</para>
            /// <para>4:Groups,设备支持“组功能”</para>
            /// <para>5:Scenes,设备支持“场景功能”</para>
            /// <para>6:on/off,设备支持“开关功能”</para>
            /// 开关功能的设备如：调关灯/继电器/窗帘等。。。
            /// <para>8:Level Control,设备支持“亮度调节功能”</para>
            /// 亮度调节功能的设备如：调关灯。。。
            /// <para>257:Door Lock,设备支持“门锁功能”</para>
            /// 门锁功能的设备如：门锁。。。
            ///  <para>258:Window Covering,设备支持“窗帘控制功能”</para>
            /// 窗帘控制功能的设备如：窗帘/开合帘/卷帘。。。
            /// <para>513:Thermostat,设备支持“恒温器功能”</para>
            /// 恒温器功能的设备如：空调。。。
            /// <para>768:Color Control,设备支持“颜色调节功能”</para>
            /// 颜色调节功能的设备如：调光灯。。。
            /// <para>1026:Temperature Measurement,设备支持“温度测量功能”</para>
            /// 温度测量功能的设备如：温度传感器。。。
            /// <para>1029:Relative Humidity Measurement,设备支持“湿度测量功能”</para>
            /// 湿度测量功能的设备如：湿度传感器。。。
            /// </summary>
            public int OutCluster;
        }

        /// <summary>
        /// 支持的属性数据
        /// </summary>
        [System.Serializable]
        public class AttributeObj
        {
            /// <summary>
            /// 响应的属性ID
            /// </summary>
            public int AttributeId;
            /// <summary>
            /// 属性值的数据类型
            /// </summary>
            public int AttributeType;
        }

        /// <summary>
        /// 设备上报的属性数据
        /// </summary>
        [System.Serializable]
        public class AttributeDataObj
        {
            /// <summary>
            /// 属性id
            /// </summary>
            public int AttributeId;
            /// <summary>
            /// 要报告属性的数据类型
            /// </summary>
            public int AttriButeDataType;
            /// <summary>
            /// AttriButeData占用的字节数
            /// </summary>
            public int AttriButeDataLength;
            /// <summary>
            /// 属性值
            /// </summary>
            public int AttriButeData = 999;
            /// <summary>
            /// 属性数据16进制转字符
            /// </summary>
            public string AttriButeDataHex;
        }

        /// <summary>
        /// Command数组
        /// </summary>
        [System.Serializable]
        public class CommandObj
        {
            /// <summary>
            /// 支持的命令id
            /// </summary>
            public int commandId;
        }

        #endregion

        #region 获取已入网设备信息

        /// <summary>
        /// 网关中的设备信息
        /// </summary>
        [Newtonsoft.Json.JsonIgnore]
        public DeviceInfoData DeviceInfo = null;
        /// <summary>
        /// 网关中的设备信息
        /// </summary>
        [System.Serializable]
        public class DeviceInfoData
        {
            /// <summary>
            /// 入网设备总数。等于0时，表示没有设备信息，下面字段将不存在。
            /// </summary>
            public int TotalNum;
            /// <summary>
            /// 标识当前设备是发送的是第几个设备。DeviceNum从1开始每发送一个设备信息，下一个设备信息的DeviceNum将加1。直到DeviceNum等于TotalNum说明所有设备信息发送完毕。
            /// </summary>
            public int DeviceNum;
            /// <summary>
            /// 入网的utc时间戳
            /// </summary>
            public int JoinTime;
            /// <summary>
            /// 1:路由器设备
            /// <para>2：终端设备</para>
            /// </summary>
            public int ZigbeeType;
            /// <summary>
            /// 设备网络地址
            /// </summary>
            public int NwkAddr;
            /// <summary>
            /// 该字段主要针对IAS安防设备设立。所有IAS安防设备共用一个DeviceID为1026。所以要区分子设备类型，需要该字段。
            /// <para>13:Motion sensor (运动传感器）</para>
            /// <para>43:Carbon Monoxide sensor (一氧化碳传感器）</para>
            /// <para>44:Personal emergency device (紧急按钮）</para>
            /// </summary>
            public int DeviceType;
            /// <summary>
            /// 用于判断设备的zigbee协议版本。
            ///<para>49246：ZLL1.0标准设备。</para>
            ///<para>260： ZHA1.2标准设备、 Z3.0标准设备。</para>
            ///<para>41440：ZGP3.0标准设备。</para>
            ///<para>265：ZSE1.4标准设备。</para>
            /// </summary>
            public int Profile;
            /// <summary>
            /// 设备mac名称
            /// </summary>
            public string MacName;
            /// <summary>
            /// 设备名(Mac+断点命名的）
            /// </summary>
            public string DeviceName;
            /// <summary>
            /// 0：设备不在线
            /// <para>1：设备在线</para>
            /// </summary>
            public int IsOnline;
            /// <summary>
            /// 当前运行程序版本信息。 最大64字节
            /// </summary>
            public int ImgVersion;
            /// <summary>
            /// 硬件版本
            /// </summary>
            public int HwVersion;
            /// <summary>
            /// 当前镜像类型id
            /// </summary>
            public int ImgTypeId;
            /// <summary>
            /// 驱动代码。为0时，表示zigbee协调器设备。其他值表示为虚拟驱动设备
            /// </summary>
            public int DriveCode;
            /// <summary>
            /// 厂商名称
            /// </summary>
            public string ManufacturerName = string.Empty;
            /// <summary>
            /// 模块ID
            /// </summary>
            public string ModelIdentifier = string.Empty;
            /// <summary>
            /// 好像是序列号
            /// </summary>
            public string ProductCode = string.Empty;
            /// <summary>
            /// 设备功能类型(空气开关和继电器专用)
            /// </summary>
            public int FunctionType = -1;
            /// <summary>
            /// 输入簇列表
            /// </summary>
            public List<InClusterObj> InClusterList = new List<InClusterObj>();
            /// <summary>
            /// 输出簇列表
            /// </summary>
            public List<OutClusterObj> OutClusterList = new List<OutClusterObj>();
            /// <summary>
            /// 用于记录设备最新上报的属性状态信息。最大支持记录16个属性状态，且只记录属性值长度不大于4字节的数据。
            /// </summary>
            public List<AttributeStatusObj> AttributeStatus = new List<AttributeStatusObj>();

        }

        #endregion

        #region 错误结果定义

        /// <summary>
        /// 网关信息错误反馈共通
        /// </summary>
        [System.Serializable]
        public class ErrorResponCommon
        {
            /// <summary>
            /// 错误信息
            /// </summary>
            public string errorMessageBase;
            /// <summary>
            /// 网关信息错误反馈
            /// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
            /// </summary>
            public ErrorResponData errorResponData;
        }

        /// <summary>
        /// 网关信息错误反馈
        /// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
        /// </summary>
        [System.Serializable]
        public class ErrorResponData
        {
            /// <summary>
            /// Error参数含义
            ///<para>1：网关无法解析命令数据。</para>
            ///<para>2：协调器正在升级或备份/恢复数据
            ///<para>3：操作设备/组/场景不存在</para>
            ///<para>4：其他错误</para>
            ///<para>5：数据传输错误（在某次客户端向网关发送数据的过程中，网关在合理时间范围内接收客户端数据不完整导致该错误发生。如客户端向网关一次发送100个字节的数据，但网关等待接收了一秒只接收了80个字节。发生该错误，网关将主动关闭客户端连接）</para>
            /// </summary>
            public int Error;
        }

        /// <summary>
        /// 网关错误信息具体内容
        /// </summary>
        public 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个字节的数据，但网关等待接收了一秒只接收了 个字节。发生该错误，网关将主动关闭客户端连接）";
                    break;
                default:
                    break;
            }
            return message;
        }

        #endregion

        #region 修改设备端口名称

        /// <summary>
        /// 重命名设备,网关反馈具体信息
        /// </summary>
        [System.Serializable]
        public class DeviceRenameAllData
        {
            /// <summary>
            /// 错误信息
            /// </summary>
            public string errorMessageBase;
            /// <summary>
            /// 网关信息错误反馈
            /// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
            /// </summary>
            public ErrorResponData errorResponData;
            /// <summary>
            /// 设备名称修改
            /// </summary>
            public DeviceRenameResponseData deviceRenameData;
        }

        /// <summary>
        /// 设备名称修改
        /// </summary>
        [System.Serializable]
        public class DeviceRenameResponseData
        {
            /// <summary>
            /// 0:修改成功
            /// <para>1:修改失败</para>
            /// </summary>
            public int Result;
            /// <summary>
            /// 修改后的设备名称
            /// </summary>
            public string DeviceName;
        }
        #endregion

        #region 修改设备mac名称

        /// <summary>
        /// 修改设备mac名称数据,网关反馈具体信息
        /// </summary>
        [System.Serializable]
        public class RenameDeviceMacNameAllData : ErrorResponCommon
        {
            /// <summary>
            /// 修改设备mac名称数据
            /// </summary>
            public RenameDeviceMacNameData renameDeviceMacNameData;
        }

        /// <summary>
        /// 修改设备mac名称数据
        /// </summary>
        [System.Serializable]
        public class RenameDeviceMacNameData
        {
            /// <summary>
            /// 0:修改成功
            /// <para>1:修改失败,mac不存在</para>
            /// </summary>
            public int Result;
            /// <summary>
            /// 修改后的设备名称
            /// </summary>
            public string MacName;
        }
        #endregion

        #region 一键更新四寸屏按键属性
        /// <summary>
        /// 同步设备功能
        /// </summary>
        /// <returns></returns>
        public async System.Threading.Tasks.Task<SynchronizationDeviceResponseAllData> SyncMsgToBindSource(string deviceAddr, int deviceEpoint)
        {
            if (Gateway == null)
            {
                return null;
            }

            return await System.Threading.Tasks.Task.Run(async () =>
            {
                SynchronizationDeviceResponseAllData resContent = null;
                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)
                        {
                            resContent = new SynchronizationDeviceResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }
                        else
                        {
                            resContent = new SynchronizationDeviceResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }

                    if (topic == gatewayID + "/" + "Bind/SyncMsgToBindSourceRespon")
                    {
                        var res = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Result"].ToString());
                        if (res == null)
                        {
                            resContent = new SynchronizationDeviceResponseAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            resContent = new SynchronizationDeviceResponseAllData { result = res };
                            System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
                        }
                    }
                };
                Gateway.Actions = action;
                DebugPrintLog("Bind/SyncMsgToBindSourceRespon_Actions 启动" + "_" + System.DateTime.Now.ToString());

                try
                {
                    var jObject = new JObject { { "DeviceAddr", deviceAddr }, { "Epoint", deviceEpoint }, { "Cluster_ID", 0 }, { "Command", 5010 } };
                    Gateway.Send("Bind/SyncMsgToBindSource", jObject.ToString());
                }
                catch { }

                var dateTime = DateTime.Now;
                while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
                {
                    await System.Threading.Tasks.Task.Delay(10);
                    if (resContent != null)
                    {
                        break;
                    }
                }
                if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
                {
                    resContent = new SynchronizationDeviceResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
                }
                Gateway.Actions -= action;
                DebugPrintLog("Bind/SyncMsgToBindSource_Actions 退出" + System.DateTime.Now.ToString());

                return resContent;
            });

        }

        /// <summary>
        /// 同步设备,网关反馈具体信息
        /// </summary>
        [System.Serializable]
        public class SynchronizationDeviceResponseAllData
        {
            /// <summary>
            /// 错误信息
            /// </summary>
            public string errorMessageBase;
            /// <summary>
            /// 网关信息错误反馈
            /// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
            /// </summary>
            public ErrorResponData errorResponData;
            /// <summary>
            /// 同步结果
            /// 0:成功：网关内部自动写入设备目标名字、设备目标功能类型、场景目标名字、utc时间写入4寸屏
            /// 1:失败
            /// </summary>
            public int result;
        }
        #endregion

        #region 删除设备（使设备离网）
        /// <summary>
        /// 删除设备（使设备离网）
        /// </summary>
        /// <returns>The device async.</returns>
        /// <param name="removeData">Remove data.</param>
        public async System.Threading.Tasks.Task<RemoveDeviceResponseAllData> DeleteDeviceAsync(ZigBee.Device.CommonDevice.RemoveDeviceData removeData)
        {
            if (Gateway == null || removeData == null)
            {
                return null;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                RemoveDeviceResponseAllData d = null;
                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 RemoveDeviceResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }
                        else
                        {
                            d = new RemoveDeviceResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }

                    if (topic == gatewayID + "/" + "RemoveDeviceRespon")
                    {
                        var removeDeviceResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.RemoveDeviceResponseData>(jobject["Data"].ToString());

                        if (removeDeviceResponseData == null)
                        {
                            d = new RemoveDeviceResponseAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            d = new RemoveDeviceResponseAllData { removeDeviceResponseData = removeDeviceResponseData };
                            System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
                        }
                    }
                };
                Gateway.Actions += action;
                DebugPrintLog("RemoveDevice_Actions 启动" + "_" + System.DateTime.Now.ToString());

                try
                {
                    if (removeData != null)
                    {
                        var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 99 } };
                        var deviceAddrList = new JArray { };
                        foreach (var a in removeData.DeviceAddrList)
                        {
                            var dd = new JObject { { "DeviceAddr", a.DeviceAddr } };
                            deviceAddrList.Add(dd);
                        }

                        var data = new JObject {
                    { "CompelClear", removeData.CompelClear },
                    { "DeviceAddrList", deviceAddrList }
                        };
                        jObject.Add("Data", data);
                        Gateway.Send(("RemoveDevice"), 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 RemoveDeviceResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
                }
                Gateway.Actions -= action;
                DebugPrintLog("RemoveDevice_Actions 退出" + System.DateTime.Now.ToString());

                return d;
            });
        }

        /// <summary>
        /// 需要删除设备的数据
        /// </summary>
        [System.Serializable]
        public class RemoveDeviceData
        {
            /// <summary>
            /// 0：不强制清除。需要节点设备反馈离网确认信息后才能删除设备信息。
            ///<para>1：强制清除。不需要节点设备反馈离网确认信息，直接删除设备信息。</para>
            ///<para>说明：正常情况下让节点设备离网，需要节点设备在线，节点设备反馈离网确认信息后网关方可删除该设备的设备信息。但如果设备已经损坏，或已经通过外部功能离网，此时节点设备已经无法反馈离网确认信息，面对这种情况，要删除保存在网关上的该节点设备的设备信息，需要将该字段赋值为1，网关强制删除该设备信息，不需要节点设备确认。</para>
            /// </summary>
            public int CompelClear = 1;
            /// <summary>
            /// 出网设备列表
            /// </summary>
            public List<RemoveDeviceListInfo> DeviceAddrList = new List<RemoveDeviceListInfo>();
        }

        /// <summary>
        /// 场景信息
        /// </summary>
        public class RemoveDeviceListInfo
        {
            /// <summary>
            /// 设备mac地址
            /// </summary>
            public string DeviceAddr;
        }

        /// <summary>
        /// 移除设备,网关反馈具体信息
        /// </summary>
        [System.Serializable]
        public class RemoveDeviceResponseAllData
        {
            /// <summary>
            /// 错误信息
            /// </summary>
            public string errorMessageBase;
            /// <summary>
            /// 网关信息错误反馈
            /// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
            /// </summary>
            public ErrorResponData errorResponData;
            /// <summary>
            /// 设备名称修改
            /// </summary>
            public RemoveDeviceResponseData removeDeviceResponseData;
        }

        /// <summary>
        /// 删除设备回复数据
        /// <para>返回结果Resul=，删除成功</para>
        /// </summary>
        [System.Serializable]
        public class RemoveDeviceResponseData
        {
            /// <summary>
            /// 0：删除成功
            /// <para>删除失败</para>
            /// </summary>
            public int Result = 2;
            /// <summary>
            /// 出网设备列表
            /// </summary>
            public List<DeviceListInfo> DeviceList = new List<DeviceListInfo>();
        }

        /// <summary>
        /// 场景信息
        /// </summary>
        [System.Serializable]
        public class DeviceListInfo
        {
            /// <summary>
            /// 设备ID
            /// </summary>
            public int Device_ID;

            /// <summary>
            /// 设备mac地址
            /// </summary>
            public string MacAddr;

            /// <summary>
            /// 设备端口号
            /// </summary>
            public int Epoint;

        }
        #endregion

        #region 识别设备
        ///<summary >
        /// 识别设备
        /// <para>cluster=3，具有Identify（识别）功能，属于ZCL库</para>
        /// <para>time:设置设备闪烁时间（秒）范围：0-65535</para>
        /// </summary>
        public void IdentifyControl(string deviceAddr, int deviceEpoint, int time)
        {
            if (Gateway == null)
            {
                return;
            }
            Action<string, string> action = (topic, message) => { };
            Gateway.Actions += action;
            System.Console.WriteLine("Identify_Actions 启动" + "_" + System.DateTime.Now.ToString());

            try
            {
                var jObject = new JObject { { "DeviceAddr", deviceAddr }, { "Epoint", deviceEpoint }, { "Cluster_ID", 3 }, { "Command", 0 }, { "SendMode", 2 } };
                var data = new JObject { { "Time", time } };
                jObject.Add("Data", data);
                Gateway.Send(("Identify"), jObject.ToString());
            }
            catch { }

            Gateway.Actions -= action;
            System.Console.WriteLine("Identify_Actions 退出" + System.DateTime.Now.ToString());

        }
        #endregion

        #region 设备属性状态上报
        /// <summary>
        /// 获取设备当前属性状态
        /// </summary>
        /// <param name="clusterID">Cluster identifier.</param>
        /// <param name="attriButeId">Attri bute identifier.</param>
        public async void ReadAttri(Cluster_ID clusterID, AttriButeId attriButeId)
        {
            if (Gateway == null)
            {
                return;
            }
            await System.Threading.Tasks.Task.Run(async () =>
            {
                //Action<string, string> action = (topic, message) => { };

                // Gateway.Actions += action;
                System.Console.WriteLine("GetDeviceStatus_Actions 启动" + "_" + System.DateTime.Now.ToString());

                try
                {
                    var JObject = new JObject {
                { "DeviceAddr",DeviceAddr },
                { "Epoint", DeviceEpoint },
                { "Cluster_ID", (int)clusterID },
                { "Command", 108 }
           };
                    var attriBute = new JArray{
                  new JObject {
                    { "AttriButeId", (int)attriButeId}
                   }
           };
                    var data = new JObject { { "AttriBute", attriBute } };
                    JObject.Add("Data", data);
                    Gateway?.Send(("GetDeviceStatus"), JObject.ToString());
                }
                catch { }

                // Gateway.Actions -= action;
                System.Console.WriteLine("GetDeviceStatus_Actions 退出" + System.DateTime.Now.ToString());
            });
        }

        /// <summary>
        /// 设备属性状态上报
        /// </summary>
        [Newtonsoft.Json.JsonIgnore]
        public DeviceStatusReportData DeviceStatusReport = new DeviceStatusReportData();
        /// <summary>
        /// 设备属性状态上报
        /// </summary>
        [System.Serializable]
        public class DeviceStatusReportData
        {
            /// <summary>
            /// 属性所在CluterID
            /// <summary>
            /// 设备支持的输入功能
            /// <para>0:Basic,设备支持“基础属性” </para>
            /// <para>3:Identify,设备支持“识别功能”</para>
            /// <para>4:Groups,设备支持“组功能”</para>
            /// <para>5:Scenes,设备支持“场景功能”</para>
            /// <para>6:on/off,设备支持“开关功能”</para>
            /// 开关功能的设备如：调关灯/继电器/窗帘等。。。
            /// <para>8:Level Control,设备支持“亮度调节功能”</para>
            /// 亮度调节功能的设备如：调关灯。。。
            /// <para>257:Door Lock,设备支持“门锁功能”</para>
            /// 门锁功能的设备如：门锁。。。
            ///  <para>258:Window Covering,设备支持“窗帘控制功能”</para>
            /// 窗帘控制功能的设备如：窗帘/开合帘/卷帘。。。
            /// <para>513:Thermostat,设备支持“恒温器功能”</para>
            /// 恒温器功能的设备如：空调。。。
            /// <para>768:Color Control,设备支持“颜色调节功能”</para>
            /// 颜色调节功能的设备如：调光灯。。。
            /// <para>1026:Temperature Measurement,设备支持“温度测量功能”</para>
            /// 温度测量功能的设备如：温度传感器。。。
            /// <para>1029:Relative Humidity Measurement,设备支持“湿度测量功能”</para>
            /// 湿度测量功能的设备如：湿度传感器。。。
            /// </summary>
            /// </summary>
            public int CluterID;
            /// <summary>
            /// 属性列表
            /// </summary>
            public List<AttributeDataObj> AttriBute = new List<AttributeDataObj>();
        }
        #endregion

        #region 设置可写属性的值
        /// <summary>
        /// 设置可写属性的值
        /// </summary>
        /// <returns>The writable value async.</returns>
        /// <param name="gateway">Gateway.</param>
        /// <param name="clusterID">要配置的属性所在的cluster.</param>
        /// <param name="setWritableValue">设置可写属性的数据</param>
        public async System.Threading.Tasks.Task<SetWritableValueResponAllData> SetWritableValueAsync(ZigBee.Device.ZbGateway gateway, int clusterID, SetWritableValueData setWritableValue)
        {
            if (gateway == null || setWritableValue == null)
            {
                return null;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                SetWritableValueResponAllData d = null;
                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 SetWritableValueResponAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }
                        else
                        {
                            d = new SetWritableValueResponAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }

                    if (topic == gatewayID + "/" + "SetWritableValue_Respon")
                    {
                        var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<SetWritableValueResponData>(jobject["Data"].ToString());

                        if (tempData == null)
                        {
                            d = new SetWritableValueResponAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            d = new SetWritableValueResponAllData { setWritableValueResponData = tempData };
                            System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
                        }
                    }
                };
                gateway.Actions += action;
                System.Console.WriteLine("SetWritableValue_Actions 启动" + "_" + System.DateTime.Now.ToString());

                try
                {
                    var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", DeviceEpoint }, { "Cluster_ID", clusterID }, { "Command", 120 } };
                    var data = new JObject { { "Undivided", setWritableValue.Undivided }, { "AttributeId", setWritableValue.AttributeId }, { "AttributeDataType", setWritableValue.AttributeDataType }, { "AttributeData", setWritableValue.AttributeData } };
                    jObject.Add("Data", data);
                    gateway.Send("SetWritableValue", 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 SetWritableValueResponAllData { errorMessageBase = " 回复超时，请重新操作" };
                }
                gateway.Actions -= action;
                System.Console.WriteLine("SetWritableValue_Actions 退出" + System.DateTime.Now.ToString());

                return d;
            });
        }

        /// <summary>
        /// 网关版本信息,网关反馈信息
        /// </summary>
        [System.Serializable]
        public class SetWritableValueResponAllData : ErrorResponCommon
        {
            /// <summary>
            /// 网关版本信息
            /// </summary>
            public SetWritableValueResponData setWritableValueResponData;
        }

        /// <summary>
        /// 设置可写属性的值的数据
        /// </summary>
        [System.Serializable]
        public class SetWritableValueResponData
        {
            /// <summary>
            /// 配置属性所在的cluster
            /// </summary>
            public int Cluster;
            /// <summary>
            /// 0：配置成功（若配置成功，下面的AttributeId字段不存在）
            ///<para>134：不支持该属性</para>
            ///<para>135：无效的属性值</para>
            ///<para>141：无效的数据类型</para>
            /// </summary>
            public int Status;
            /// <summary>
            /// 配置的属性ID（当Status=0 时，该字段将不存在 ，也就是只有失败的结果才会返回该字段）
            /// </summary>
            public int AttributeId;

        }

        /// <summary>
        /// 设置可写属性的值的数据
        /// </summary>
        [System.Serializable]
        public class SetWritableValueData
        {
            /// <summary>
            /// 是否强制写入属性
            ///<para>0：否</para>
            ///<para>1：强制写属性值</para>
            ///<para>可缺省，默认为0。</para>
            /// </summary>
            public int Undivided;
            /// <summary>
            /// 属性id
            /// </summary>
            public int AttributeId;
            /// <summary>
            /// 属性数据类型
            /// </summary>
            public int AttributeDataType;
            /// <summary>
            /// 写入数值
            /// </summary>
            public int AttributeData;

        }
        #endregion

        #region 开关
        ///<summary >
        ///开关控制(仅用于cluster=6的设备）
        /// <para>设备支持cluster=6的设备才能调用该接口</para>
        /// <para>command的值</para>
        ///<para>0 : 关闭</para>
        ///<para>1: 打开</para>
        ///<para>2：取反</para>
        /// </summary>
        public void SwitchControl(int command)
        {
            try
            {
                var jobject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", DeviceEpoint }, { "Cluster_ID", 6 }, { "Command", command }, { "SendMode", 2 } };
                Gateway?.Send(("DeviceControl"), jobject.ToString());
                System.Console.WriteLine("SwitchControl_发送数据" + "_" + jobject.ToString() + "_" + System.DateTime.Now.ToString());

            }
            catch { }
        }
        #endregion

        #region ZCL库-发现属性
        /// <summary>
        ///ZCL库-发现属性(如果返回为空，可能是设备不是标准设备，不支持这条命令）
        /// <para>获取设备的某个Cluster所支持的Attributes</para>
        /// <para> gateway：当前网关</para>
        /// <para> clusterID：需要查询的cluster</para>
        /// <para>读Panel的属性：clusterID=6</para>
        /// <para>读亮度的属性：clusterID=8</para>
        /// </summary>
        public async System.Threading.Tasks.Task<ClusterOwnAttributesResponAllData> ClusterOwnAttributesAsync(ZigBee.Device.ZbGateway gateway, int clusterID)
        {
            if (gateway == null)
            {
                return null;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                ClusterOwnAttributesResponAllData d = null;
                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 ClusterOwnAttributesResponAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }
                        else
                        {
                            d = new ClusterOwnAttributesResponAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }

                    if (topic == gatewayID + "/" + "Cluster/OwnAttributes_Respon")
                    {
                        var clusterOwnAttributesResponData = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ClusterOwnAttributesResponData>(jobject["Data"].ToString());
                        var tempAttributes = Newtonsoft.Json.Linq.JArray.Parse(jobject["Data"]["Attribute"].ToString());
                        for (int m = 0; tempAttributes != null && m < tempAttributes.Count; m++)
                        {
                            var tempAttribute = tempAttributes[m];
                            clusterOwnAttributesResponData.AttributeList.Add(Newtonsoft.Json.JsonConvert.DeserializeObject<AttributeObj>(tempAttribute.ToString()));
                        }

                        if (clusterOwnAttributesResponData == null)
                        {
                            d = new ClusterOwnAttributesResponAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            d = new ClusterOwnAttributesResponAllData { clusterOwnAttributesResponData = clusterOwnAttributesResponData };
                            System.Console.WriteLine($"UI收到通知后的主题_{ topic}");

                        }
                    }
                };
                gateway.Actions += action;
                System.Console.WriteLine("Cluster/OwnAttributes_Actions 启动" + "_" + System.DateTime.Now.ToString());

                try
                {
                    var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", DeviceEpoint }, { "Cluster_ID", clusterID }, { "Command", 301 } };
                    gateway.Send("Cluster/OwnAttributes", 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 ClusterOwnAttributesResponAllData { errorMessageBase = " 回复超时，请重新操作" };
                }
                gateway.Actions -= action;
                System.Console.WriteLine("Cluster/OwnAttributes_Actions 退出" + System.DateTime.Now.ToString());

                return d;
            });
        }

        /// <summary>
        /// 发现属性,网关反馈信息
        /// </summary>
        [System.Serializable]
        public class ClusterOwnAttributesResponAllData : ErrorResponCommon
        {
            /// <summary>
            /// 网关版本信息
            /// </summary>
            public ClusterOwnAttributesResponData clusterOwnAttributesResponData;
        }

        [System.Serializable]
        public class ClusterOwnAttributesResponData
        {
            /// <summary>
            /// 查询的cluste
            /// </summary>
            public int Cluster;
            /// <summary>
            /// 设备属性列表
            /// </summary>
            public List<AttributeObj> AttributeList = new List<AttributeObj>();

        }
        #endregion

        #region ZCL库-支持的Command
        /// <summary>
        ///ZCL库-设备某cluster所支持的Command  ;(如果返回为空，可能是设备不是标准设备，不支持这条命令）
        /// <para>获取设备某cluster所支持的Command</para>
        /// <para> gateway：当前网关</para>
        /// <para> clusterID：需要查询的cluster</para>
        /// </summary>
        public async System.Threading.Tasks.Task<ClusterOwnCommandResponAllData> ClusterOwnCommandAsync(ZigBee.Device.ZbGateway gateway, int clusterID)
        {
            if (gateway == null)
            {
                return null;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                ClusterOwnCommandResponAllData d = null;
                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 ClusterOwnCommandResponAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }
                        else
                        {
                            d = new ClusterOwnCommandResponAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };

                        }
                    }

                    if (topic == gatewayID + "/" + "Cluster/OwnCommand_Respon")
                    {
                        var clusterOwnCommandResponData = Newtonsoft.Json.JsonConvert.DeserializeObject<ClusterOwnCommandResponData>(jobject["Data"].ToString());

                        if (clusterOwnCommandResponData == null)
                        {
                            d = new ClusterOwnCommandResponAllData { errorMessageBase = "网关返回的数据为空" };

                        }
                        else
                        {
                            d = new ClusterOwnCommandResponAllData { clusterOwnCommandResponData = clusterOwnCommandResponData };
                            System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
                        }
                    }
                };
                gateway.Actions += action;
                System.Console.WriteLine("Cluster/OwnCommand_Actions 启动" + "_" + System.DateTime.Now.ToString());

                try
                {
                    var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", DeviceEpoint }, { "Cluster_ID", clusterID }, { "Command", 302 } };
                    gateway.Send("Cluster/OwnCommand", 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 ClusterOwnCommandResponAllData { errorMessageBase = " 回复超时，请重新操作" };

                }
                gateway.Actions -= action;
                System.Console.WriteLine("Cluster/OwnCommand_Actions 退出" + System.DateTime.Now.ToString());

                return d;
            });
        }

        /// <summary>
        /// 设备某cluster所支持的Command数据,网关反馈信息
        /// </summary>
        [System.Serializable]
        public class ClusterOwnCommandResponAllData : ErrorResponCommon
        {
            /// <summary>
            /// 网设备某cluster所支持的Command数据
            /// </summary>
            public ClusterOwnCommandResponData clusterOwnCommandResponData;
        }

        /// <summary>
        /// 设备某cluster所支持的Command数据
        /// </summary>
        [System.Serializable]
        public class ClusterOwnCommandResponData
        {
            /// <summary>
            /// 查询的cluste
            /// </summary>
            public int Cluster;
            /// <summary>
            /// 设备属性列表
            /// </summary>
            public List<CommandObj> Command = new List<CommandObj>();

        }
        #endregion

        #region 设定OTA升级固件.;
        /// <summary>
        /// 设定OTA升级固件
        /// </summary>
        /// <returns>The NVA sync.</returns>
        /// <param name="gateway">Gateway.</param>
        /// <param name="oTAImageName">O TAI mage name:升级镜像名称</param>
        public async System.Threading.Tasks.Task<OTASetImageResponseAllData> UpgradeDeviceAsync(ZigBee.Device.ZbGateway gateway, string oTAImageName)
        {
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                OTASetImageResponseAllData d = null; ;
                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 OTASetImageResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }

                        else
                        {
                            d = new OTASetImageResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }

                    if (topic == gatewayID + "/" + "OTA/SetImage_Respon")
                    {
                        var oTASetImageData = Newtonsoft.Json.JsonConvert.DeserializeObject<OTASetImageData>(jobject["Data"].ToString());

                        if (oTASetImageData == null)
                        {
                            d = new OTASetImageResponseAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            d = new OTASetImageResponseAllData { otaSetImageData = oTASetImageData };
                            System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
                        }
                    }
                };
                gateway.Actions += action;
                System.Console.WriteLine("OTA/SetImage_Actions 启动" + "_" + System.DateTime.Now.ToString());

                try
                {
                    var jObject = new JObject { { "Cluster_ID", 25 }, { "Command", 30 } };
                    var data = new JObject { { "OTAImageName", oTAImageName }, { "OTAImagePath", "/tmp" } };
                    jObject.Add("Data", data);
                    gateway.Send(("OTA/SetImage"), 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 OTASetImageResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
                }
                gateway.Actions -= action;
                System.Console.WriteLine("OTA/SetImage_Actions 退出" + System.DateTime.Now.ToString());

                return d;
            });
        }

        /// <summary>
        /// 设备进行OTA升级,网关反馈具体信息
        /// </summary>
        [System.Serializable]
        public class OTASetImageResponseAllData : ErrorResponCommon
        {
            /// <summary>
            /// 保存zigbee协调器组网信息
            /// </summary>
            public OTASetImageData otaSetImageData;
        }

        [System.Serializable]
        public class OTASetImageData
        {
            /// <summary>
            /// 0：成功
            ///<para>1：没有找到文件或打开文件失败</para>
            ///<para>2：当前有节点设备正在ota升级，原来的ota固件还在占用，不能重新设定固件。若要重新设定ota固件，则需要先用终止升级指令终止所有正在升级的节点设备。</para>
            /// </summary>
            public int Result;

            /// <summary>
            /// 该ota固件的制造商ID(Result = 0时存在)
            /// </summary>
            public int Manufacture;

            /// <summary>
            /// 该ota固件的固件类型id(Result = 0时存在)
            /// </summary>
            public int ImgTypeId;

            /// <summary>
            /// 该ota固件的版本(Result = 0时存在)
            /// </summary>
            public int FileVersion;

            /// <summary>
            /// 固件大小
            /// </summary>
            public int FileSize;

            /// <summary>
            ///正在升级的ota节点设备列(Result=2时，该字段才存在)
            /// </summary>
            public List<OTADeviceList> DeviceList = new List<OTADeviceList>();
        }

        /// <summary>
        /// 输入簇
        /// </summary>
        [System.Serializable]
        public class OTADeviceList
        {
            /// <summary>
            /// MAC地址
            /// </summary>
            public string MacAddr;

            /// <summary>
            /// 设备端口号，当升级设备，HDL的设备大多数的端点默认是200
            /// </summary>
            public int Epoint = 200;
        }
        #endregion

        #region 启动升级;
        /// <summary>
        /// 设定OTA升级固件
        /// </summary>
        /// <returns>The NVA sync.</returns>
        /// <param name="gateway">Gateway.</param>
        /// <param name="oTAImageName">O TAI mage name:升级镜像名称</param>
        public async System.Threading.Tasks.Task<StartDeviceUpdateResponseAllData> StartDeviceUpdateAsync(ZigBee.Device.ZbGateway gateway, StartUpdateData startUpdateData)
        {
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                StartDeviceUpdateResponseAllData d = null; ;
                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 StartDeviceUpdateResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }

                        else
                        {
                            d = new StartDeviceUpdateResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }

                    if (topic == gatewayID + "/" + "OTA/StartUpdate_Respon")
                    {
                        var startUpdateDeviceData = Newtonsoft.Json.JsonConvert.DeserializeObject<StartDeviceUpdateData>(jobject["Data"].ToString());

                        if (startUpdateDeviceData == null)
                        {
                            d = new StartDeviceUpdateResponseAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            d = new StartDeviceUpdateResponseAllData { startUpdateDeviceData = startUpdateDeviceData };
                            System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
                        }
                    }
                };
                gateway.Actions += action;
                System.Console.WriteLine("OTA/StartUpdate_Actions 启动" + "_" + System.DateTime.Now.ToString());

                try
                {
                    if (startUpdateData != null)
                    {
                        var jObject = new JObject { { "Cluster_ID", 25 }, { "Command", 0 } };
                        var deviceList = new JArray { };
                        foreach (var de in startUpdateData.DeviceList)
                        {
                            var dInfo = new JObject{
                            { "MacAddr",de.MacAddr},
                            { "Epoint", de.Epoint}
                            };
                            deviceList.Add(dInfo);
                        }
                        var data = new JObject { { "DeviceList", deviceList } };
                        jObject.Add("Data", data);
                        gateway.Send(("OTA/StartUpdate"), jObject.ToString());
                    }
                }
                catch
                { }
                var dateTime = DateTime.Now;
                while ((DateTime.Now - dateTime).TotalMilliseconds < 30 * 1000)
                {
                    await System.Threading.Tasks.Task.Delay(10);
                    if (d != null)
                    {
                        break;
                    }
                }
                if ((DateTime.Now - dateTime).TotalMilliseconds > 30 * 1000)
                {
                    d = new StartDeviceUpdateResponseAllData { errorMessageBase = " 回复超时，请重新操作" };

                }
                gateway.Actions -= action;
                System.Console.WriteLine("OTA/StartUpdate_Actions 退出" + System.DateTime.Now.ToString());

                return d;
            });
        }

        /// <summary>
        /// 启动升级,网关反馈具体信息
        /// </summary>
        [System.Serializable]
        public class StartDeviceUpdateResponseAllData
        {
            /// <summary>
            /// 错误信息
            /// </summary>
            public string errorMessageBase;
            /// <summary>
            /// 网关信息错误反馈
            /// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
            /// </summary>
            public ErrorResponData errorResponData;
            /// <summary>
            /// 保存zigbee协调器组网信息
            /// </summary>
            public StartDeviceUpdateData startUpdateDeviceData;
        }

        [System.Serializable]
        public class StartDeviceUpdateData
        {
            /// <summary>
            /// 0：正常
            /// <para>1：启动失败，未设定升级固件</para>
            /// </summary>
            public int Result = 999;

            /// <summary>
            ///升级设备列表
            /// </summary>
            public List<OTAStartUpdateList> DeviceList = new List<OTAStartUpdateList>();
        }

        /// <summary>
        /// 输入簇
        /// </summary>
        [System.Serializable]
        public class OTAStartUpdateList
        {
            /// <summary>
            /// MAC地址
            /// </summary>
            public string MacAddr;

            /// <summary>
            /// 设备端口号，当升级设备，HDL的设备大多数的端点默认是200
            /// </summary>
            public int Epoint = 200;

            /// <summary>
            /// 设备名称
            /// </summary>
            public string DeviceName;
        }

        /// <summary>
        /// 启动升级
        /// </summary>
        [Newtonsoft.Json.JsonIgnore]
        public OTAScheduleResponData oTAScheduleResponData;

        [System.Serializable]
        public class OTAScheduleResponData
        {
            /// <summary>
            /// 0：节点设备可进行OTA升级（如果设备在线，且支持OTA升级，则设备首先会反馈该状态，说明该设备OTA升级已启动）
            ///<para>1：正在升级（设备处于下载OTA升级固件状态将反馈该状</para>
            ///<para>2：升级完成（OTA升级完成，节点设备反馈该状态）</para>
            ///<para>3：升级失败，响应超时</para>
            ///<para>150：无效的OTA升级固件（下载完成后，由节点设备判断固件是否有效）</para>
            ///<para>153：客户端仍需更多的OTA升级固件</para>
            ///<para>149：升级终止</para>
            /// </summary>
            public int Status = 999;

            /// <summary>
            /// 升级百分比。(当Status=1时有效)
            /// </summary>
            public int Percent = 999;
        }

        [System.Serializable]
        public class StartUpdateData
        {
            /// <summary>
            ///升级设备列表
            /// </summary>
            public List<OTADeviceList> DeviceList = new List<OTADeviceList>();
        }

        #endregion

        #region 客户端向节点设备透传数据.
        /// <summary>
        /// 客户端向节点设备透传数据
        /// <para>passData:透传数据(这里的值是在各个设备对象中复制好的，传进来即可）</para>
        /// <para>透传数据返回后，可以调用各个设备对象中获取相应的处理完成的数据</para>
        /// </summary>
        public async System.Threading.Tasks.Task<ClientDataPassthroughResponseAllData> ClientDataPassthroughAsync(ZigBee.Device.ZbGateway gateway, string passData)
        {
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                ClientDataPassthroughResponseAllData d = null; ;
                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 ClientDataPassthroughResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }

                        else
                        {
                            d = new ClientDataPassthroughResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }

                    if (topic == gatewayID + "/" + "ZbDataPassthrough")
                    {
                        var clientDataPassthroughResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<ClientDataPassthroughResponseData>(jobject["Data"].ToString());

                        if (clientDataPassthroughResponseData == null)
                        {
                            d = new ClientDataPassthroughResponseAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            d = new ClientDataPassthroughResponseAllData { clientDataPassthroughResponseData = clientDataPassthroughResponseData };
                            System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
                        }
                    }
                };
                gateway.Actions += action;
                System.Console.WriteLine("ClientDataPassthrough_Actions 启动" + "_" + System.DateTime.Now.ToString());

                try
                {
                    var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", 200 }, { "Cluster_ID", 64513 }, { "Command", 0 } };
                    var data = new JObject { { "PassData", passData } };
                    jObject.Add("Data", data);
                    gateway.Send("ClientDataPassthrough", 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 ClientDataPassthroughResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
                }
                gateway.Actions -= action;
                System.Console.WriteLine("ClientDataPassthrough_Actions 退出" + System.DateTime.Now.ToString());

                return d;
            });
        }

        /// <summary>
        /// 客户端向节点设备透传数据,网关反馈具体信息
        /// </summary>
        [System.Serializable]
        public class ClientDataPassthroughResponseAllData : ErrorResponCommon
        {
            /// <summary>
            /// 客户端向节点设备透传数据
            /// </summary>
            public ClientDataPassthroughResponseData clientDataPassthroughResponseData;
        }
        /// <summary>
        /// 客户端向节点设备透传数据
        /// </summary>
        [Newtonsoft.Json.JsonIgnore]
        public ClientDataPassthroughResponseData clientDataPassthroughResponseData = new ClientDataPassthroughResponseData();

        [System.Serializable]
        public class ClientDataPassthroughResponseData
        {
            /// <summary>
            /// 透传的数据，最大256个字符，也就是透传128个字节
            /// </summary>
            public string PassData;
        }

        /// <summary>
        /// 启用或关闭节点设备透传数据上传接口,网关反馈具体信息
        /// </summary>
        [System.Serializable]
        public class OnZbDataPassthroughResponseAllData : ErrorResponCommon
        {
            /// <summary>
            /// 启用或关闭节点设备透传数据上传接口
            /// </summary>
            public OnZbDataPassthroughData onZbDataPassthroughData;
        }

        [System.Serializable]
        public class OnZbDataPassthroughData
        {
            /// <summary>
            /// 已经转换成字符格式的16进制的透传数据
            /// </summary>
            public string PassData;
        }
        #endregion

        #region 下载云端固件.
        /// <summary>
        /// 下载云端设备固件
        /// </summary>
        /// <returns>The file async.</returns>
        /// <param name="gateway">Gateway:当前网关</param>
        /// <param name="distributedMark">Distributed mark:固件唯一标识</param>
        /// <param name="imageName">Image name:固件版本</param>
        public async System.Threading.Tasks.Task<DownloadFileResponAllData> DownloadFileAsync(ZigBee.Device.ZbGateway gateway, string distributedMark, string imageName)
        {
            if (gateway == null)
            {
                return null;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                DownloadFileResponAllData d = null; ;
                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 DownloadFileResponAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }
                        else
                        {
                            d = new DownloadFileResponAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }

                    if (topic == gatewayID + "/" + "DownloadFile_Respon")
                    {
                        var downloadFileResponData = Newtonsoft.Json.JsonConvert.DeserializeObject<DownloadFileResponData>(jobject["Data"].ToString());

                        if (downloadFileResponData == null)
                        {
                            d = new DownloadFileResponAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            d = new DownloadFileResponAllData { downloadFileResponData = downloadFileResponData };
                            System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
                        }
                    }
                };
                gateway.Actions += action;
                try
                {
                    var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 6000 } };
                    var data = new JObject {
                        { "DistributeMark", distributedMark},
                        { "DownloadPath", "/tmp" },
                        { "FileName", imageName }
                     };
                    jObject.Add("Data", data);
                    gateway.Send("DownloadFile", jObject.ToString());
                }
                catch
                {
                }
                var dateTime = DateTime.Now;
                while ((DateTime.Now - dateTime).TotalMilliseconds < 30 * 1000)
                {
                    await System.Threading.Tasks.Task.Delay(10);
                    if (d != null)
                    {
                        break;
                    }
                }
                if ((DateTime.Now - dateTime).TotalMilliseconds > 30 * 1000)
                {
                    d = new DownloadFileResponAllData { errorMessageBase = " 回复超时，请重新操作" };

                }
                gateway.Actions -= action;
                System.Console.WriteLine("DownloadFile_Actions 退出" + System.DateTime.Now.ToString());

                return d;
            });

        }

        /// <summary>
        /// 网关系统升级,网关反馈具体信息
        /// </summary>
        [System.Serializable]
        public class DownloadFileResponAllData : ErrorResponCommon
        {
            /// <summary>
            /// 下载云端固件
            /// </summary>
            public DownloadFileResponData downloadFileResponData;
        }

        /// <summary>
        /// 下载云端固件
        /// </summary>
        [System.Serializable]
        public class DownloadFileResponData
        {
            /// <summary>
            /// 下载固件的唯一标识
            /// </summary>
            public string DistributeMark;
            /// <summary>
            /// 0：成功，开启启动下载。
            ///<para>1：失败，文件创建失败。</para>
            ///<para>2：失败，云端没有找到该标识文件。</para>
            ///<para>3：网关未能连接云端。</para>
            ///<para>4：其他错误。</para>
            /// </summary>
            public int Result;
        }

        /// <summary>
        /// 下载进度
        /// </summary>
        [Newtonsoft.Json.JsonIgnore]
        public DownloadFileProgressResponData downloadFileProgressResponData;
        /// <summary>
        /// 下载进度
        /// </summary>
        [System.Serializable]
        public class DownloadFileProgressResponData
        {
            /// <summary>
            /// 下载固件的唯一标识
            /// </summary>
            public string DistributeMark;
            /// <summary>
            ///<para>0：下载成功</para>
            ///<para>1：正在下载</para>
            ///<para>2：下载失败</para>
            /// </summary>
            public int Status;
            /// <summary>
            ///文件总大小
            /// </summary>
            public int TotalSize;
            /// <summary>
            ///当前已经下载文件大小
            /// </summary>
            public int DownloadSize;
            /// <summary>
            ///下载进度，百分比。每百分之十反馈一次
            /// </summary>
            public int DownloadPercent;
        }

        #endregion

        #region 终止设备升级;
        /// <summary>
        /// 终止设备升级
        /// </summary>
        /// <returns>The NVA sync.</returns>
        /// <param name="gateway">Gateway.</param>
        /// <param name="oTAImageName">O TAI mage name:升级镜像名称</param>
        public async System.Threading.Tasks.Task<KillUpdateResponseAllData> KillUpdateAsync(ZigBee.Device.ZbGateway gateway, int deviceEpoint = 200)
        {
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                KillUpdateResponseAllData d = null; ;
                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 KillUpdateResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }

                        else
                        {
                            d = new KillUpdateResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }

                    if (topic == gatewayID + "/" + "OTA/KillUpdate_Respon")
                    {
                        var killUpdateData = Newtonsoft.Json.JsonConvert.DeserializeObject<KillUpdateData>(jobject["Data"].ToString());

                        if (killUpdateData == null)
                        {
                            d = new KillUpdateResponseAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            d = new KillUpdateResponseAllData { killUpdateData = killUpdateData };
                            System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
                        }
                    }
                };
                gateway.Actions += action;
                System.Console.WriteLine("OTA/KillUpdate_Actions 启动" + "_" + System.DateTime.Now.ToString());

                try
                {
                    var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", deviceEpoint }, { "Cluster_ID", 25 }, { "Command", 5 } };
                    gateway.Send("OTA/KillUpdate", 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 KillUpdateResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
                }
                gateway.Actions -= action;
                System.Console.WriteLine("OTA/KillUpdate_Actions 退出" + System.DateTime.Now.ToString());

                return d;
            });
        }

        /// <summary>
        /// 终止设备升级,网关反馈具体信息
        /// </summary>
        [System.Serializable]
        public class KillUpdateResponseAllData : ErrorResponCommon
        {
            /// <summary>
            /// 终止设备升级
            /// </summary>
            public KillUpdateData killUpdateData;
        }

        [System.Serializable]
        public class KillUpdateData
        {
            /// <summary>
            ///0：终止成功
            ///<para>1：终止失败，设备并不处于OTA升级状态。</para>
            /// </summary>
            public int Result;
        }
        #endregion

        #region 私有协议网关和设备的默认回复

        [System.Serializable]
        public class ResponseAllData : ErrorResponCommon
        {
            /// <summary>
            /// 按键指示灯颜色信息
            /// </summary>
            public ResponseData responseData;
        }

        /// <summary>
        /// 私有协议网关和设备的默认回复
        /// </summary>
        [System.Serializable]
        public class ResponseData
        {
            /// <summary>
            ///响应操作码（0-ffff）
            /// </summary>
            public string command;
            /// <summary>
            /// 状态值
            /// <para>0--成功 1--失败 ff--无效</para>
            /// </summary>
            public int status = -1;
        }
        #endregion

        #region ■ 调试打印

        /// <summary>
        /// 调试时打开打印信息，true:打印，false:不打印
        /// </summary>
        /// <param name="msg">Message.</param>
        /// <param name="flage">If set to <c>true</c> flage.</param>
        public static void DebugPrintLog(string msg, bool flage = true)
        {
#if DEBUG
            if (flage == true)
            {
                if (msg.Contains("DeviceStatusReport") == false)
                {
                    System.Console.WriteLine(msg + "  " + System.DateTime.Now.ToLongTimeString() + " " + System.DateTime.Now.Millisecond);
                }
            }
#endif
        }

        #endregion
    }
}