BlowingScanServiceClient.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using FObjBase;
using FLY.Thick.BlowingScan.OBJ_INTERFACE;
using FLY.Thick.BlowingScan.IService;
using Misc;
using FLY.Thick.Blowing.Client;
using Newtonsoft.Json;

namespace FLY.Thick.BlowingScan.Client
{
    /// <summary>
    /// 
    /// </summary>
    public class BlowingScanServiceClient : BlowingServiceClient, IBlowingScanService
    {
        /// <summary>
        /// 
        /// </summary>
        public BlowingScanServiceClient(UInt32 serverid):base(serverid)
        {
        }
        #region IRenZiJiaScanService
        private int solvecnt = 4;
        /// <summary>
        /// 解方程数
        /// </summary>
        public int SolveCnt
        {
            get { return solvecnt; }
            set
            {
                if (value < 3)
                    value = 3;

                if (solvecnt != value)
                {
                    solvecnt = value;
                }
            }
        }

        private int sensorwidth = 250;
        /// <summary>
        /// 探头宽度，用于解方程，可以与实际不符合 单位脉冲
        /// </summary>
        public int SensorWidth
        {
            get { return sensorwidth; }
            set
            {
                if (value < 1)
                    value = 1;

                if (sensorwidth != value)
                {
                    sensorwidth = value;
                }
            }
        }

        private int smooth = 1;
        /// <summary>
        /// 平滑
        /// </summary>
        public int Smooth
        {
            get { return smooth; }
            set
            {
                if (value < 0)
                    value = 0;
                if (smooth != value)
                {
                    smooth = value;
                }
            }
        }

        /// <summary>
        /// 缓冲区第一个记录序号
        /// </summary>
        public int FirstBM { get; set; } = -1;
        /// <summary>
        /// 缓冲区最后一个记录序号
        /// </summary>
        public int LastBM { get; set; } = -1;
        #endregion

        #region 下载进度
        public bool IsDownloading { get; private set; }
        public int TotalSize { get; private set; }
        public int CurrentSize { get; private set; }
        #endregion
        public override void ConnectNotify(IFConn from)
        {
            base.ConnectNotify(from);

            if (from.IsConnected)
            {
                //获取所有数据，设置推送
                CurrObjSys.GetValueEx(
                    mConn, mServerID, ID,
                    BLOWING_SCAN_OBJ_INTERFACE.GET_PARAMSEXT);

                CurrObjSys.GetValueEx(
                    mConn, mServerID, ID,
                    BLOWING_SCAN_OBJ_INTERFACE.GET_BUFINFO);
            }
        }
        public override void PushGetValue(IFConn from, uint srcid, ushort memid, byte[] infodata)
        {
            base.PushGetValue(from, srcid, memid, infodata);

            switch (memid)
            {
                case BLOWING_SCAN_OBJ_INTERFACE.GET_PARAMSEXT:
                    {
                        string json = Misc.Converter.BytesToString(infodata);
                        var p = JsonConvert.DeserializeObject<BLOWING_SCAN_OBJ_INTERFACE.Pack_ParamsExt>(json);
                        
                        SolveCnt = p.solveCnt;
                        SensorWidth = p.sensorWidth;
                        Smooth = p.smooth;
                    }
                    break;
                case BLOWING_SCAN_OBJ_INTERFACE.GET_BUFINFO:
                    {
                        string json = Misc.Converter.BytesToString(infodata);
                        var p = JsonConvert.DeserializeObject<BLOWING_SCAN_OBJ_INTERFACE.Pack_BM>(json);
                        
                        FirstBM = p.firstbm;
                        LastBM = p.lastbm;
                    }
                    break;
            }
        }

        public override void PushCallFunction(IFConn from, uint srcid, uint magic, ushort funcid, byte[] retdata, object AsyncDelegate, object AsyncState)
        {
            switch (funcid)
            {
                case BLOWING_SCAN_OBJ_INTERFACE.CALL_GETBUF:
                    {
                        string json = Misc.Converter.BytesToString(retdata);
                        var p = JsonConvert.DeserializeObject<GetBufListReponse>(json);

                        
                        ((AsyncCBHandler)AsyncDelegate)(AsyncState, p);
                    } break;
            }
        }

        public override void PushCallFunctionBigSizeStatus(IFConn from, uint srcid, uint magic, ushort funcid, int total_size, int download_size, object AsyncState)
        {
            switch (funcid)
            {
                case BLOWING_SCAN_OBJ_INTERFACE.CALL_GETBUF:
                    {
                        
                        TotalSize = total_size;
                        CurrentSize = download_size;
                        if (CurrentSize == TotalSize)
                        {
                            IsDownloading = false;
                        }
                        else
                        {
                            IsDownloading = true;
                        }
                    }
                    break;
            }
        }
        /// <summary>
        /// 参数应用
        /// </summary>
        public override void Apply()
        {
            base.Apply();

            var p = new BLOWING_SCAN_OBJ_INTERFACE.Pack_ParamsExt()
            {
                solveCnt = SolveCnt,
                sensorWidth = SensorWidth,
                smooth = Smooth
            };
            string json = JsonConvert.SerializeObject(p);


            CurrObjSys.SetValueEx(
                mConn, mServerID, ID,
                BLOWING_SCAN_OBJ_INTERFACE.SET_PARAMSEXT,
                Misc.Converter.StringToBytes(json));
        }
        /// <summary>
        /// 获取 缓冲区列表
        /// </summary>
        /// <param name="AsyncDelegate">retdata = GetBufListReponse</param>
        /// <param name="AsyncState"></param>
        public void GetBufList(AsyncCBHandler AsyncDelegate, object AsyncState)
        {
            CurrObjSys.CallFunctionEx(mConn, mServerID, ID,
                BLOWING_SCAN_OBJ_INTERFACE.CALL_GETBUF,
                null,
                AsyncDelegate, AsyncState);
        }
    }
}