HamBook – Diff between revs 48 and 54

Subversion Repositories:

?pathlinks?

Rev 48 – Details – Blame – Last modification – View Log

-using HamBook.Radios.Generic;
-using HamBook.Radios;
 using System;
 using System.Collections.Generic;
+using System.Media;
+using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
-using Serilog;
 using HamBook.Properties;
-using System.Media;
+using HamBook.Radios;
-using System.Reflection;
+using HamBook.Radios.Generic;
 using RJCP.IO.Ports;
+using Serilog;
 namespace HamBook
+{
     public class MemoryTune
+    {
-    {
+        private readonly CatAssemblies _catAssemblies;
+        private readonly Configuration.Configuration _configuration;
-        private CancellationTokenSource _scanningCancellationTokenSource;
+        private readonly MemoryBanks _memoryBanks;
+        private CancellationToken _scanningCancellationToken;
-        private CancellationToken _scanningCancellationToken;
+        private CancellationTokenSource _scanningCancellationTokenSource;
-        private Thread _scanThread;
-        private CatAssemblies _catAssemblies;
+        private Thread _scanThread;
-        private SerialPortStream _serialPort;
-        private Configuration.Configuration _configuration;
-        private MemoryBanks _memoryBanks;
+        private SerialPortStream _serialPort;
         private MemoryTune()
         {
+        }
         public MemoryTune(CatAssemblies catAssemblies, SerialPortStream serialPort,
-        public MemoryTune(CatAssemblies catAssemblies, SerialPortStream serialPort, Configuration.Configuration configuration) : this()
+            Configuration.Configuration configuration) : this()
+        {
         public void Start()
+        {
             if (_scanThread != null)
             {
-                if (!_scanningCancellationToken.IsCancellationRequested)
-                {
-                    _scanningCancellationTokenSource.Cancel();
                 if (!_scanningCancellationToken.IsCancellationRequested) _scanningCancellationTokenSource.Cancel();
                 _scanThread.Join();
                 _scanThread = null;
+            }
             _scanningCancellationTokenSource = new CancellationTokenSource();
             _scanningCancellationToken = _scanningCancellationTokenSource.Token;
-            _scanThread = new Thread(new ParameterizedThreadStart(Tune));
             var memoryBankQueue = new Queue<string>();
-            foreach (var bank in _memoryBanks.GetMemoryBanks())
+            _scanThread = new Thread(Tune);
-                memoryBankQueue.Enqueue(bank);
+            var memoryBankQueue = new Queue<string>();
             foreach (var bank in _memoryBanks.GetMemoryBanks()) memoryBankQueue.Enqueue(bank);
             _scanThread.Start(memoryBankQueue);
-        }
-        public void Stop()
+        }
             if (_scanThread != null)
         public void Stop()
                 if (!_scanningCancellationToken.IsCancellationRequested)
             do
+            {
                 try
-                {
+                {
                     var memoryBank = memoryBankQueue.Dequeue();
                     using (var soundPlayer = new SoundPlayer(Assembly.GetExecutingAssembly()
-                    using (var soundPlayer = new SoundPlayer(Assembly.GetExecutingAssembly().GetManifestResourceStream("HamBook.Effects.pot.wav")))
+                               .GetManifestResourceStream("HamBook.Effects.pot.wav")))
                     {
                         soundPlayer.Play();
-                        if (!await _catAssemblies.CatSetAsync<int, bool>("MC", new object[] { memoryBank }, _scanningCancellationToken))
+                        if (!await _catAssemblies.CatSetAsync<int, bool>("MC", new object[] { memoryBank },
                                 _scanningCancellationToken))
-                            throw new MemoryTuneException(MemoryTuneExceptionCode.CouldNotChangeChannel, Resources.Could_not_change_channel);
+                            throw new MemoryTuneException(MemoryTuneExceptionCode.CouldNotChangeChannel,
-                        }
+                                Resources.Could_not_change_channel);
                     }
-                    if (!await _catAssemblies.CatSetAsync<TunerState, bool>("AC", new object[] { TunerState.TUNER_ON }, _scanningCancellationToken))
+                    if (!await _catAssemblies.CatSetAsync<TunerState, bool>("AC", new object[] { TunerState.TUNER_ON },
                             _scanningCancellationToken))
-                        throw new MemoryTuneException(MemoryTuneExceptionCode.CouldNotEnableTuner, Resources.Could_not_enable_tuner);
+                        throw new MemoryTuneException(MemoryTuneExceptionCode.CouldNotEnableTuner,
                             Resources.Could_not_enable_tuner);
                     do
+                    {
-                    {
+                        await Task.Delay(TimeSpan.FromSeconds(1), _scanningCancellationToken);
-                        await Task.Delay(TimeSpan.FromSeconds(1), _scanningCancellationToken);
-                        try
-                            var tuneState = await _catAssemblies.CatReadAsync<TunerState>("AC", new object[] { }, _scanningCancellationToken);
+                        try
+                        {
-                            if (tuneState == TunerState.TUNER_ON)
+                            var tuneState = await _catAssemblies.CatReadAsync<TunerState>("AC", new object[] { },
                                 _scanningCancellationToken);
-                                break;
-                        }
+                            if (tuneState == TunerState.TUNER_ON) break;
-                        catch (Exception)
+                        }
-                        {
+                        catch (Exception)
-                            // retry
+                        {
                             // retry
+                        }
                     } while (!_scanningCancellationToken.IsCancellationRequested);
-                    if (!await _catAssemblies.CatSetAsync<TunerState, bool>("AC", new object[] { TunerState.TUNING_START }, _scanningCancellationToken))
+                    if (!await _catAssemblies.CatSetAsync<TunerState, bool>("AC",
-                    {
+                            new object[] { TunerState.TUNING_START }, _scanningCancellationToken))
+                        throw new MemoryTuneException(MemoryTuneExceptionCode.CouldNotStartTuning,
-                        throw new MemoryTuneException(MemoryTuneExceptionCode.CouldNotStartTuning, Resources.Could_not_start_tuning);
+                            Resources.Could_not_start_tuning);
-                    }
-                    do
-                        await Task.Delay(TimeSpan.FromSeconds(1), _scanningCancellationToken);
+                    do
+                    {
-                        try
+                        await Task.Delay(TimeSpan.FromSeconds(1), _scanningCancellationToken);
-                            var tuneState = await _catAssemblies.CatReadAsync<TunerState>("AC", new object[] { }, _scanningCancellationToken);
                         try
-                            if (tuneState != TunerState.TUNING_START)
+                        {
-                                break;
+                            var tuneState = await _catAssemblies.CatReadAsync<TunerState>("AC", new object[] { },
                                 _scanningCancellationToken);
-                        catch (Exception)
+                            if (tuneState != TunerState.TUNING_START) break;
+                        }
-                            // retry
+                        catch (Exception)
+                        {
                             // retry
-                    } while (!_scanningCancellationToken.IsCancellationRequested);
+                        }
-                }
-                catch(MemoryTuneException exception)
+                    } while (!_scanningCancellationToken.IsCancellationRequested);
+                }
-                    Log.Error(exception, exception.Message);
+                catch (MemoryTuneException exception)
+                {