Merge branch 'wjc' into Dev-Branch-2024

wxr

2024-01-03 488cf7d591dc7400ed5c7f116af7005396c666e2

Merge branch 'wjc' into Dev-Branch-2024

 HDL_ON/DAL/DriverLayer/AsyncUdpServer.cs

New file
@@ -0,0 +1,453 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
 
namespace HDL_ON.DAL.DriverLayer
{
    //class AsyncUdpServer
    /// <summary>
    /// UdpClient 实现异步UDP服务器
    /// </summary>
    public class AsyncUdpServer
    {
        #region Fields
        /// <summary>
        /// 服务器程序允许的最大客户端连接数
        /// </summary>
        private int _maxClient;

        /// <summary>
        /// 当前的连接的客户端数
        /// </summary>
        //private int _clientCount;

        /// <summary>
        /// 服务器使用的异步UdpClient
        /// </summary>
        private UdpClient _server;

        /// <summary>
        /// 客户端会话列表
        /// </summary>
        //private List<AsyncUDPState> _clients;

        private bool disposed = false;

        /// <summary>
        /// 数据接受缓冲区
        /// </summary>
        private byte[] _recvBuffer;

        #endregion

        #region Properties

        /// <summary>
        /// 服务器是否正在运行
        /// </summary>
        public bool IsRunning { get; private set; }
        /// <summary>
        /// 监听的IP地址
        /// </summary>
        public IPAddress Address { get; private set; }
        /// <summary>
        /// 监听的端口
        /// </summary>
        public int Port { get; private set; }
        /// <summary>
        /// 通信使用的编码
        /// </summary>
        public Encoding Encoding { get; set; }

        #endregion

        #region 构造函数

        /// <summary>
        /// 异步UdpClient UDP服务器
        /// </summary>
        /// <param name="listenPort">监听的端口</param>
        public AsyncUdpServer(int listenPort)
            : this(IPAddress.Any, listenPort, 10240)
        {
        }

        /// <summary>
        /// 异步UdpClient UDP服务器
        /// </summary>
        /// <param name="localEP">监听的终结点</param>
        public AsyncUdpServer(IPEndPoint localEP)
            : this(localEP.Address, localEP.Port, 10240)
        {
        }

        /// <summary>
        /// 异步UdpClient UDP服务器
        /// </summary>
        /// <param name="localIPAddress">监听的IP地址</param>
        /// <param name="listenPort">监听的端口</param>
        /// <param name="maxClient">最大客户端数量</param>
        public AsyncUdpServer(IPAddress localIPAddress, int listenPort, int maxClient)
        {
            this.Address = localIPAddress;
            this.Port = listenPort;
            this.Encoding = Encoding.Default;

            _maxClient = maxClient;
            //_clients = new List<AsyncUDPSocketState>();
            _server = new UdpClient(new IPEndPoint(this.Address, this.Port));
            uint IOC_IN = 0x80000000;
            uint IOC_VENDOR = 0x18000000;
            uint SIO_UDP_CONNRESET = IOC_IN | IOC_VENDOR | 12;

            _server.Client.IOControl((int)SIO_UDP_CONNRESET, new byte[] { Convert.ToByte(false) }, null);

            _recvBuffer = new byte[_server.Client.ReceiveBufferSize];
        }

        #endregion

        #region Method
        /// <summary>
        /// 启动服务器
        /// </summary>
        /// <returns>异步TCP服务器</returns>
        public void Start()
        {
            try
            {
                if (!IsRunning)
                {
                    IsRunning = true;
                    _server.EnableBroadcast = true;
                    _server.BeginReceive(ReceiveDataAsync, null);
                }
            }
            catch (Exception e) { }
        }

        /// <summary>
        /// 停止服务器
        /// </summary>
        public void Stop()
        {
            try
            {
                //if (IsRunning)
                {
                    IsRunning = false;
                    _server.Close();
                    //TODO 关闭对所有客户端的连接

                }
            }
            catch (Exception e) { }
        }

        /// <summary>
        /// 接收数据的方法
        /// </summary>
        /// <param name="ar"></param>
        private void ReceiveDataAsync(IAsyncResult ar)
        {
            bool isReceive = false;
            try
            {
                var udpState = new AsyncUDPState();
                IPEndPoint remote = null;
                udpState.buffer = _server.EndReceive(ar, ref remote); ;
                udpState.remote = remote;
                udpState.udpClient = _server;

                isReceive = true;
                receive();

                //触发数据收到事件
                RaiseDataReceived(udpState);
            }
            catch (Exception)
            {
                //TODO 处理异常
                RaiseOtherException(null);
            }
            finally
            {
                if (!isReceive)
                {
                    receive();
                }
            }
        }

        void receive()
        {
            if (IsRunning && _server != null)
            {
                int count = 10;
                while (0 < count--)
                {
                    try
                    {
                        _server.BeginReceive(ReceiveDataAsync, null);
                        break;
                    }
                    catch (Exception e)
                    {
                        System.Threading.Thread.Sleep(100);
                    }
                }
            }

        }

        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="msg"></param>
        /// <param name="remote"></param>
        public void Send(byte[] data, IPEndPoint remote)
        {
            try
            {
                RaisePrepareSend(null);
                _server.BeginSend(data, data.Length, remote, new AsyncCallback(SendCallback), null);
            }
            catch (Exception)
            {
                //TODO 异常处理
                RaiseOtherException(null);
            }
        }

        private void SendCallback(IAsyncResult ar)
        {
            //if (ar.IsCompleted)
            {
                try
                {
                    _server.EndSend(ar);
                    //消息发送完毕事件
                    RaiseCompletedSend(null);
                }
                catch (Exception)
                {
                    //TODO 数据发送失败事件
                    RaiseOtherException(null);
                }
            }

        }
        #endregion

        #region 事件
        /// <summary>
        /// 接收到数据事件
        /// </summary>
        public event EventHandler<AsyncUDPEventArgs> DataReceived;

        private void RaiseDataReceived(AsyncUDPState state)
        {
            if (DataReceived != null)
            {
                DataReceived(this, new AsyncUDPEventArgs(state));
            }
        }

        /// <summary>
        /// 发送数据前的事件
        /// </summary>
        public event EventHandler<AsyncUDPEventArgs> PrepareSend;

        /// <summary>
        /// 触发发送数据前的事件
        /// </summary>
        /// <param name="state"></param>
        private void RaisePrepareSend(AsyncUDPState state)
        {
            if (PrepareSend != null)
            {
                PrepareSend(this, new AsyncUDPEventArgs(state));
            }
        }

        /// <summary>
        /// 数据发送完毕事件
        /// </summary>
        public event EventHandler<AsyncUDPEventArgs> CompletedSend;

        /// <summary>
        /// 触发数据发送完毕的事件
        /// </summary>
        /// <param name="state"></param>
        private void RaiseCompletedSend(AsyncUDPState state)
        {
            if (CompletedSend != null)
            {
                CompletedSend(this, new AsyncUDPEventArgs(state));
            }
        }

        /// <summary>
        /// 网络错误事件
        /// </summary>
        public event EventHandler<AsyncUDPEventArgs> NetError;
        /// <summary>
        /// 触发网络错误事件
        /// </summary>
        /// <param name="state"></param>
        private void RaiseNetError(AsyncUDPState state)
        {
            if (NetError != null)
            {
                NetError(this, new AsyncUDPEventArgs(state));
            }
        }

        /// <summary>
        /// 异常事件
        /// </summary>
        public event EventHandler<AsyncUDPEventArgs> OtherException;
        /// <summary>
        /// 触发异常事件
        /// </summary>
        /// <param name="state"></param>
        private void RaiseOtherException(AsyncUDPState state, string descrip)
        {
            if (OtherException != null)
            {
                OtherException(this, new AsyncUDPEventArgs(descrip, state));
            }
        }
        private void RaiseOtherException(AsyncUDPState state)
        {
            RaiseOtherException(state, "");
        }
        #endregion

        #region Close
        /// <summary>
        /// 关闭一个与客户端之间的会话
        /// </summary>
        /// <param name="state">需要关闭的客户端会话对象</param>
        public void Close(AsyncUDPState state)
        {
            if (state != null)
            {
                //_clients.Remove(state);
                //_clientCount--;
                //TODO 触发关闭事件
            }
        }
        /// <summary>
        /// 关闭所有的客户端会话,与所有的客户端连接会断开
        /// </summary>
        public void CloseAllClient()
        {
            //foreach (AsyncUDPSocketState client in _clients)
            //{
            //    Close(client);
            //}
            //_clientCount = 0;
            //_clients.Clear();
        }

        #endregion

        #region 释放
        /// <summary>
        /// Performs application-defined tasks associated with freeing, 
        /// releasing, or resetting unmanaged resources.
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Releases unmanaged and - optionally - managed resources
        /// </summary>
        /// <param name="disposing"><c>true</c> to release 
        /// both managed and unmanaged resources; <c>false</c> 
        /// to release only unmanaged resources.</param>
        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    try
                    {
                        Stop();
                        if (_server != null)
                        {
                            _server = null;
                        }
                    }
                    catch (SocketException)
                    {
                        //TODO
                        RaiseOtherException(null);
                    }
                }
                disposed = true;
            }
        }
        #endregion
    }
}
public class AsyncUDPState
{
    // Client   socket.
    public UdpClient udpClient = null;
    // Size of receive buffer.
    public const int BufferSize = 1024;
    // Receive buffer.
    public byte[] buffer = new byte[BufferSize];
    // Received data string.
    public StringBuilder sb = new StringBuilder();

    public IPEndPoint remote = new IPEndPoint(IPAddress.Any, 0);
}
/// <summary>
/// UdpClient 异步UDP服务器事件参数类
/// </summary>
public class AsyncUDPEventArgs : EventArgs
{
    /// <summary>
    /// 提示信息
    /// </summary>
    public string _msg;

    /// <summary>
    /// 客户端状态封装类
    /// </summary>
    public AsyncUDPState _state;

    /// <summary>
    /// 是否已经处理过了
    /// </summary>
    public bool IsHandled { get; set; }

    public AsyncUDPEventArgs(string msg)
    {
        this._msg = msg;
        IsHandled = false;
    }
    public AsyncUDPEventArgs(AsyncUDPState state)
    {
        this._state = state;
        IsHandled = false;
    }
    public AsyncUDPEventArgs(string msg, AsyncUDPState state)
    {
        this._msg = msg;
        this._state = state;
        IsHandled = false;
    }

}

 HDL_ON/DAL/DriverLayer/Packet.cs

@@ -12,11 +12,11 @@
    /// </summary>
    public class Packet
    {
        /// <summary>
        /// 缓冲区大小
        /// Link协议现在一个包的数据比较大，缓冲区太小存不完全部数据 2023-07-14 16:03:56  wxr
        /// </summary>
        public const int Size = 1024 * 10;
        ///// <summary>
        ///// 缓冲区大小
        ///// Link协议现在一个包的数据比较大，缓冲区太小存不完全部数据 2023-07-14 16:03:56  wxr
        ///// </summary>
        //public const int Size = 2000;

        /// <summary>
        /// 接收到的数据
@@ -28,11 +28,15 @@
        /// </summary>
        public System.Net.EndPoint RemoteEndPoint;

        public Packet()
        public Packet(int lenght)
        {
            this.Bytes = new byte[Size];
            this.Bytes = new byte[lenght];
           
            RemoteEndPoint = new System.Net.IPEndPoint(System.Net.IPAddress.Any, 0);
        }



        public Packet(byte[] data, System.Net.EndPoint remoteEndPoint)
        {
            this.Bytes = data;

 HDL_ON/DAL/DriverLayer/UdpSocket.cs

@@ -1,4 +1,222 @@
using System;
//using System;
//using System.Net.Sockets;
//using System.Net;

//namespace HDL_ON.DriverLayer
//{
//    public class UdpSocket
//    {
//        static UdpSocket _busSocket;
//        public static UdpSocket _BusSocket
//        {
//            get
//            {
//                if(_busSocket == null)
//                {
//                    _busSocket = new UdpSocket();
//                }
//                return _busSocket;
//            }
//        }

//        //本地Socket
//        private Socket busSocket;
//        public int Port = 0;
//        /// <summary>
//        /// 启动Socket接收和发送功能
//        /// </summary>
//        public void Start (int port = 0)
//        {
//            if (IsRunning)
//            {
//                if (port == Port)
//                {
//                    return;
//                }
//                else
//                {
//                    busSocket.Close();
//                }
//            }
//            if (port != 0)
//                Port = port;
//            if (Port == 0)
//                return;

//            busSocket = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
//            busSocket.EnableBroadcast = true;
//            try {
//                busSocket.Bind(new IPEndPoint(IPAddress.Any, Port));

//                busSocket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.AddMembership, new MulticastOption(IPAddress.Parse("239.0.168.188")));
//                relinkCount = 0;
//            }
//            catch (Exception ex){
//                MainPage.Log ($"udp port bind error : {ex.Message}");

//                busSocket = null;
//                return;
//            }

//            asyncBeginReceive();

//            MainPage.Log ($"udp port : {port}");
//        }

//        /// <summary>
//        /// 停止Socket
//        /// </summary>
//        public void Stop()
//        {
//            if(busSocket == null)
//            {
//                return;
//            }
//            if (!IsRunning)
//            {
//                return;
//            }
//            try
//            {
//                busSocket.Close();
//                relinkCount = 0;
//            }
//            catch { }
//            busSocket = null;
//            MainPage.Log("Socket关闭");
//        }

//        /// <summary>
//        /// 当前的Socket是否运行
//        /// </summary>
//        public bool IsRunning
//        {
//            get
//            {
//                return null == busSocket ? false : true;
//            }
//        }

//        /// <summary>
//        /// 开始异步接收数据
//        /// </summary>
//        private void asyncBeginReceive()
//        {
//            if (!IsRunning)
//            {
//                return;
//            }
//            if(busSocket == null)
//            {
//                return;
//            }

//            try {
//                Packet packet = new Packet ();
//                busSocket.BeginReceiveFrom (packet.Bytes, 0, packet.Bytes.Length, SocketFlags.None, ref packet.RemoteEndPoint, new AsyncCallback (asyncEndReceive), packet);
//            } 
//            catch (Exception e) {
//                System.Threading.Thread.Sleep (1);
//                Console.WriteLine("asyncBeginReceive " + relinkCount    );
//                if (relinkCount == 0)
//                {
//                    relinkCount = 1;
//                    asyncBeginReceive();
//                }
//                Console.WriteLine($"asyncBeginReceive {e.Message}");
//            } 
//        }
//        /// <summary>
//        /// 重连次数
//        /// </summary>
//        private int relinkCount = 0;



//        /// <summary>
//        /// 异步接收数据结束
//        /// </summary>
//        /// <param name="iar"></param>
//        private void asyncEndReceive(IAsyncResult iar)
//        {
//            if (!IsRunning)
//            {
//                return;
//            }
//            try
//            {
//                if (busSocket == null)
//                {
//                    return;
//                }
//                asyncBeginReceive();
//                Packet packet = (Packet)iar.AsyncState;
//                int len = busSocket.EndReceiveFrom(iar, ref packet.RemoteEndPoint);

//                byte[] bytes = packet.Bytes;
//                packet.Bytes = new byte[len];
//                Array.Copy(bytes, 0, packet.Bytes, 0, packet.Bytes.Length);

//                //MainPage.Log($"接收{packet.RemoteEndPoint}数据");
//                //mqtt连接数据读取  A协议网络设备信息读取回复 处理
//                if (((IPEndPoint)packet.RemoteEndPoint).Port == 8585)
//                {
//                    Control.Ins.ConvertReceiveData(bytes, ((IPEndPoint)packet.RemoteEndPoint).Address.ToString());
//                }
//                else if (((IPEndPoint)packet.RemoteEndPoint).Port == 6000)//处理bus 6000端口的数据
//                {
//                    packet.Manager();
//                }

//            }
//            catch (Exception ex)
//            {
//                MainPage.Log($"异步接收数据结束 {ex.Message},{((Packet)iar.AsyncState).Bytes}");
//            }
//        }

//        /// <summary>
//        /// 异步发送数据
//        /// </summary>
//        /// <param name="tempPacket"></param>
//        public void AsyncBeginSend(Packet tempPacket)
//        {
//            try
//            {
//                if (!IsRunning)
//                {
//                    tempPacket.HaveSendCount++;
//                    return;
//                }
//                tempPacket.FlagDateTime = System.DateTime.Now;
//                tempPacket.HaveSendCount++;
//                busSocket.BeginSendTo(tempPacket.Bytes, 0, tempPacket.Bytes.Length, SocketFlags.None, tempPacket.RemoteEndPoint, new AsyncCallback(asyncEndSend), tempPacket);
//            }
//            catch (Exception ex)
//            {
//                MainPage.Log($"AsyncBeginSend error {ex.Message}");
//            }
//        }

//        /// <summary>
//        /// 异步发送数据结束
//        /// </summary>
//        /// <param name="iar"></param>
//        private void asyncEndSend(IAsyncResult iar)
//        {
//            Packet tempUDPPacketBuffer = (Packet)iar.AsyncState;
//            try
//            {
//                int bytesSent = busSocket.EndSendTo(iar);
//            }
//            catch {

//            }
//        }
//    }
//}

using System;
using System.Net.Sockets;
using System.Net;

@@ -8,16 +226,16 @@
    {
        static UdpSocket _busSocket;
        public static UdpSocket _BusSocket
        {
            get
            {
                if(_busSocket == null)
                {
        {
            get
            {
                if (_busSocket == null)
                {
                    _busSocket = new UdpSocket();
                }
                }
                return _busSocket;
            }
        }
            }
        }

        //本地Socket
        private Socket busSocket;
@@ -25,53 +243,55 @@
        /// <summary>
        /// 启动Socket接收和发送功能
        /// </summary>
        public void Start (int port = 0)
        {
        public void Start(int port = 0)
        {
            if (IsRunning)
            {
                if (port == Port)
                {
                    return;
                {
                    return;
                }
                else
                {
                    busSocket.Close();
                else
                {
                    busSocket.Close();
                }
            }
            }
            if (port != 0)
                Port = port;
            if (Port == 0)
                return;

            busSocket = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
            busSocket.EnableBroadcast = true;
            try {
            busSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
            busSocket.EnableBroadcast = true;
            try
            {
                busSocket.Bind(new IPEndPoint(IPAddress.Any, Port));

                busSocket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.AddMembership, new MulticastOption(IPAddress.Parse("239.0.168.188")));
                relinkCount = 0;
            }
            catch (Exception ex){
                MainPage.Log ($"udp port bind error : {ex.Message}");
            catch (Exception ex)
            {
                MainPage.Log($"udp port bind error : {ex.Message}");

                busSocket = null;
                return;
            }
                return;
            }

            asyncBeginReceive();
            asyncBeginReceive();

            MainPage.Log ($"udp port : {port}");
        }
            MainPage.Log($"udp port : {port}");
        }

        /// <summary>
        /// 停止Socket
        /// </summary>
        public void Stop()
        {
            if(busSocket == null)
            {
            if (busSocket == null)
            {
                return;
            }
            }
            if (!IsRunning)
            {
                return;
@@ -97,6 +317,8 @@
            }
        }

        byte []receiveBytes = new byte[2000];

        /// <summary>
        /// 开始异步接收数据
        /// </summary>
@@ -106,29 +328,35 @@
            {
                return;
            }
            if(busSocket == null)
            {
            if (busSocket == null)
            {
                return;
            }
            }

            try {
                Packet packet = new Packet ();
                busSocket.BeginReceiveFrom (packet.Bytes, 0, packet.Bytes.Length, SocketFlags.None, ref packet.RemoteEndPoint, new AsyncCallback (asyncEndReceive), packet);
            } 
            catch (Exception e) {
                System.Threading.Thread.Sleep (1);
                Console.WriteLine("asyncBeginReceive " + relinkCount    );
            try
            {
                int len = busSocket.Receive(receiveBytes, SocketFlags.None);
			    
                Packet packet = new Packet(len);

                System.Array.Copy(receiveBytes, packet.Bytes, len);
                packet.Manager();
            }
            catch (Exception e)
            {
                System.Threading.Thread.Sleep(1);
                Console.WriteLine("asyncBeginReceive " + relinkCount);
                if (relinkCount == 0)
                {
                    relinkCount = 1;
                    asyncBeginReceive();
                }
                Console.WriteLine($"asyncBeginReceive {e.Message}");
            } 
                Console.WriteLine($"asyncBeginReceive {e.Message}");
            }
        }
        /// <summary>
        /// 重连次数
        /// </summary>
        /// 重连次数
        /// </summary>
        private int relinkCount = 0;


@@ -209,9 +437,11 @@
            {
                int bytesSent = busSocket.EndSendTo(iar);
            }
            catch {
            
            }
            catch
            {

            }
        }
    }
}
}


 HDL_ON/DAL/Server/HttpServerRequest.cs

@@ -710,7 +710,7 @@
                            if (mHomeGatewayRes.Count > 0)
                            {
                                DB_ResidenceData.Instance.HomeGateway = mHomeGatewayRes[0];//网关状态
                                DriverLayer.Control.Ins.GatewayOnline_Cloud = mHomeGatewayRes[0].gatewayStatus;
                                HDL_ON.DriverLayer.Control.Ins.GatewayOnline_Cloud = mHomeGatewayRes[0].gatewayStatus;
                                DB_ResidenceData.Instance.SaveResidenceData();
                                return revertObj.Code;
                            }
@@ -776,7 +776,7 @@
                var mHomeGatewayRes = Newtonsoft.Json.JsonConvert.DeserializeObject<HomeGatewayInfo>(revertObj.Data.ToString());
                if (mHomeGatewayRes != null)
                {
                    DriverLayer.Control.Ins.GatewayOnline_Cloud = mHomeGatewayRes.gatewayStatus;
                    HDL_ON.DriverLayer.Control.Ins.GatewayOnline_Cloud = mHomeGatewayRes.gatewayStatus;
                }
            }
            return revertObj.Code;

 HDL_ON/Entity/Function/Function.cs

@@ -2306,7 +2306,7 @@
        /// <summary>
        /// 红外热水器
        /// </summary>
        public const string HeaterIr = " ir.water_heater";
        public const string HeaterIr = "ir.water_heater";
        /// <summary>
        /// 红外风扇
        /// </summary>

 HDL_ON/UI/UI2/3-Intelligence/Automation/ConditionDeviceFunList.cs

@@ -1311,27 +1311,30 @@
                         if (indexeList.Count > 0)
                         {
                             dicSateteList.Clear();
                             string s = string.Empty;
                             string userNameStr = string.Empty;
                             string seleUsrIdStr = string.Empty;  
                             string tag = string.Empty;
                             //数据封装
                             string[] arrayUserIds = new string[indexeList.Count];
                             //开门类型
                             AddDictionary("open_type", "1", "integer");
                             for (int i = 0; i < indexeList.Count; i++)
                             {

                                 if (i > faceIdList.Count)
                                 {
                                     continue;
                                 }
                                 var indexe = indexeList[i];
                                 var face = faceIdList[indexe];
                                 AddDictionary("user_id", face.userId, "string");
                                 s += face.userName;
                                 s += ",";
                                 tag += face.userId;
                                 tag += "_";
                                 userNameStr += face.userName;
                                 userNameStr += ",";
                                 arrayUserIds[i] = face.userId;
                             }
                             seleUsrIdStr = Newtonsoft.Json.JsonConvert.SerializeObject(arrayUserIds);
                             AddDictionary("user_id", seleUsrIdStr, "string", "[]");
                             //界面显示选中值
                             btnState.Text = s;
                             btnState.Text = InpOrOutLogicMethod.Current.RemoveLastStr(userNameStr);
                             btnState.Tag = tag;
                         }


 HDL_ON/UI/UI2/3-Intelligence/Automation/InpOrOutLogicMethod.cs

@@ -436,30 +436,43 @@
                                    break;
                                case SPK.doorgate:
                                    {
                                        string s = string.Empty;
                                        if (inputCondition.identifier == "door_call_cloud_event")
                                        {
                                            s = Language.StringByID(StringId.shipintonghuahujiao);
                                        }
                                        else
                                        {
                                            for (int b = 0; b < dicList.Count; b++)
                                            {
                                                var dic = dicList[b];
                                                var key = dic["key"].ToString();
                                                if (key != "user_id")
                                                {
                                                    continue;
                                                }
                                                var userId = dic["value"].ToString();
                                                var FaceItem = this.GetFaceItem(userId, device.deviceId);
                                                s += FaceItem.userName;
                                                s += ",";

                                        string s = string.Empty;
                                        try
                                        {
                                            if (inputCondition.identifier == "door_call_cloud_event")
                                            {
                                                s = Language.StringByID(StringId.shipintonghuahujiao);
                                            }
                                            else
                                            {
                                                for (int b = 0; b < dicList.Count; b++)
                                                {
                                                    var dic = dicList[b];
                                                    var key = dic["key"].ToString();
                                                    if (key != "user_id")
                                                    {
                                                        continue;
                                                    }
                                                    var value = dic["value"].ToString();
                                                    if (!string.IsNullOrEmpty(value))
                                                    {
                                                        var list = Newtonsoft.Json.JsonConvert.DeserializeObject<List<string>>(value);
                                                        for (int a = 0; a < list.Count; a++)
                                                        {

                                                            var FaceItem = this.GetFaceItem(list[a], device.deviceId);
                                                            s += FaceItem.userName;
                                                            s += ",";

                                                        }
                                                    }

                                                }

                                            }

                                        }
                                        catch { }
                                        inputView.btnState.Text = s;
                                    }
                                    break;
@@ -1506,17 +1519,32 @@
                                case SPK.MusicStandard:
                                case SPK.AvMusic:
                                    {
                                        string on_off = GetKeyValue("on_off", dicList);
                                        string song_name = GetKeyValue("song_name", dicList);
                                        string volume = GetKeyValue("volume", dicList);
                                        stateStr = song_name + ";" + Language.StringByID(StringId.volumeMusic) + volume;
                                        if (stateStr.StartsWith(";"))

                                        if (!string.IsNullOrEmpty(on_off))
                                        {
                                            stateStr = stateStr.Substring(1, stateStr.Length - 1);
                                            if (on_off == "on")
                                            {
                                                stateStr = Language.StringByID(StringId.onLogic);
                                            }
                                            else
                                            {
                                                stateStr = Language.StringByID(StringId.offLogic);
                                            }
                                        }
                                        else if (stateStr.EndsWith(Language.StringByID(StringId.volumeMusic)))

                                        if (!string.IsNullOrEmpty(song_name))
                                        {
                                            stateStr = stateStr.Substring(0, stateStr.Length - 3);
                                            stateStr += "," + song_name;
                                        }

                                        if (!string.IsNullOrEmpty(volume))
                                        {
                                            stateStr += "," + volume;
                                        }

                                    }
                                    break;
                                case SPK.ElectricalTvHisense:
@@ -2303,7 +2331,7 @@
                        foreach (var dic in dicList)
                        {
                            string value = dic["value"];
                            if (value == "on"|| value == "open")
                            if (value == "on" || value == "open")
                            {
                                button1.Text = Language.StringByID(StringId.onLogic);
                            }
@@ -2494,38 +2522,61 @@
                    {
                        foreach (var dic in dicList)
                        {
                            if (dic["key"] == "song_name")
                            if (dic["key"] == "on_off")
                            {
                                button1.Text = dic["value"]?.ToString();
                                if (dic["value"] == "on")
                                {
                                    button1.Text = Language.StringByID(StringId.onLogic);
                                }
                                else
                                {
                                    button1.Text = Language.StringByID(StringId.offLogic);
                                }
                            }
                            else if (dic["key"] == "song_name")
                            {
                                button2.Text = dic["value"]?.ToString();
                            }
                            else if (dic["key"] == "volume")
                            {
                                button2.Text = dic["value"]?.ToString();
                                button3.Text = dic["value"]?.ToString();
                            }
                        }
                    }
                    break;
                case SPK.doorgate:
                    {
                        string s = string.Empty;
                        string tag = string.Empty;
                        for (int b = 0; b < dicList.Count; b++)
                        try
                        {
                            var dic = dicList[b];
                            var key = dic["key"].ToString();
                            if (key != "user_id")
                            string userNameStr = string.Empty; 
                            string tag = string.Empty;
                            for (int b = 0; b < dicList.Count; b++)
                            {
                                continue;
                                var dic = dicList[b];
                                var key = dic["key"].ToString();
                                if (key != "user_id")
                                {
                                    continue;
                                }
                                var value = dic["value"].ToString();
                                if (!string.IsNullOrEmpty(value))
                                {
                                    var list = Newtonsoft.Json.JsonConvert.DeserializeObject<List<string>>(value);
                                    for (int i = 0; i < list.Count; i++)
                                    {

                                        var FaceItem = this.GetFaceItem(list[i], device.deviceId);
                                        userNameStr += FaceItem.userName;
                                        userNameStr += ",";
                                        tag += FaceItem.userId;
                                        tag += "_";
                                    }
                                }
                            }
                            var userId = dic["value"].ToString();
                            var FaceItem = this.GetFaceItem(userId, device.deviceId);
                            s += FaceItem.userName;
                            s += ",";
                            tag += FaceItem.userId;
                            tag += "_";
                            button2.Text = RemoveLastStr(userNameStr);
                            button2.Tag = tag;
                        }
                        button2.Text = s;
                        button2.Tag = tag;
                        catch { }
                    }
                    break;
                case SPK.ElectricalTvHisense:

 HDL_ON/UI/UI2/3-Intelligence/Automation/Logic.cs

@@ -109,7 +109,7 @@
        /// <summary>
        /// 检测类型 配合condition_type=3时使用,没有该字段、该值或0: 状态检测(每次收到状态就成立),1:动作检测(需要切换状态才成立);
        /// </summary>
        public string detect_type = "0"; 
        public string detect_type = "1"; 
        /// <summary>
        /// 人体移动传感器（带持续时间）
        /// </summary>

 HDL_ON/UI/UI2/3-Intelligence/Automation/TargetDeviceFunList.cs

@@ -736,8 +736,13 @@
                case SPK.AvMusic:
                    {
                        #region 界面
                        ///开关
                        LogicView.FunTypeView switchVie = new LogicView.FunTypeView();
                        switchVie.btnText.TextID = StringId.switchLogic;
                        fLayout.AddChidren(switchVie.FLayoutView());
                        //提示语音
                        LogicView.FunTypeView funTypeView = new LogicView.FunTypeView();
                        funTypeView.frameLayout.Y = switchVie.frameLayout.Bottom;
                        funTypeView.btnText.TextID = StringId.tishiyin;
                        fLayout.AddChidren(funTypeView.FLayoutView());
                        ///音量
@@ -757,6 +762,12 @@
                        DelayView(fLayout, volView.frameLayout.Bottom);
                        #endregion
                        #region 点击事件
                        ///开关点击事件
                        switchVie.btnClick.MouseUpEventHandler += (sender, e) =>
                        {

                            SwitchViewMethod(device, switchVie.btnState, 2);
                        };
                        ///提示语音点击事件
                        funTypeView.btnClick.MouseUpEventHandler += (sender, e) =>
                        {
@@ -820,7 +831,7 @@
                        if (edit)
                        {
                            //显示编辑之前的设备状态
                            GetEditDeviceState(device, index, funTypeView.btnState, volView.btnState, null, null);
                            GetEditDeviceState(device, index, switchVie.btnState, funTypeView.btnState, volView.btnState, null);
                        }

                        #endregion

 HDL_ON/UI/UI2/4-PersonalCenter/PersonalDataPage.cs

@@ -242,7 +242,7 @@

            if (MainPage.Increase)
            {
                bodyScrolView.Height = Application.GetRealHeight(541);
                bodyScrolView.Height = Application.GetRealHeight(541-10);
            }

            headPortraitView = new FrameLayout()
@@ -858,16 +858,9 @@

            #endregion

            bodyView.AddChidren(new Button()
            {
                Y = Application.GetRealHeight(622),
                Height = 1,
                BackgroundColor = CSS_Color.DividingLineColor,
            });

            btnLogout = new Button()
            {
                Y = Application.GetRealHeight(623),
                Y = Application.GetRealHeight(624),
                Height = Application.GetRealHeight(50),
                TextAlignment = TextAlignment.Center,
                TextSize = CSS_FontSize.SubheadingFontSize,