Simano/Simano/UserControls/MainUserUI.xaml.cs

using Microsoft.Win32;
using Simano.Model;
using Simano.Service;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;

namespace Simano.UserControls
{
    /// <summary>
    /// MainUserUI.xaml 的互動邏輯
    /// </summary>
    public partial class MainUserUI : UserControl
    {
        public MainUserUI()
        {
            InitializeComponent();
            InitUi();
            Loaded += MainUserUI_Loaded;
        }

        private static readonly NLog.Logger Logger = NLog.LogManager.GetCurrentClassLogger();

        private UiStatus _Status;
        private ScrollViewer scrollViewer;

        private UiStatus Status
        {
            get => _Status;
            set => SetStatus(value);
        }

        private void InitUi()
        {
            Status = UiStatus.Disconnected;

            uxConnectBtn.Click += UxConnectBtn_Click;
            uxDisconnectBtn.Click += UxDisconnectBtn_Click;
            uxComportSelector.SelectionChanged += UxComportSelector_SelectionChanged;
            uxFirmwareUpdateBtn.Click += UxFirmwareUpdateBtn_Click;
            uxSelectFirmwareBtn.Click += UxSelectFirmwareBtn_Click;
            SimanoService.Instance.OnLogReceived += SimanoService_OnLogReceived;

            var comList = SimanoService.Instance.GetComportList();
            uxComportSelector.ItemsSource = comList;

            var recordedPortName = AppSettingConfig.Instance.PortName;
            if (comList.Contains(recordedPortName))
            {
                uxComportSelector.SelectedItem = recordedPortName;
            }

            var recordedFirmwarePath = AppSettingConfig.Instance.FirmwarePath;
            uxFirmwarelocationText.Text = recordedFirmwarePath;
        }

        private void MainUserUI_Loaded(object sender, RoutedEventArgs e)
        {
            GetScroller();
        }

        private void SimanoService_OnLogReceived(object sender, string e)
        {
            Dispatcher.InvokeAsync(new Action(() =>
            {
                //uxConsole.AppendText(e + Environment.NewLine);
                var view = new Run(e + Environment.NewLine);
                uxConsole.Inlines.Add(view);
                scrollViewer?.ScrollToEnd();
                //uxConsole.Text = e + Environment.NewLine;
                Logger.Trace(e);
                Console.WriteLine(e);
            }));
        }

        private void UxSelectFirmwareBtn_Click(object sender, RoutedEventArgs e)
        {
            OpenFileDialog openFileDialog = new OpenFileDialog();
            var success = openFileDialog.ShowDialog();
            if (success != true)
            {
                return;
            }
            var path = openFileDialog.FileName;
            path = Path.GetFullPath(path);
            uxFirmwarelocationText.Text = path;
            AppSettingConfig.Instance.FirmwarePath = path;
        }

        private async void UxFirmwareUpdateBtn_Click(object sender, RoutedEventArgs e)
        {
            if (Status != UiStatus.Connected)
            {
                return;
            }

            var firmwareFile = uxFirmwarelocationText.Text;
            firmwareFile = Path.GetFullPath(firmwareFile);
            if (string.IsNullOrEmpty(firmwareFile) ||
                !File.Exists(firmwareFile))
            {
                MessageBox.Show("Firmware not found!");
                return;
            }

            Status = UiStatus.Busy;
            var result = await SimanoService.Instance.FlashFirmware(firmwareFile);
            if ( result )
            {
                MessageBox.Show("Flash Success");
            }
            else
            {
                MessageBox.Show("Flash Failed");
            }
            Status = UiStatus.Connected;
        }

        private void UxComportSelector_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            AppSettingConfig.Instance.PortName = uxComportSelector.SelectedItem.ToString();
        }

        private void UxDisconnectBtn_Click(object sender, RoutedEventArgs e)
        {
            uxDisconnectBtn.Click -= UxDisconnectBtn_Click;

            Disconnect();

            uxDisconnectBtn.Click += UxDisconnectBtn_Click;
        }

        private void UxConnectBtn_Click(object sender, RoutedEventArgs e)
        {
            uxConnectBtn.Click -= UxConnectBtn_Click;

            Connect();

            uxConnectBtn.Click += UxConnectBtn_Click;
        }

        private async void Connect()
        {
            if (uxComportSelector.SelectedItem is null)
            {
                MessageBox.Show("Comport is not selected");
                Logger.Trace("Comport is not selected");
                return;
            }
            Status = UiStatus.Connecting;
            var connectResult = await SimanoService.Instance.Connect(uxComportSelector.SelectedItem as string);
            if (!connectResult)
            {
                Status = UiStatus.Disconnected;
                MessageBox.Show("Open port failed");
                Logger.Trace("Open port {portname} failed", uxComportSelector.SelectedItem);
                return;
            }
            Status = UiStatus.Connected;
            Logger.Trace("Open port {portname}", uxComportSelector.SelectedItem);
        }

        private void Disconnect()
        {
            var disconnectResult = SimanoService.Instance.Disconnect();
            if (!disconnectResult)
            {
                Status = UiStatus.Connected;
                MessageBox.Show("Close port failed");
                Logger.Trace("Close port failed");
                return;
            }
            Logger.Trace("Close port");
            Status = UiStatus.Disconnected;
        }

        private void GetScroller()
        {
            DependencyObject obj = uxConsoleScroller;

            Queue<DependencyObject> visuals = new Queue<DependencyObject> { };
            do
            {
                for (int index = 0; index < VisualTreeHelper.GetChildrenCount(obj); index ++)
                {
                    visuals.Enqueue(VisualTreeHelper.GetChild(obj as Visual, index));
                }
                obj = visuals.Dequeue();
            }
            while (!(obj is ScrollViewer));

            this.scrollViewer = obj as ScrollViewer;
        }

        private void SetStatus(UiStatus value)
        {
            _Status = value;
            switch (value) {
                case UiStatus.Disconnected:
                    uxConnectBtn.IsEnabled = true;
                    uxDisconnectBtn.IsEnabled = false;
                    uxComportSelector.IsEnabled = true;
                    uxFirmwareUpdateBtn.IsEnabled = false;
                    uxSelectFirmwareBtn.IsEnabled = true;

                    uxConnectedStatusHint.Visibility = Visibility.Collapsed;
                    uxDisconnectedStatusHint.Visibility = Visibility.Visible;
                    uxRunningStatusHint.Visibility = Visibility.Collapsed;
                    break;
                case UiStatus.Connecting:
                    uxConnectBtn.IsEnabled = false;
                    uxDisconnectBtn.IsEnabled = false;
                    uxComportSelector.IsEnabled = false;
                    uxFirmwareUpdateBtn.IsEnabled = false;
                    uxSelectFirmwareBtn.IsEnabled = true;

                    uxConnectedStatusHint.Visibility = Visibility.Collapsed;
                    uxDisconnectedStatusHint.Visibility = Visibility.Visible;
                    uxRunningStatusHint.Visibility = Visibility.Collapsed;
                    break;
                case UiStatus.Connected:
                    uxConnectBtn.IsEnabled = false;
                    uxDisconnectBtn.IsEnabled = true;
                    uxComportSelector.IsEnabled = false;
                    uxFirmwareUpdateBtn.IsEnabled = true;
                    uxSelectFirmwareBtn.IsEnabled = true;

                    uxConnectedStatusHint.Visibility = Visibility.Visible;
                    uxDisconnectedStatusHint.Visibility = Visibility.Collapsed;
                    uxRunningStatusHint.Visibility = Visibility.Collapsed;
                    break;
                case UiStatus.Busy:
                    uxConnectBtn.IsEnabled = false;
                    uxDisconnectBtn.IsEnabled = false;
                    uxComportSelector.IsEnabled = false;
                    uxFirmwareUpdateBtn.IsEnabled = false;
                    uxSelectFirmwareBtn.IsEnabled = false;

                    uxConnectedStatusHint.Visibility = Visibility.Collapsed;
                    uxDisconnectedStatusHint.Visibility = Visibility.Collapsed;
                    uxRunningStatusHint.Visibility = Visibility.Visible;
                    break;
            }

        }
    }
}