Display_D_HP/TeamAAS-VM/Core/Scanners/NlsScanner.cs

using Opc.Ua;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Net;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using TeamAAS_VP.Enums;
using TeamAAS_VP.Interfaces;
using TeamAAS_VP.Models;
using TeamAAS_VP.Models.Scanner;
using TouchSocket.Core;
using TouchSocket.Sockets;

namespace TeamAAS_VP.Core.Scanners
{
    public class NlsScanner : IScanner, INotifyPropertyChanged
    {
        private IWaitingClient<ITcpClient, IReceiverResult> WaitClient;
        private IWaitingClient<ITcpSessionClient, IReceiverResult> WaitClientServer;
        //private bool isFirstConnect=true;
        private Task bgConnectTask;
        public event Action<Guid, object, ConnectedEventArgs> ConnectedEvent;
        public event Action<Guid, object, ClosedEventArgs> DisconnectedEvent;
        public event Action<Guid, object, ReceivedDataEventArgs> ReceivedEvent;
        public event Action<Guid, object, string> SendEvent;

        public NlsScanner(ScannerInfo scanner)
        {
            Id = scanner.Id;
            Name = scanner.ScannerName;
            ScannerNo = scanner.ScannerNo;
            ScannerIp = scanner.IP;
            ScannerPort = scanner.Port;
            ConnectType = scanner.ConnectType;
            Terminator = scanner.Terminator;
            DataEncoding = scanner.DataEncoding;
            //Brand = scanner.ScannerBrand;
            if (ConnectType == TCPConnectType.Client)
            {
                TcpClient = new TouchSocket.Sockets.TcpClient();
                var config = new TouchSocketConfig();
                config.SetRemoteIPHost(new IPHost(IPAddress.Parse(ScannerIp), ScannerPort));
                config.ConfigurePlugins(a => { a.UseTcpReconnection(); });       ////如需永远尝试连接，tryCount设置为-1即可。
                ////设置结束符
                if (Terminator == Terminator.None)
                {
                    config.SetTcpDataHandlingAdapter(() => { return new NormalDataHandlingAdapter(); });       ////亦或者省略\r\n，但此时调用方不能高速调用，会粘包
                }
                else if (Terminator == Terminator.CR)
                {
                    config.SetTcpDataHandlingAdapter(() => { return new TerminatorPackageAdapter("\r"); });       //命令行中使用\r结尾 
                }
                else if (Terminator == Terminator.LF)
                {
                    config.SetTcpDataHandlingAdapter(() => { return new TerminatorPackageAdapter("\n"); });       //命令行中使用\n结尾 
                }
                else if (Terminator == Terminator.CRLF)
                {
                    config.SetTcpDataHandlingAdapter(() => { return new TerminatorPackageAdapter("\r\n"); });       //命令行中使用\r\n结尾 
                }
                //载入配置
                TcpClient.Setup(config);
                ////调用CreateWaitingClient获取到IWaitingClient的对象。
                WaitClient = TcpClient.CreateWaitingClient(new WaitingOptions()
                {
                    FilterFunc = response => //设置用于筛选的fun委托，当返回为true时，才会响应返回
                    {
                        return true;

                        //if (response.Data.Length == 1)
                        //{
                        //    return true;
                        //}
                        //return false;
                    }
                });

                TcpClient.Connected = ConnectedVoid;//成功连接到服务器
                //有客户端断开连接
                TcpClient.Closed = DisconnectedVoid;
                //从客户端收到信息
                TcpClient.Received = ReceivedVoid;
            }
            else
            {
                TcpService = new TcpService();

                var config = new TouchSocketConfig();
                config.SetListenIPHosts(new IPHost[] { new IPHost($"{ScannerIp}:{ScannerPort}"), new IPHost(ScannerPort + 1) }); //同时监听两个地址
                ////设置结束符
                if (Terminator == Terminator.None)
                {
                    config.SetTcpDataHandlingAdapter(() => { return new NormalDataHandlingAdapter(); });       ////亦或者省略\r\n，但此时调用方不能高速调用，会粘包
                }
                else if (Terminator == Terminator.CR)
                {
                    config.SetTcpDataHandlingAdapter(() => { return new TerminatorPackageAdapter("\r"); });       //命令行中使用\r结尾 
                }
                else if (Terminator == Terminator.LF)
                {
                    config.SetTcpDataHandlingAdapter(() => { return new TerminatorPackageAdapter("\n"); });       //命令行中使用\n结尾 
                }
                else if (Terminator == Terminator.CRLF)
                {
                    config.SetTcpDataHandlingAdapter(() => { return new TerminatorPackageAdapter("\r\n"); });       //命令行中使用\r\n结尾 
                }
                //载入配置
                TcpService.Setup(config);

                /////有客户端成功连接
                TcpService.Connected = ConnectedVoid;
                //有客户端断开连接
                TcpService.Closed = DisconnectedVoid;
                //从客户端收到信息
                TcpService.Received = ReceivedVoid;

            }
        }

        #region 属性
        public TcpClient TcpClient { get; private set; }

        public TcpService TcpService { get; private set; }

        public Guid Id { get; set; }

        public string Name { get; set; }

        /// <summary>
        /// 扫码枪编号
        /// </summary>
        public int ScannerNo { get; set; }

        public int ScannerPort { get; private set; }
        public string ScannerIp { get; private set; }

        public TCPConnectType ConnectType { get; private set; }

        public Terminator Terminator { get; private set; }

        public DataEncoding DataEncoding { get; private set; }

        public bool IsConnected
        {
            get
            {
                if (ConnectType == TCPConnectType.Client)
                {
                    return TcpClient.Online;
                }
                else
                {
                    if (TcpService.Count > 0)
                        return true;
                    else return false;
                }
            }
        }

        public int Timeout { get; set; } = 5000;

        private bool _CanExecute = false;

        public bool CanExecute
        {
            get { return _CanExecute; }
            set { SetProperty(ref _CanExecute, value); }
        }

        public int SelectedTool { get; private set; } = 0;

        public ScannerBrand Brand { get; private set; }

        /// <summary>
        /// 进入调试模式
        /// </summary>
        /// <returns></returns>
        public bool EnterDebugMode { get; set; }

        private RPoint _CurrentPosition = new RPoint();
        /// <summary>
        /// 当前位置
        /// </summary>
        public RPoint CurrentPosition
        {
            get { return _CurrentPosition; }
            set { SetProperty(ref _CurrentPosition, value); }
        }
        #endregion

        #region 事件接收
        //-----------------------------------------------服务器---------------------------------------------
        /// <summary>
        /// 有客户端成功连接
        /// </summary>
        /// <param name="client"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        private Task ConnectedVoid(ITcpSessionClient client, ConnectedEventArgs e)
        {
            CanExecute = true;
            //调用CreateWaitingClient获取到IWaitingClient的对象。
            WaitClientServer = client.CreateWaitingClient(new WaitingOptions()
            {
                FilterFunc = response => //设置用于筛选的fun委托，当返回为true时，才会响应返回
                {
                    return true;

                    //if (response.Data.Length == 1)
                    //{
                    //    return true;
                    //}
                    //return false;
                }
            });
            ConnectedEvent?.Invoke(this.Id, client, e);
            return EasyTask.CompletedTask;
        }
        /// <summary>
        /// 有客户端断开连接
        /// </summary>
        /// <param name="client"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        private Task DisconnectedVoid(ITcpSessionClient client, ClosedEventArgs e)
        {
            if (TcpService.Count < 1)
            {
                CanExecute = false;
            }
            DisconnectedEvent?.Invoke(this.Id, client, e);
            if (WaitClientServer != null)
            {
                if (WaitClientServer.Client.Id == client.Id)
                {
                    if (TcpService.Count > 0)
                    {
                        WaitClientServer = ((ITcpSessionClient)(TcpService.Clients.First())).CreateWaitingClient(new WaitingOptions()
                        {
                            FilterFunc = response => //设置用于筛选的fun委托，当返回为true时，才会响应返回
                            {
                                return true;

                                //if (response.Data.Length == 1)
                                //{
                                //    return true;
                                //}
                                //return false;
                            }
                        });
                    }
                }
            }
            return EasyTask.CompletedTask;
        }
        /// <summary>
        /// 从客户端收到信息
        /// </summary>
        /// <param name="client"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        private Task ReceivedVoid(ITcpSessionClient client, ReceivedDataEventArgs e)
        {
            ReceivedEvent?.Invoke(this.Id, client, e);
            //调用CreateWaitingClient获取到IWaitingClient的对象。
            WaitClientServer = client.CreateWaitingClient(new WaitingOptions()
            {
                FilterFunc = response => //设置用于筛选的fun委托，当返回为true时，才会响应返回
                {
                    return true;

                    //if (response.Data.Length == 1)
                    //{
                    //    return true;
                    //}
                    //return false;
                }
            });
            return EasyTask.CompletedTask;
        }

        //---------------------------------------------客户端--------------------------------------------
        /// <summary>
        /// 连接到服务器时
        /// </summary>
        /// <param name="client"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        private Task ConnectedVoid(ITcpClient client, ConnectedEventArgs e)
        {
            CanExecute = true;
            ConnectedEvent?.Invoke(this.Id, client, e);
            return EasyTask.CompletedTask;
        }

        /// <summary>
        /// 有客户端断开连接
        /// </summary>
        /// <param name="client"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        private Task DisconnectedVoid(ITcpClient client, ClosedEventArgs e)
        {
            CanExecute = false;
            DisconnectedEvent?.Invoke(this.Id, client, e);
            return EasyTask.CompletedTask;
        }
        /// <summary>
        /// 从客户端收到信息
        /// </summary>
        /// <param name="client"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        private Task ReceivedVoid(ITcpClient client, ReceivedDataEventArgs e)
        {
            ReceivedEvent?.Invoke(this.Id, client, e);
            return EasyTask.CompletedTask;
        }
        #endregion

        #region 连接
        public void Connect()
        {
            if (ConnectType == TCPConnectType.Client)
            {
                try
                {
                    TcpClient.Connect();
                    //isFirstConnect = false;
                }
                catch (Exception)
                {
                    if (bgConnectTask == null)
                    {
                        bgConnectTask = Task.Run(async () =>
                        {
                            while (true)
                            {
                                try
                                {
                                    TcpClient.Connect();
                                    //isFirstConnect = false;
                                    return;
                                }
                                catch (Exception)
                                {
                                    await Task.Delay(1000);
                                }
                            }
                        });
                    }
                    throw;
                }
            }
            else
            {
                TcpService.Start();
            }
        }

        public async Task ConnectAsync()
        {
            if (ConnectType == TCPConnectType.Client)
            {
                try
                {
                    await TcpClient.ConnectAsync();
                    //isFirstConnect = false;
                }
                catch (Exception)
                {
                    if (bgConnectTask == null)
                    {
                        bgConnectTask = Task.Run(async () =>
                        {
                            while (true)
                            {
                                try
                                {
                                    TcpClient.Connect();
                                    //isFirstConnect = false;
                                    return;
                                }
                                catch (Exception)
                                {
                                    await Task.Delay(1000);
                                }
                            }
                        });
                    }
                    throw;
                }
            }
            else
            {
                await TcpService.StartAsync();
            }
        }

        public void Disconnect()
        {
            if (TcpClient != null)
            {
                TcpClient.Close();
            }
            if (TcpService != null)
            {
                TcpService.Stop();
            }
        }

        public void Dispose()
        {
            if (TcpClient != null)
            {
                TcpClient.Dispose();
            }
            if (TcpService != null)
            {
                TcpService.Dispose();
            }
        }
        #endregion

       

        #region 收发数据
        /// <summary>
        /// 发送并接收数据
        /// </summary>
        /// <param name="send"></param>
        /// <returns></returns>
        public string SendAndReceive(string send)
        {
            if (ConnectType == TCPConnectType.Client)
            {
                Encoding encoding = GetEncoding();
                SendEvent?.Invoke(this.Id, WaitClient.Client, send);
                var returnData = WaitClient.SendThenReturn(encoding.GetBytes(send), Timeout);
                ReceivedDataEventArgs receivedDataEvent = new ReceivedDataEventArgs(new ByteBlock(returnData), null);
                ReceivedEvent?.Invoke(this.Id, WaitClient, receivedDataEvent);
                return encoding.GetString(returnData);
            }
            else
            {
                Encoding encoding = GetEncoding();
                SendEvent?.Invoke(this.Id, WaitClientServer.Client, send);
                var returnData = WaitClientServer.SendThenReturn(encoding.GetBytes(send), Timeout);
                ReceivedDataEventArgs receivedDataEvent = new ReceivedDataEventArgs(new ByteBlock(returnData), null);
                ReceivedEvent?.Invoke(this.Id, WaitClientServer.Client, receivedDataEvent);
                return encoding.GetString(returnData);
            }
        }

        /// <summary>
        /// 发送并接收数据
        /// </summary>
        /// <param name="send"></param>
        /// <returns></returns>
        public async Task<string> SendAndReceiveAsync(string send)
        {
            if (ConnectType == TCPConnectType.Client)
            {
                Encoding encoding = GetEncoding();
                SendEvent?.Invoke(this.Id, WaitClient.Client, send);
                var returnData = await WaitClient.SendThenReturnAsync(encoding.GetBytes(send), Timeout);
                ReceivedDataEventArgs receivedDataEvent = new ReceivedDataEventArgs(new ByteBlock(returnData), null);
                ReceivedEvent?.Invoke(this.Id, WaitClient, receivedDataEvent);
                return encoding.GetString(returnData);
            }
            else
            {
                Encoding encoding = GetEncoding();
                SendEvent?.Invoke(this.Id, WaitClientServer.Client, send);
                var returnData = await WaitClientServer.SendThenReturnAsync(encoding.GetBytes(send), Timeout);
                ReceivedDataEventArgs receivedDataEvent = new ReceivedDataEventArgs(new ByteBlock(returnData), null);
                ReceivedEvent?.Invoke(this.Id, WaitClientServer.Client, receivedDataEvent);
                return encoding.GetString(returnData);
            }
        }

        /// <summary>
        /// 发送并接收数据
        /// </summary>
        /// <param name="send"></param>
        /// <returns></returns>
        public string SendAndReceive(ITcpSessionClient client, string send)
        {
            if (ConnectType == TCPConnectType.Client)
            {
                Encoding encoding = GetEncoding();
                SendEvent?.Invoke(this.Id, WaitClient.Client, send);
                var returnData = WaitClient.SendThenReturn(encoding.GetBytes(send), Timeout);
                ReceivedDataEventArgs receivedDataEvent = new ReceivedDataEventArgs(new ByteBlock(returnData), null);
                ReceivedEvent?.Invoke(this.Id, WaitClient, receivedDataEvent);
                return encoding.GetString(returnData);
            }
            else
            {
                //调用CreateWaitingClient获取到IWaitingClient的对象。
                var waitClientServer = client.CreateWaitingClient(new WaitingOptions()
                {
                    FilterFunc = response => //设置用于筛选的fun委托，当返回为true时，才会响应返回
                    {
                        return true;

                        //if (response.Data.Length == 1)
                        //{
                        //    return true;
                        //}
                        //return false;
                    }
                });
                Encoding encoding = GetEncoding();
                SendEvent?.Invoke(this.Id, WaitClientServer.Client, send);
                var returnData = waitClientServer.SendThenReturn(encoding.GetBytes(send), Timeout);
                ReceivedDataEventArgs receivedDataEvent = new ReceivedDataEventArgs(new ByteBlock(returnData), null);
                ReceivedEvent?.Invoke(this.Id, WaitClientServer.Client, receivedDataEvent);
                return encoding.GetString(returnData);
            }
        }

        /// <summary>
        /// 发送并接收数据
        /// </summary>
        /// <param name="send"></param>
        /// <returns></returns>
        public async Task<string> SendAndReceiveAsync(ITcpSessionClient client, string send)
        {
            if (ConnectType == TCPConnectType.Client)
            {
                Encoding encoding = GetEncoding();
                SendEvent?.Invoke(this.Id, WaitClient.Client, send);
                var returnData = await WaitClient.SendThenReturnAsync(encoding.GetBytes(send), Timeout);
                ReceivedDataEventArgs receivedDataEvent = new ReceivedDataEventArgs(new ByteBlock(returnData), null);
                ReceivedEvent?.Invoke(this.Id, WaitClient, receivedDataEvent);
                return encoding.GetString(returnData);
            }
            else
            {
                //调用CreateWaitingClient获取到IWaitingClient的对象。
                var waitClientServer = client.CreateWaitingClient(new WaitingOptions()
                {
                    FilterFunc = response => //设置用于筛选的fun委托，当返回为true时，才会响应返回
                    {
                        return true;

                        //if (response.Data.Length == 1)
                        //{
                        //    return true;
                        //}
                        //return false;
                    }
                });
                Encoding encoding = GetEncoding();
                SendEvent?.Invoke(this.Id, WaitClientServer.Client, send);
                var returnData = await waitClientServer.SendThenReturnAsync(encoding.GetBytes(send), Timeout);
                ReceivedDataEventArgs receivedDataEvent = new ReceivedDataEventArgs(new ByteBlock(returnData), null);
                ReceivedEvent?.Invoke(this.Id, WaitClientServer.Client, receivedDataEvent);
                return encoding.GetString(returnData);
            }
        }

        public void Send(string send)
        {
            if (ConnectType == TCPConnectType.Client)
            {
                Encoding encoding = GetEncoding();
                SendEvent?.Invoke(this.Id, TcpClient, send);
                TcpClient.Send(encoding.GetBytes(send));
            }
            else
            {
                Encoding encoding = GetEncoding();
                SendEvent?.Invoke(this.Id, WaitClientServer.Client, send);
                TcpService.Send(WaitClientServer.Client.Id, encoding.GetBytes(send));
            }
        }

        public async Task SendAsync(string send)
        {
            if (ConnectType == TCPConnectType.Client)
            {
                Encoding encoding = GetEncoding();
                SendEvent?.Invoke(this.Id, TcpClient, send);
                await TcpClient.SendAsync(encoding.GetBytes(send));
            }
            else
            {
                Encoding encoding = GetEncoding();
                SendEvent?.Invoke(this.Id, WaitClientServer.Client, send);
                await TcpService.SendAsync(WaitClientServer.Client.Id, encoding.GetBytes(send));
            }
        }

        public void Send(ITcpSessionClient client, string send)
        {
            try
            {
                if (ConnectType == TCPConnectType.Client)
                {
                    Encoding encoding = GetEncoding();
                    SendEvent?.Invoke(this.Id, TcpClient, send);
                    TcpClient.Send(encoding.GetBytes(send));
                }
                else
                {
                    Encoding encoding = GetEncoding();
                    SendEvent?.Invoke(this.Id, client, send);
                    TcpService.Send(client.Id, encoding.GetBytes(send));
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("给机器人发送数据时出错", ex);
            }

        }

        public async Task SendAsync(ITcpSessionClient client, string send)
        {
            try
            {
                if (ConnectType == TCPConnectType.Client)
                {
                    Encoding encoding = GetEncoding();
                    SendEvent?.Invoke(this.Id, TcpClient, send);
                    await TcpClient.SendAsync(encoding.GetBytes(send));
                }
                else
                {
                    Encoding encoding = GetEncoding();
                    SendEvent?.Invoke(this.Id, client, send);
                    await TcpService.SendAsync(client.Id, encoding.GetBytes(send));
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("给机器人发送数据时出错", ex);
            }

        }
        /// <summary>
        /// 获取编码
        /// </summary>
        /// <param name="dataEncoding"></param>
        /// <returns></returns>
        public Encoding GetEncoding()
        {
            DataEncoding dataEncoding = this.DataEncoding;
            Encoding encoding;
            if (dataEncoding == DataEncoding.Default)
            {
                encoding = Encoding.Default;
            }
            else if (dataEncoding == DataEncoding.ASCII)
            {
                encoding = Encoding.ASCII;
            }
            else if (dataEncoding == DataEncoding.UTF7)
            {
                encoding = Encoding.UTF7;
            }
            else if (dataEncoding == DataEncoding.UTF8)
            {
                encoding = Encoding.UTF8;
            }
            else if (dataEncoding == DataEncoding.UTF32)
            {
                encoding = Encoding.UTF32;
            }
            else if (dataEncoding == DataEncoding.Unicode)
            {
                encoding = Encoding.Unicode;
            }
            else if (dataEncoding == DataEncoding.BigEndianUnicode)
            {
                encoding = Encoding.BigEndianUnicode;
            }
            else if (dataEncoding == DataEncoding.GB2312)
            {

                encoding = Encoding.GetEncoding("gb2312");
            }
            else
            {
                encoding = Encoding.Default;
            }
            return encoding;
        }
        #endregion

        #region 属性通知
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// Checks if a property already matches a desired value. Sets the property and
        /// notifies listeners only when necessary.
        /// </summary>
        /// <typeparam name="T">Type of the property.</typeparam>
        /// <param name="storage">Reference to a property with both getter and setter.</param>
        /// <param name="value">Desired value for the property.</param>
        /// <param name="propertyName">Name of the property used to notify listeners. This
        /// value is optional and can be provided automatically when invoked from compilers that
        /// support CallerMemberName.</param>
        /// <returns>True if the value was changed, false if the existing value matched the
        /// desired value.</returns>
        protected virtual bool SetProperty<T>(ref T storage, T value, [CallerMemberName] string propertyName = null)
        {
            if (EqualityComparer<T>.Default.Equals(storage, value)) return false;

            storage = value;
            RaisePropertyChanged(propertyName);

            return true;
        }

        /// <summary>
        /// Checks if a property already matches a desired value. Sets the property and
        /// notifies listeners only when necessary.
        /// </summary>
        /// <typeparam name="T">Type of the property.</typeparam>
        /// <param name="storage">Reference to a property with both getter and setter.</param>
        /// <param name="value">Desired value for the property.</param>
        /// <param name="propertyName">Name of the property used to notify listeners. This
        /// value is optional and can be provided automatically when invoked from compilers that
        /// support CallerMemberName.</param>
        /// <param name="onChanged">Action that is called after the property value has been changed.</param>
        /// <returns>True if the value was changed, false if the existing value matched the
        /// desired value.</returns>
        protected virtual bool SetProperty<T>(ref T storage, T value, Action onChanged, [CallerMemberName] string propertyName = null)
        {
            if (EqualityComparer<T>.Default.Equals(storage, value)) return false;

            storage = value;
            onChanged?.Invoke();
            RaisePropertyChanged(propertyName);

            return true;
        }

        /// <summary>
        /// Raises this object's PropertyChanged event.
        /// </summary>
        /// <param name="propertyName">Name of the property used to notify listeners. This
        /// value is optional and can be provided automatically when invoked from compilers
        /// that support <see cref="CallerMemberNameAttribute"/>.</param>
        protected void RaisePropertyChanged([CallerMemberName] string propertyName = null)
        {
            OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
        }

        /// <summary>
        /// Raises this object's PropertyChanged event.
        /// </summary>
        /// <param name="args">The PropertyChangedEventArgs</param>
        protected virtual void OnPropertyChanged(PropertyChangedEventArgs args)
        {
            PropertyChanged?.Invoke(this, args);
        }

        public List<DataValue> GetNodesValue()
        {
            throw new NotImplementedException();
        }
        #endregion
    }
}