DP44/DataPRO/IService/Classes/TDAS Service/TDAS Service.cs

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Threading;
using DTS.Common.Utilities.Logging;
//using DTS.DASLib.Command.SLICE;
using DTS.Common.DASResource;
using DTS.Common.ICommunication;
using DTS.Common.Interface.Connection;
using DTS.Common.Classes.Connection;
using DTS.Common.Interface.DASFactory;

namespace DTS.DASLib.Service
{
    public partial class TDAS<T> : Communication<T>,
                           IDASCommunication,
                           IConfigurationActions,
                           IDiagnosticsActions,
                           ITriggerCheckActions,
                           IRealTimeActions,
                           IArmActions,
                           IDownloadActions where T : IConnection, new()
    {
        public bool IsEthernetDistributor() { return false; }
        public bool IsSlice6Distributor() { return false; }
        public bool IsBattery() { return false; }
        public bool IsTSRAIR() { return false; }
        public bool IsSlice6Air() { return false; }
        public bool IsSlice6AirTc() { return false; }
        public bool IsScheduleEventCountSupported() { return false; }
        public class TDASDownloadServiceAsyncInfo
        {
            public TDASServiceAsyncInfo info { get; set; }
            public TDASServiceSetupInfo setupInfo { get; set; }

            public TDASDownloadServiceAsyncInfo(TDASServiceAsyncInfo _info, object _setupInfo)
            {
                info = _info;
                if (_setupInfo != null)
                {
                    setupInfo = _setupInfo as TDASServiceSetupInfo;
                }
            }
        }

        public class TDASServiceQueryConfigAsyncInfo : TDASServiceAsyncInfo
        {
            public bool ReadIds { get; set; } = true;

            public TDASServiceQueryConfigAsyncInfo(bool bReadIds, ServiceCallback callback, object userData)
                : base(callback, userData)
            {
                ReadIds = bReadIds;
            }
        }
        public class TDASServiceAsyncInfo
        {
            public ServiceCallback callback { get; set; }
            public object userData { get; set; }
            public object functionData { get; set; }

            public TDASServiceAsyncInfo(ServiceCallback _callback, object _userData)
            {
                callback = _callback;
                userData = _userData;
            }

            public void Error(string msg, Exception ex)
            {
                try
                {
                    var cbData = new ServiceCallbackData();
                    cbData.Status = ServiceCallbackData.CallbackStatus.Failure;
                    cbData.ErrorMessage = msg;
                    cbData.ErrorException = ex;
                    cbData.UserData = userData;
                    callback(cbData);
                }
                catch (Exception eex)
                {
                    APILogger.Log("MessageBox", Strings.TDASAsyncInfoError, eex);
                }
            }

            public void Error(string msg)
            {
                Error(msg, null);
            }

            public void Progress(int value)
            {
                try
                {
                    var progressData = new ServiceCallbackData();
                    progressData.Status = ServiceCallbackData.CallbackStatus.ProgressReport;
                    progressData.ProgressValue = value;
                    progressData.UserData = userData;
                    callback(progressData);
                }
                catch (Exception ex)
                {
                    APILogger.Log("MessageBox", Strings.TDASAsyncInfoProgressError, ex);
                }
            }
            public void NewData(object obj)
            {
                if (obj is ServiceCallbackData.DiagnosticNewData)
                {
                    var progressData = new ServiceCallbackData();
                    progressData.Status = ServiceCallbackData.CallbackStatus.NewData;
                    progressData.ProgressValue = 0;
                    progressData.UserData = userData;
                    progressData.SetNewDiagnosticData((obj as ServiceCallbackData.DiagnosticNewData));
                    callback(progressData);
                }
                else
                {
                    var newdatadata = obj as NewDataData;
                    var datas = newdatadata.datas;
                    var samplenumbers = newdatadata.SampleNumbers;
                    var timeStamps = newdatadata.TimeStamps;
                    var sequenceNumbers = newdatadata.SequenceNumbers;
                    try
                    {
                        var progressData = new ServiceCallbackData();
                        progressData.Status = ServiceCallbackData.CallbackStatus.NewData;
                        progressData.ProgressValue = 0;
                        progressData.UserData = userData;
                        for (var i = 0; i < datas.Length && i < samplenumbers.Length; i++)
                        {
                            progressData.AddSampleData(datas[i], samplenumbers[i], timeStamps[i], sequenceNumbers[i]);
                        }
                        callback(progressData);
                    }
                    catch (Exception ex)
                    {
                        APILogger.Log("MessageBox", Strings.SLICEAsyncInfoNewDataError, ex);
                    }
                }
            }
            public void NewData(IList<short[][]> datas, IList<ulong> samplenumbers, IList<ulong> timeStamps, IList<ulong> sequenceNumbers)
            {
                try
                {
                    var progressData = new ServiceCallbackData();
                    progressData.Status = ServiceCallbackData.CallbackStatus.NewData;
                    progressData.ProgressValue = 0;
                    progressData.UserData = userData;
                    for (var i = 0; i < datas.Count && i < samplenumbers.Count; i++)
                    {
                        progressData.AddSampleData(datas[i], samplenumbers[i], timeStamps[i], 0);
                    }
                    callback(progressData);
                }
                catch (Exception ex)
                {
                    APILogger.Log("MessageBox", Strings.TDASAsyncInfoNewDataError, ex);
                }
            }
            public void NewData(short[][] data, ulong samplenumber, ulong timeStamp, ulong sequenceNumber)
            {
                try
                {
                    var progressData = new ServiceCallbackData();
                    progressData.Status = ServiceCallbackData.CallbackStatus.NewData;
                    progressData.ProgressValue = 0;
                    progressData.UserData = userData;
                    progressData.AddSampleData(data, samplenumber, timeStamp, sequenceNumber);
                    callback(progressData);
                }
                catch (Exception ex)
                {
                    APILogger.Log("MessageBox", Strings.TDASAsyncInfoNewDataError, ex);
                }
            }

            public void Success()
            {
                try
                {
                    var success = new ServiceCallbackData();
                    success.Status = ServiceCallbackData.CallbackStatus.Success;
                    success.UserData = userData;
                    callback(success);
                }
                catch (Exception ex)
                {
                    APILogger.Log("MessageBox", Strings.TDASAsyncInfoSuccessError, ex);
                }
            }

            public void Cancel()
            {
                try
                {
                    var cancelReport = new ServiceCallbackData();
                    cancelReport.Status = ServiceCallbackData.CallbackStatus.Canceled;
                    cancelReport.ProgressValue = 0;
                    cancelReport.UserData = userData;
                    callback(cancelReport);
                }
                catch (Exception ex)
                {
                    APILogger.Log("MessageBox", Strings.TDASAsyncInfoCancelError, ex);
                }
            }
        }

        private void LaunchAsyncWorker(string Invoker, WaitCallback cb, object asyncInfo)
        {
            if (!Connected)
            {
                // "{0}: Not currently connected"
                throw new NotConnectedException(string.Format(Strings.Slice_LaunchAsyncWorker_Err1, Invoker));
            }

            if (!ThreadPool.QueueUserWorkItem(cb, asyncInfo))
            {
                // "{0}: Unable to enqueue function"
                throw new Exception(string.Format(Strings.Slice_LaunchAsyncWorker_Err2, Invoker));
            }
        }

        private void CallSyncMethod(string Invoker, WaitCallback cb, object info)
        {
            if (!Connected)
            {
                // "{0}: Not currently connected"
                throw new NotConnectedException(string.Format(Strings.Slice_LaunchAsyncWorker_Err1, Invoker));
            }
            cb(info);
        }

        /// <summary>
        /// compare to an object to determine equality
        /// </summary>
        /// <param name="right"></param>
        /// <returns></returns>
        public override bool Equals(object right)
        {

            if (right == null)
                return false;

            if (ReferenceEquals(this, right))
                return true;

            if (!(right is TDAS<T> rightSlice))
            {
                return false;
            }

            if (string.IsNullOrEmpty(SerialNumber))
            {
                return string.IsNullOrEmpty(rightSlice.SerialNumber);
            }
            if (string.IsNullOrEmpty(rightSlice.SerialNumber))
                return false;
            return SerialNumber == rightSlice.SerialNumber;
        }
        /// <summary>
        /// returns identical index for any two 'equal' slice
        /// </summary>
        /// <returns></returns>
        public override int GetHashCode()
        {
            if (string.IsNullOrEmpty(SerialNumber))
                return 0;
            return SerialNumber.GetHashCode();
        }
    }
}