PacDrive.cs

Go to the documentation of this file.

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


namespace DirectOutput.Cab.Out.Pac
{
    public class PacDrive : OutputControllerBase, IOutputController
    {

        #region IOutputcontroller implementation
        public override void Update()
        {
            PacDriveInstance.TriggerPacDriveUpdaterThread();
        }


        public override void Init(Cabinet Cabinet)
        {
            AddOutputs();
            PacDriveInstance.Init(Cabinet);
            Log.Write("PacDrive initialized and updater thread started.");

        }

        public override void Finish()
        {
            PacDriveInstance.Finish();
            PacDriveInstance.ShutdownLighting();
            Log.Write("PacDrive finished and updater thread stopped.");

        }
        #endregion



        #region Outputs


        private void AddOutputs()
        {
            for (int i = 1; i <= 16; i++)
            {
                if (!Outputs.Any(x => x.Number == i))
                {
                    Outputs.Add(new Output() { Name = "{0}.{1:00}".Build(Name, i), Number = i });
                }
            }
        }




        protected override void OnOutputValueChanged(IOutput Output)
        {

            if (!(Output is IOutput))
            {
                throw new Exception("The OutputValueChanged event handler for the PacDrive uni has been called by a sender which is not a OutputNumbered.");
            }
            IOutput ON = Output;

            if (!ON.Number.IsBetween(1, 64))
            {
                throw new Exception("PacDrive output numbers must be in the range of 1-16. The supplied output number {0} is out of range.".Build(ON.Number));
            }

            PacDriveInstance.UpdateValue(ON);
        }



        #endregion









        //~PacDrive()
        //{
        //    Dispose(false);
        //}

        //#region Dispose



        //public void Dispose()
        //{

        //    Dispose(true);
        //    GC.SuppressFinalize(this); // remove this from gc finalizer list
        //}
        //protected virtual void Dispose(bool disposing)
        //{
        //    // Check to see if Dispose has already been called.
        //    if (!this.disposed)
        //    {
        //        // If disposing equals true, dispose all managed
        //        // and unmanaged resources.
        //        if (disposing)
        //        {
        //            // Dispose managed resources.

        //        }

        //        // Call the appropriate methods to clean up
        //        // unmanaged resources here.
        //        // If disposing is false,
        //        // only the following code is executed.

        //        TerminatePacDrive();


        //        // Note disposing has been done.
        //        disposed = true;

        //    }
        //}
        //private bool disposed = false;

        //#endregion



        #region Constructor


        static PacDrive()
        {
            PacDriveInstance = new PacDriveUnit();
        }

        public PacDrive()
        {
            Outputs = new OutputList();
            Name = "PacDrive";
        }




        #endregion






        #region Internal class for PacDrive output states and update methods

        private static PacDriveUnit PacDriveInstance=null;

        private class PacDriveUnit
        {
            //private Pinball Pinball;

           

            private const int MaxUpdateFailCount = 5;

            private PacDriveSingleton PDSingleton;

            private ushort NewValue;
            private ushort CurrentValue;
            private bool UpdateRequired = true;

            private int Index = -1;

            public object PacDriveUpdateLocker = new object();
            public object ValueChangeLocker = new object();

            public Thread PacDriveUpdater;
            public bool KeepPacDriveUpdaterAlive = false;
            public object PacDriveUpdaterThreadLocker = new object();


            public void Init(Cabinet Cabinet)
            {
                //this.Pinball = Cabinet.Pinball;
                //if (!Pinball.TimeSpanStatistics.Contains("PacDrive update calls"))
                //{
                //    UpdateTimeStatistics = new TimeSpanStatisticsItem() { Name = "PacDrive update calls", GroupName = "OutputControllers - PacDrive" };
                //    Pinball.TimeSpanStatistics.Add(UpdateTimeStatistics);
                //}
                //else
                //{
                //    UpdateTimeStatistics = Pinball.TimeSpanStatistics["PacDrive update calls"];
                //}

                StartPacDriveUpdaterThread();
            }

            public void Finish()
            {

                TerminatePacDriveUpdaterThread();
                ShutdownLighting();
        

            }

            public void UpdateValue(IOutput Output)
            {
                //Skip update on output numbers which are out of range
                if (!Output.Number.IsBetween(1, 16)) return;

                int ZeroBasedOutputNumber = Output.Number - 1;
                ushort Mask = (ushort)(1 << ZeroBasedOutputNumber);
                lock (ValueChangeLocker)
                {
                    if (Output.Value != 0)
                    {
                        NewValue |= Mask;
                    }
                    else
                    {
                        NewValue &= (ushort)~Mask;
                    }
                    UpdateRequired = true;
                }

            }
            private void CopyNewToCurrent()
            {
                lock (ValueChangeLocker)
                {
                    CurrentValue = NewValue;

                }
            }

            public bool IsUpdaterThreadAlive
            {
                get
                {
                    if (PacDriveUpdater != null)
                    {
                        return PacDriveUpdater.IsAlive;
                    }
                    return false;
                }
            }

            public void StartPacDriveUpdaterThread()
            {
                lock (PacDriveUpdaterThreadLocker)
                {
                    if (!IsUpdaterThreadAlive)
                    {
                        KeepPacDriveUpdaterAlive = true;
                        PacDriveUpdater = new Thread(PacDriveUpdaterDoIt);
                        PacDriveUpdater.Name = "PacDrive updater thread";
                        PacDriveUpdater.Start();
                    }
                }
            }
            public void TerminatePacDriveUpdaterThread()
            {
                lock (PacDriveUpdaterThreadLocker)
                {
                    if (PacDriveUpdater != null)
                    {
                        try
                        {
                            KeepPacDriveUpdaterAlive = false;
                            TriggerPacDriveUpdaterThread();
                            if (!PacDriveUpdater.Join(1000))
                            {
                                PacDriveUpdater.Abort();
                            }

                        }
                        catch (Exception E)
                        {
                            Log.Exception("A error occurd during termination of {0}.".Build(PacDriveUpdater.Name), E);
                            throw new Exception("A error occurd during termination of {0}.".Build(PacDriveUpdater.Name), E);
                        }
                        PacDriveUpdater = null;
                    }
                }
            }

            bool TriggerUpdate = false;
            public void TriggerPacDriveUpdaterThread()
            {
                if (!UpdateRequired) return;
                TriggerUpdate = true;
                UpdateRequired = false;
                lock (PacDriveUpdaterThreadLocker)
                {
                    Monitor.Pulse(PacDriveUpdaterThreadLocker);
                }
            }


            //TODO: Check if thread should really terminate on failed updates
            private void PacDriveUpdaterDoIt()
            {
                //Pinball.ThreadInfoList.HeartBeat("PacDrive");


                int FailCnt = 0;
                while (KeepPacDriveUpdaterAlive)
                {
                    try
                    {
                        if (IsPresent)
                        {
                          
                            SendPacDriveUpdate();
                     
                        }
                        FailCnt = 0;
                    }
                    catch (Exception E)
                    {
                        Log.Exception("A error occured when updating PacDrive", E);
                        //Pinball.ThreadInfoList.RecordException(E);
                        FailCnt++;

                        if (FailCnt > MaxUpdateFailCount)
                        {
                            Log.Exception("More than {0} consecutive updates failed for PacDrive. Updater thread will terminate.".Build(MaxUpdateFailCount));
                            KeepPacDriveUpdaterAlive = false;
                        }
                    }
                    //Pinball.ThreadInfoList.HeartBeat();
                    if (KeepPacDriveUpdaterAlive)
                    {
                        lock (PacDriveUpdaterThreadLocker)
                        {
                            while (!TriggerUpdate && KeepPacDriveUpdaterAlive)
                            {
                                Monitor.Wait(PacDriveUpdaterThreadLocker, 50);  // Lock is released while we’re waiting
                                //Pinball.ThreadInfoList.HeartBeat();
                            }

                        }

                    }
                    TriggerUpdate = false;
                }

                ShutdownLighting();

                //Pinball.ThreadInfoList.ThreadTerminates();
            }



            private bool ForceFullUpdate = true;
            private void SendPacDriveUpdate()
            {
                if (IsPresent)
                {

                    lock (PacDriveUpdateLocker)
                    {
                        lock (ValueChangeLocker)
                        {
                            if (NewValue == CurrentValue && !ForceFullUpdate) return;

                            CopyNewToCurrent();

                        }


                        PDSingleton.PacDriveUHIDSetLEDStates(Index, CurrentValue);

                    }
                    ForceFullUpdate = false;
                }
                else
                {
                    ForceFullUpdate = true;
                }
            }


            public void ShutdownLighting()
            {
                lock (PacDriveUpdateLocker)
                {
                    lock (ValueChangeLocker)
                    {
                        CurrentValue = 0;
                        NewValue = 0;

                        PDSingleton.PacDriveUHIDSetLEDStates(Index, 0);
                    }
                }
            }



            private bool IsPresent
            {
                get
                {
                    return Index >= 0;
                }
            }


            void Instance_OnPacRemoved(int Index)
            {
                this.Index = PDSingleton.PacDriveGetIndex();
            }

            void Instance_OnPacAttached(int Index)
            {
                this.Index = PDSingleton.PacDriveGetIndex();
                InitUnit();
                TriggerPacDriveUpdaterThread();
            }

            private void InitUnit()
            {
                lock (ValueChangeLocker)
                {
                    NewValue = 0;
                    CurrentValue = 65535;
                };
                SendPacDriveUpdate();
            }


            public PacDriveUnit()
            {
                PDSingleton = PacDriveSingleton.Instance;
                PDSingleton.OnPacAttached += new PacDriveSingleton.PacAttachedDelegate(Instance_OnPacAttached);
                PDSingleton.OnPacRemoved += new PacDriveSingleton.PacRemovedDelegate(Instance_OnPacRemoved);
                this.Index = PacDriveSingleton.Instance.PacDriveGetIndex();
                InitUnit();


            }


        }



        #endregion




    }
}