public IOPH_EZLinkDongle(ADTRecord adtRec, IAppMainWindow mainWin)
 {
     this._adtRec = adtRec;
     this._mainWin = mainWin;
     this._teleFromWin = new Telegram(0x3e8);
     this._teleToWin = new Telegram(0x3e8);
     this._replyData = new DataBuffer(0x3e8);
     this._isSeries = false;
     this._seriesExecStat = SeriesExecutionState.Stop;
     this._taskEvent = new AutoResetEvent(false);
     this._taskState = TaskState.TaskReady_OK;
     if (adtRec.isUsbEZLinkDevice())
     {
         this._ddi = DDI_EZLinkDongle.instance();
     }
     else if (adtRec.isTESTDevice())
     {
         this._ddi = DDI_TEST.instance();
     }
     else
     {
         GlobalServices.ErrMsg("FATAL ERROR: IOPH_EZLinkDongle", "I/O port type not supported, exit WDS!");
         Application.Exit();
     }
     this._iot = new Thread(new ThreadStart(this.doDeviceIO));
     this._iot.IsBackground = true;
     this._iot.Name = "IOPH_EZLink thread";
     this._isTelegramRequest = false;
     this._isRxTimerRequest = false;
     this._isReadRxPacketEnabled = false;
     this._iot.Start();
 }

 /// <summary>
 /// Create a new progress snapshot.
 /// </summary>
 /// <param name="state">The current State of the task.</param>
 /// <param name="unitsByte"><c>true</c> if <see cref="UnitsProcessed"/> and <see cref="UnitsTotal"/> are measured in bytes; <c>false</c> if they are measured in generic units.</param>
 /// <param name="unitsProcessed">The number of units that have been processed so far.</param>
 /// <param name="unitsTotal">The total number of units that are to be processed; -1 for unknown.</param>
 public TaskSnapshot(TaskState state, bool unitsByte = false, long unitsProcessed = 0, long unitsTotal = -1)
 {
     State = state;
     UnitsByte = unitsByte;
     UnitsProcessed = unitsProcessed;
     UnitsTotal = unitsTotal;
 }

		public override void RequestTaskState(TaskState taskState)
		{
			if (taskState == TaskState.Stopped || taskState == TaskState.Finished || taskState == TaskState.Paused)
			{
				while (true)
				{
					try
					{
						tcpListener.Stop();
						tcpListener.Server.Close();
					}
					catch
					{
					}

					if (base.RequestTaskState(taskState, TimeSpan.FromSeconds(0.5)))
					{
						return;
					}

					if (taskState == TaskState.Stopped || taskState == TaskState.Finished)
					{
						return;
					}
				}
			}

			base.RequestTaskState(taskState);
		}

        internal FlowState(Flow flow)
        {
            this.Tasks = new List<TaskState>();
            this.Art = flow.Art;

            foreach (var task in flow.Nodes)
            {
                TaskState state = new TaskState()
                {
                    ItemsProcessed = task.ItemsProcessed,
                    Name = task.Name,
                    Status = task.Status,
                    TotalSecondsBlocked = task.TotalSecondsBlocked,
                    TotalSecondsProcessing = task.TotalSecondsProcessing,
                    Position = task.Position
                };

                this.Tasks.Add(state);
            }
            this.Streams = new List<StreamState>();
            foreach (var stream in flow.Streams)
            {
                StreamState state = new StreamState()
                {
                    Name = stream.Name,
                    Closed = stream.IsClosed,
                    Count = stream.Count,
                    InPoint = stream.InPoint
                };
                this.Streams.Add(state);
            }
        }

 private TaskState ProcessByState(Task processedTask, TaskState state)
 {
     //Global.Log ("Processing task of sequence (" + ToString () + "): " + processedTask.ToString() + " with state: " + state.ToString());
     switch (state) {
     case TaskState.Ready:
         return ExecuteSubTask (processedTask);
     case TaskState.Running:
         return TaskState.Running;
     case TaskState.Success:
         processedTask.State = TaskState.Ready;
         currentTaskIndex++;
         if (currentTaskIndex >= SubTasks.Count) {
             currentTaskIndex = 0;
             return TaskState.Success;
         }
         return TaskState.Running;
     case TaskState.Failed:
         processedTask.State = TaskState.Ready;
         //setting next task to first sub action
         currentTaskIndex = 0;
         return TaskState.Failed;
     default:
         //unexpected
         return TaskState.Failed;
     }
 }

 internal Task(TaskManager taskManager, IEnumerator<IAsyncCall> callIterator)
 {
     this._waitCall = new AsyncCall<bool>();
     this._taskManager = taskManager;
     this._taskState = TaskState.Unstarted;
     this._asyncCallIterator = callIterator;
 }

 public TaskState(RemoteTask task, TaskState parentState, string message = "Internal Error (xunit runner): No status reported", TaskResult result = TaskResult.Inconclusive)
 {
     Task = task;
     Message = message;
     Result = result;
     ParentState = parentState;
 }

 public BuildData(string header)
 {
     Header = header;
     Info = new ObservableCollection<Message>();
     _state = TaskState.Normal;
     ItemCount = new ObservableCollection<string>();
 }

        public ScheduleTrigger(TaskState state, ITrigger trigger, IDev2TaskService service, ITaskServiceConvertorFactory factory)
        {
            _service = service;
            _factory = factory;
            State = state;
            Trigger = trigger;

        }

        public static IProcessingState GetState(TaskState state)
        {
            if (States.ContainsKey(state))
            {
                return States[state];
            }

            throw new ArgumentOutOfRangeException("state");
        }

        public void SetState(ITaskExecuteClient source, TaskState state, TaskMessage message)
        {
            this._state = state;

            if (this.StateChanged != null)
            {
                this.StateChanged(source, this, message);
            }
        }

        private void NotifyTaskStateChanged(AsyncTask task, TaskState state)
        {
            var stateChangedHandler = TaskStateChanged;
            if (stateChangedHandler == null)
                return; // No event handler, bail.

            var e = new TaskStateChangedEventArgs(task, state);
            stateChangedHandler(this, e);
        }

 internal Task(string name, Guid queueId)
 {
     this.Id = Guid.NewGuid();
     this.QueueId = queueId;
     this.Name = name;
     this.State = TaskState.Queued;
     this.OutstandingDependencies = new HashSet<Guid>();
     this.DependantOn = new HashSet<Guid>();
     this.DependencyTo = new HashSet<Guid>();
 }

        public bool ChangeTaskState(TaskState destinationState)
        {
            bool isSuccess = _database.ChangeTaskState(_targetTask, destinationState);
            if (isSuccess)
            {
                RefreshTaskList();

            }
            return isSuccess;
        }

 public DummyTask(DummyBackend backend, int id, string taskName)
 {
     this.backend = backend;
     this.id = id;
     this.name = taskName;
     this.dueDate = DateTime.MinValue; // No due date specified
     this.completionDate = DateTime.MinValue; // No due date specified
     this.priority = TaskPriority.None;
     this.state = TaskState.Active;
 }

 /// <summary>
 /// Create method constructer parameters
 /// </summary>
 /// <param name="id"></param>
 /// <param name="name"></param>
 /// <param name="description"></param>
 /// <param name="type"></param>
 /// <param name="user"></param>
 /// <param name="state"></param>
 /// <param name="completedPercent"></param>
 public Task(int id, string name, string description, TaskType type, List<User> user, TaskState state, int completedPercent)
 {
     TaskId = id;
     Name = name;
     Description = description;
     Type = type;
     Users = user;
     State = state;
     CompletedPercent = completedPercent;
 }

        public TaskState Tick( Dictionary<string, object> pxActorView )
        {
            bool bHasTask = m_pxRootTask != null;
            if ( bHasTask )
            {
                m_pxRootTask.TickTask( pxActorView );
                m_eStatus = m_pxRootTask.GetCurrentState();

                return m_eStatus;
            }
            return TaskState.eTaskFailed;
        }

	        /// <summary>
            /// 
            /// </summary>
            /// <param name="task"></param>
            public TaskAsyncStateAndImplementationHelper(ITask task)
            {
                this.task = task;
                taskState = TaskState.NotStarted;

                requestedTaskState = TaskState.Unknown;
                this.TaskThread = null;
                this.TaskStateLock = new object();

                TaskStateChanged = null;
                RequestedTaskStateChanged = null;
            }

    public void Initialize(Task _task)
    {
        interfaceB = GameObject.FindGameObjectWithTag("Interface").GetComponent<InterfaceBehaviour>();
        //Debug.Log("prova " + interfaceB.name);
        task = _task;
        if (title.text.Length > maxStringCountTitle)
        {
            title.text = title.text.Substring(0, maxStringCountTitle) + "...";
        }
        else
        {
            title.text = _task.title;
        }

        if (_task.description.Length > maxStringCountDescr)
        {
            description.text = _task.description.Substring(0, maxStringCountDescr) + "...";
        }
        else
        {
            description.text = _task.description;
        }

        state = _task.taskState;
        bitmapNumber.text = _task.number.ToString();
        switch (state)
        {
            case TaskState.New:
                this.GetComponent<Button>().interactable = true;
                maskLock.SetActive(false);
                informationTask.gameObject.SetActive(true);
                stateText.color = InterfaceBehaviour.Orange;
                interfaceB.localizationUtils.AddTranslationText(stateText, "{new_task}");
                break;
            case TaskState.Visited:
                this.GetComponent<Button>().interactable = true;
                maskLock.SetActive(false);
                informationTask.gameObject.SetActive(true);
                stateText.color = InterfaceBehaviour.ClearGreen;
                interfaceB.localizationUtils.AddTranslationText(stateText, "{visited_task}");
                break;
            case TaskState.Locked:
                this.GetComponent<Button>().interactable = false;
                stateText.color = InterfaceBehaviour.Grey;
                interfaceB.localizationUtils.AddTranslationText(stateText, "{locked_task}");
                maskLock.SetActive(true);
                informationTask.gameObject.SetActive(false);
                break;
        }
    }

    private ResmgrNative()
    {
        //初始化本地URL
        #if UNITY_ANDROID && !UNITY_EDITOR
        localurl = Application.streamingAssetsPath;
        //Android 比较特别
        #else
        localurl = "file://" + Application.streamingAssetsPath;
        //此url 在 windows 及 WP IOS  可以使用
        #endif
        cacheurl = System.IO.Path.Combine(Application.persistentDataPath, "vercache");

        sha1 = new System.Security.Cryptography.SHA1Managed();
        taskState = new TaskState();
    }