ConnectionSensitiveModel.cs

using System;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Networking.XMPP;
 
namespace LegalLab.Models.Network
{
    public class ConnectionSensitiveModel : PersistedModel
    {
        private readonly Property<XmppState> connectionState;
        private readonly Property<bool> connected;
        private NetworkModel networkModel;
 
        public ConnectionSensitiveModel()
        {
            this.connected = new Property<bool>(nameof(this.Connected), false, this);
            this.connectionState = new Property<XmppState>(nameof(this.ConnectionState), XmppState.Offline, this);
        }
 
        public bool Connected => this.connected.Value;
 
        public NetworkModel Network => this.networkModel;
 
        public XmppState ConnectionState
        {
            get => this.connectionState.Value;
            set
            {
                this.connectionState.Value = value;
                this.connected.Value = value == XmppState.Connected;
            }
        }
 
        public override async Task Start()
        {
            await base.Start();
 
            this.networkModel = await MainWindow.InstantiateModel<NetworkModel>();
            this.networkModel.OnStateChanged += this.NetworkModel_OnStateChanged;
 
            MainWindow.UpdateGui(() =>
            {
                this.ConnectionState = this.networkModel.State;
                return Task.CompletedTask;
            });
        }
 
        public override async Task Stop()
        {
            this.networkModel.OnStateChanged -= this.NetworkModel_OnStateChanged;
            await base.Stop();
        }
 
        private Task NetworkModel_OnStateChanged(object Sender, XmppState NewState)
        {
            MainWindow.UpdateGui(async () =>
            {
                try
                {
                    this.ConnectionState = this.networkModel.State;
                    await this.StateChanged(NewState);
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            });
 
            return Task.CompletedTask;
        }
 
        protected virtual async Task StateChanged(XmppState NewState)
        {
            EventHandlerAsync<XmppState> h = this.OnStateChanged;
            if (h is not null)
                await h(this, NewState);
        }
 
        public event EventHandlerAsync<XmppState> OnStateChanged;
    }
}