OutputControllerCompleteBase.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Serialization;
using DirectOutput.General.Generic;
using System.Threading;

namespace DirectOutput.Cab.Out
{
    public abstract class OutputControllerCompleteBase : NamedItemBase, IOutputController, ISupportsSetValues
    {

        byte[] OutputValues = new byte[0];





        protected void SetupOutputs()
        {
            int NumberOfOutputs = GetNumberOfConfiguredOutputs().Limit(0, int.MaxValue);
            if (Outputs == null)
            {
                Outputs = new OutputList();
            }

            Outputs.Where(O => O.Number > NumberOfOutputs).ToList().ForEach(ODEL => Outputs.Remove(ODEL));

            for (int i = 1; i <= NumberOfOutputs; i++)
            {
                if (!Outputs.Any(O => O.Number == i))
                {
                    Outputs.Add(new Output() { Name = "{0}.{1}".Build((Name != null ? Name : ""), i), Number = i, Value = 0 });
                }
            }


            OutputValues = Outputs.OrderBy(O => O.Number).Select(O => O.Value).ToArray();
        }

        private void RenameOutputs()
        {
            if (Outputs != null)
            {
                foreach (IOutput O in Outputs)
                {
                    O.Name = "{0}.{1}".Build((Name != null ? Name : ""), O.Name);
                }
            }
        }

        protected override void AfterNameChange(string OldName, string NewName)
        {
            RenameOutputs();
            base.AfterNameChange(OldName, NewName);
        }


        private OutputList _Outputs = null;
        [XmlIgnore]
        public OutputList Outputs
        {
            get { return _Outputs; }
            set
            {
                if (_Outputs != null)
                {
                    _Outputs.OutputValueChanged -= new OutputList.OutputValueChangedEventHandler(Outputs_OutputValueChanged);
                }

                _Outputs = value;

                if (_Outputs != null)
                {
                    _Outputs.OutputValueChanged += new OutputList.OutputValueChangedEventHandler(Outputs_OutputValueChanged);

                }

            }
        }

        private void Outputs_OutputValueChanged(object sender, OutputEventArgs e)
        {
            OnOutputValueChanged(e.Output);
        }

        private void OnOutputValueChanged(IOutput Output)
        {
            if (Output.Number > 0 && Output.Number <= OutputValues.Length)
            {
                lock (ValueChangeLocker)
                {
                    if (OutputValues[Output.Number - 1] != Output.Value)
                    {
                        OutputValues[Output.Number - 1] = Output.Value;
                        UpdateRequired = true;
                    }

                }
            }
        }



        #region ISupportsSetValues Member

        public void SetValues(int FirstOutput, byte[] Values)
        {
            if (FirstOutput >= OutputValues.Length) return;
            if (FirstOutput < 0) return;
            int CopyLength = (OutputValues.Length - FirstOutput).Limit(0, Values.Length);
            if (CopyLength < 1) return;

            lock (ValueChangeLocker)
            {
                Buffer.BlockCopy(Values, 0, OutputValues, FirstOutput, CopyLength);
                UpdateRequired = true;
            }
        }

        #endregion



        public virtual void Init(Cabinet Cabinet)
        {
            bool V = false;
            try
            {
                V = VerifySettings();
            }
            catch (Exception E)
            {
                string msg = "A exception occured when verifying the settings for {0} {1}: {2}. Cant initialize.".Build(this.GetType().Name, Name, E.Message);
                Log.Exception(msg, E);
                throw new Exception(msg, E);
            }
            if (V)
            {
                SetupOutputs();
                InitUpdaterThread();
                Log.Write("{0} {1} intialized and updater thread started.".Build(this.GetType().Name, Name));
            }
            else
            {
                Log.Warning("Settings for {0} {1} are not correct. Cant initialize.".Build(this.GetType().Name, Name));
            }
        }


        public virtual void Finish()
        {
            FinishUpdaterThread();
            Log.Write("{0} {1} finished and updater thread stopped.".Build(this.GetType().Name, Name));
        }

        public void Update()
        {
            if (UpdateRequired)
            {
                UpdaterThreadSignal();
            }
        }


        protected abstract int GetNumberOfConfiguredOutputs();

        protected abstract bool VerifySettings();

        protected abstract void UpdateOutputs(byte[] OutputValues);



        protected abstract void ConnectToController();


        protected abstract void DisconnectFromController();


        #region UpdaterThread
        private void InitUpdaterThread()
        {

            if (!UpdaterThreadIsActive)
            {
                KeepUpdaterThreadAlive = true;
                try
                {
                    UpdaterThread = new Thread(UpdaterThreadDoIt);
                    UpdaterThread.Name = "{0} {1} updater thread ".Build(this.GetType().Name, Name);
                    UpdaterThread.Start();
                }
                catch (Exception E)
                {
                    Log.Exception("{0} {1}  updater thread could not start.".Build(this.GetType().Name, Name), E);
                    throw new Exception("{0} {1}  updater thread could not start.".Build(this.GetType().Name, Name), E);
                }
            }
        }


        private void FinishUpdaterThread()
        {
            if (UpdaterThread != null)
            {
                try
                {
                    KeepUpdaterThreadAlive = false;
                    UpdaterThreadSignal();
                    if (!UpdaterThread.Join(1000))
                    {
                        UpdaterThread.Abort();
                        Log.Warning("{0} did not quit. Forcing abort.".Build(UpdaterThread.Name));
                    }
                    UpdaterThread = null;
                }
                catch (Exception E)
                {
                    Log.Exception("A error occured during termination of the {0}: {1}.".Build(UpdaterThread.Name), E);
                    throw new Exception("A error occured during termination of the {0}: {1}.".Build(UpdaterThread.Name), E);
                }
            }
        }


        public bool UpdaterThreadIsActive
        {
            get
            {
                if (UpdaterThread != null)
                {
                    if (UpdaterThread.IsAlive)
                    {
                        return true;
                    }
                }
                return false;
            }
        }

        private void UpdaterThreadSignal()
        {
            lock (UpdaterThreadLocker)
            {
                Monitor.Pulse(UpdaterThreadLocker);
            }
        }


        private object ValueChangeLocker = new object();

        private Thread UpdaterThread { get; set; }
        private object UpdaterThreadLocker = new object();
        private bool KeepUpdaterThreadAlive = true;

        private bool UpdateRequired = false;

        private void UpdaterThreadDoIt()
        {
            Log.Write("{0} started.".Build(Thread.CurrentThread.Name));
            try
            {
                try
                {
                    ConnectToController();

                }
                catch (Exception E)
                {
                    Log.Exception("{0} could not connect to the controller. Thread will quit.".Build(Thread.CurrentThread.Name), E);

                    try
                    {
                        DisconnectFromController();
                        return;
                    }
                    catch { }
                }

                Log.Write("{0} has connected to {1} {2}.".Build(Thread.CurrentThread.Name, this.GetType().Name, Name));

                while (KeepUpdaterThreadAlive)
                {
                    byte[] ValuesToSend = new byte[0];
                    lock (ValueChangeLocker)
                    {
                        ValuesToSend = (byte[])OutputValues.Clone();
                    }


                    bool UpdateOK = true;
                    for (int i = 0; i < 1; i++)
                    {

                        try
                        {
                            UpdateOutputs(ValuesToSend);
                        }
                        catch (Exception E)
                        {
                            Log.Exception("{0} could not send update for {1} {2}: {3}. Will try again.".Build(new object[] { Thread.CurrentThread.Name, this.GetType().Name, Name, E.Message }), E);
                            UpdateOK = false;
                        }
                        if (UpdateOK) break;
                    }

                    if (!UpdateOK)
                    {
                        Log.Warning("{0} tries to reconnect to {1} {2}.".Build(Thread.CurrentThread.Name, this.GetType().Name, Name));
                        try
                        {
                            DisconnectFromController();
                        }
                        catch { }
                        Thread.Sleep(100);
                        try
                        {
                            ConnectToController();

                        }
                        catch (Exception E)
                        {
                            Log.Exception("{0} could not reconnect to the controller. Thread will quit.".Build(Thread.CurrentThread.Name), E);

                            try
                            {
                                DisconnectFromController();
                                return;
                            }
                            catch { }
                        }
                        Log.Write("{0} has reconnected to {1} {2}.".Build(Thread.CurrentThread.Name, this.GetType().Name, Name));
                        Thread.Sleep(100);
                        try
                        {
                            UpdateOutputs(ValuesToSend);
                        }
                        catch (Exception E)
                        {
                            Log.Exception("{0} could still not send update for {1} {2}: {3}. Thread will quit.".Build(new object[] { Thread.CurrentThread.Name, this.GetType().Name, Name, E.Message }), E);
                            try
                            {
                                DisconnectFromController();
                                return;
                            }
                            catch { }
                        }

                    }



                    if (KeepUpdaterThreadAlive)
                    {
                        lock (UpdaterThreadLocker)
                        {
                            while (!UpdateRequired && KeepUpdaterThreadAlive)
                            {
                                Monitor.Wait(UpdaterThreadLocker, 50);  // Lock is released while we’re waiting
                            }
                        }

                    }
                    UpdateRequired = false;
                }

                try
                {
                    UpdateOutputs(new byte[OutputValues.Length]);
                }
                catch (Exception E)
                {
                    Log.Exception("A exception occured in {0} while trying to turn of all outputs for {1} {2}".Build(Thread.CurrentThread.Name, this.GetType().Name, Name), E);
                }
                try
                {
                    DisconnectFromController();

                }
                catch {}

                Log.Write("{0} has disconnected from {1} {2} and will terminate.".Build(Thread.CurrentThread.Name, this.GetType().Name, Name));
            }
            catch (Exception EU)
            {
                Log.Exception("A exception has occured in {0}. Thread will quit. Message: {1}".Build(Thread.CurrentThread.Name, EU.Message), EU);
            }


        }

        #endregion


    }
}