ProcessWatchImpl/Bagel/Repeater.cs

using System;
using System.Threading;
using System.Windows.Threading;
using Toast.NicoNico;
using Toast.Twitter;
using dbg = SeedCreate.CommonLibrary.DebugHelper;
using Toast.ProcessControl;

namespace Toast.IsolationLayer
{
        public sealed class Repeater:IDisposable
        {
                private EventHandler<ReceieverStatusChangedEventArgs> receieverStatucChangedEventInvoker;
                private EventHandler<DetectProgramStartEventArgs> programStartedEventInvoker;
                private EventHandler<TwitterWriteFailedEventArgs> twitterWriteFailedEventInvoker;

                private EventHandler detectProcessStartedEventInvoker;
                private EventHandler detectProcessTerminatedEventInvoker;


                private OriginalAlertApiReceiever receiver;
                private TweetController writer;
                private ManualResetEvent threadCatcher;
                private Dispatcher dispatcher;
                private MessageFormatter  formatter;
                private ProcessWatcher watcher;

                private readonly object syncRoot = new object();


                //surrogated event.
                public event EventHandler<ReceieverStatusChangedEventArgs> ReceieverStatusChanged;

                //surrogated event.
                public event EventHandler<DetectProgramStartEventArgs> ProgramStarted;

                //converted from exception event.
                public event EventHandler<TwitterWriteFailedEventArgs> TwitterWriteFailed;

                public event EventHandler DetectWatchProcessStarted;

                public event EventHandler DetectWatchProcessTerminated;

                //Ui side thread incoming.
                public Repeater(Dispatcher dispatcher)
                {
                        if (dispatcher == null)
                        {
                                throw new ArgumentNullException("dispatcher");
                        }

                        dispatcher = dispatcher;

                        receieverStatucChangedEventInvoker = new EventHandler<ReceieverStatusChangedEventArgs>(OnReceieverStatusChanged);
                        programStartedEventInvoker = new EventHandler<DetectProgramStartEventArgs>(OnProgramStarted);
                        twitterWriteFailedEventInvoker = new EventHandler<TwitterWriteFailedEventArgs>(OnTwitterWriteFailed);

                        detectProcessStartedEventInvoker = new EventHandler(OnDetectProcessStarted);
                        detectProcessTerminatedEventInvoker = new EventHandler(OnDetectProcessTerminated);
                }

                //Ui side thread incoming.
                public void Start(uint smileId, string twitterId, string password,string format)
                {
                        Start(smileId, twitterId, password, format, string.Empty, false);
                }

                public void Start(uint smileId, string twitterId, string password, string format, string processName, bool requireWatch)
                {
                        lock (syncRoot)
                        {
                                if (receiver == null)
                                {
                                        if (requireWatch && processName == null)
                                        {
                                                throw new ArgumentNullException("processName");
                                        }

                                        if (twitterId == null)
                                        {
                                                throw new ArgumentNullException("twitterId");
                                        }

                                        if (password == null)
                                        {
                                                throw new ArgumentNullException("password");
                                        }

                                        receiver = new OriginalAlertApiReceiever(smileId);
                                        receiver.ProgramStarted += new EventHandler<DetectProgramStartEventArgs>(Receiver__ProgramStarted);
                                        receiver.StatusChanged += new EventHandler<ReceieverStatusChangedEventArgs>(Receiver__StatusChanged);

                                        writer = new TweetController(twitterId, password);

                                        threadCatcher = new ManualResetEvent(false);

                                        formatter = new MessageFormatter(format == null ? string.Empty : format);

#if !DEBUG_TESTING
                                        if (!requireWatch)
                                        {
                                                receiver.Start();
                                        }
                                        else
                                        {
                                                watcher = new ProcessWatcher();
                                                watcher.DetectProcessStart += new EventHandler(watcher_DetectProcessStart);
                                                watcher.DetectProcessTerminate += new EventHandler(watcher_DetectProcessTerminate);

                                                watcher.Start(4, new TimeSpan(0, 0, 5), processName);
                                        }
#else
                                        receiver.DebugStart();
#endif

                                }
                                else
                                {
                                        throw new InvalidOperationException("Already running");
                                }
                        }


                }


                //Ui side thread incoming.
                public void Stop()
                {
                        lock (syncRoot)
                        {
                                if (receiver != null)
                                {
                                        if (watcher != null)
                                        {
                                                watcher.Dispose();
                                                watcher = null;
                                        }


                                        receiver.Dispose();
                                        receiver = null;

                                        writer = null;
                                        threadCatcher.Close();
                                        threadCatcher = null;
                                }
                        }
                }

                //Ui side thread incoming.
                public bool IsRunning
                {
                        get
                        {
                                lock (syncRoot)
                                {
                                        return receiver != null;
                                }
                        }
                }


                //Logic side threads incoming.
                void watcher_DetectProcessTerminate(object sender, EventArgs e)
                {
                        receiver.Start();
                        dispatcher.Invoke(detectProcessStartedEventInvoker, this, e);
                }


                //Logic side threads incoming.
                void watcher_DetectProcessStart(object sender, EventArgs e)
                {
                        receiver.Stop();
                        dispatcher.Invoke(detectProcessTerminatedEventInvoker, this, e);
                }


                //Logic side threads incoming.
                private void Receiver__StatusChanged(object sender, ReceieverStatusChangedEventArgs e)
                {
                        dispatcher.Invoke(receieverStatucChangedEventInvoker, this, e);
                }

                //Logic side threads incoming.
                private void Receiver__ProgramStarted(object sender, DetectProgramStartEventArgs e)
                {
                        try
                        {
                                writer.PostMessage(formatter.BuildMessage(e.TargetProgram));

                                //Asynchronous
                                dispatcher.BeginInvoke(programStartedEventInvoker, this, e);
                        }
                        catch (Exception ex)
                        {

                                //Independent thread stop llogical process.
                                ThreadPool.QueueUserWorkItem(new WaitCallback(AutomatedStop),ex);


                                try
                                {
                                        Thread.CurrentThread.Abort();
                                }
                                catch (ThreadInterruptedException)
                                {
                                        dbg::TinyDebugWriter.WriteLine("Event process Thread interrupted");
                                }
                        }

                }

                //Embodiment of the stop llogical process.
                private void AutomatedStop(object dummy)
                {
                        Stop();

                        dispatcher.BeginInvoke(twitterWriteFailedEventInvoker, this,
                                new TwitterWriteFailedEventArgs("Some error occured", (Exception)dummy));
                }


                //Ui side thread outgoing.
                private void OnReceieverStatusChanged(object sender, ReceieverStatusChangedEventArgs e)
                {
                        if (ReceieverStatusChanged != null)
                        {
                                ReceieverStatusChanged(sender, e);
                        }
                }

                //Ui side thread outgoing.
                private void OnProgramStarted(object sender, DetectProgramStartEventArgs e)
                {
                        if (ProgramStarted != null)
                        {
                                ProgramStarted(sender, e);
                        }
                }

                //Ui side thread outoging.
                private void OnTwitterWriteFailed(object sender, TwitterWriteFailedEventArgs e)
                {
                        if (TwitterWriteFailed != null)
                        {
                                TwitterWriteFailed(sender, e);
                        }
                }

                //Ui side thread outgoing.
                private void OnDetectProcessStarted(object sender, EventArgs e)
                {
                        if (DetectWatchProcessStarted != null)
                        {
                                DetectWatchProcessStarted(sender, e);
                        }
                }

                //Ui side thread outgoing.
                private void OnDetectProcessTerminated(object sender, EventArgs e)
                {
                        if (DetectWatchProcessTerminated != null)
                        {
                                DetectWatchProcessTerminated(sender, e);
                        }
                }


                #region IDisposable メンバ

                //Must called  by UI side thread.
                public void Dispose()
                {
                        lock (syncRoot)
                        {
                                if (watcher != null)
                                {
                                        watcher.Dispose();
                                }

                                if (receiver != null)
                                {
                                        receiver.Dispose();
                                }

                                if (threadCatcher != null)
                                {
                                        threadCatcher.Close();
                                }
                        }
                }

                #endregion
        }
}