CanReadNotificationEvent.cs

using NeuroAccessMaui.Resources.Languages;
using NeuroAccessMaui.Services.Contacts;
using NeuroAccessMaui.UI.Pages.Things.CanRead;
using Waher.Networking.XMPP;
using Waher.Networking.XMPP.Provisioning;
using Waher.Networking.XMPP.Sensor;
using Waher.Persistence;
using Waher.Things;
using Waher.Things.SensorData;
 
namespace NeuroAccessMaui.Services.Notification.Things
{
    public class CanReadNotificationEvent : ThingNotificationEvent
    {
        public CanReadNotificationEvent()
            : base()
        {
        }
 
        public CanReadNotificationEvent(CanReadEventArgs e)
            : base(e)
        {
            this.Fields = e.Fields;
            this.FieldTypes = e.FieldTypes;
        }
 
        public string[]? Fields { get; set; }
 
        public string[]? AllFields { get; set; }
 
        public FieldType FieldTypes { get; set; }
 
        public override async Task<string> GetDescription()
        {
            string ThingName = await ContactInfo.GetFriendlyName(this.BareJid, this.SourceId ?? string.Empty,
                this.PartitionId ?? string.Empty, this.NodeId ?? string.Empty);
 
            string RemoteName = await ContactInfo.GetFriendlyName(this.RemoteJid);
 
            return ServiceRef.Localizer[nameof(AppResources.ReadoutRequestText), RemoteName, ThingName];
        }
 
        public override async Task Open()
        {
            string ThingName = await ContactInfo.GetFriendlyName(this.BareJid);
            string RemoteName = await ContactInfo.GetFriendlyName(this.RemoteJid);
 
            await ServiceRef.UiService.GoToAsync(nameof(CanReadPage), new CanReadNavigationArgs(this, ThingName, RemoteName));
        }
 
        public override async Task Prepare()
        {
            await base.Prepare();
 
            string[]? Fields = await GetAvailableFieldNames(this.BareJid, new ThingReference(this.NodeId, this.SourceId, this.PartitionId));
 
            if (Fields is not null)
            {
                this.AllFields = Fields;
                await Database.Update(this);
            }
        }
 
        public static async Task<string[]?> GetAvailableFieldNames(string BareJid, ThingReference Thing)
        {
            try
            {
                RosterItem? Item = ServiceRef.XmppService.GetRosterItem(BareJid);
                if (Item is null || !Item.HasLastPresence || !Item.LastPresence.IsOnline)
                    return null;
 
                SortedDictionary<string, bool> Fields = [];
                SensorDataClientRequest Request = ServiceRef.XmppService.RequestSensorReadout(Item.LastPresenceFullJid, [ Thing ], FieldType.All);
                TaskCompletionSource<bool> Done = new();
 
                Request.OnFieldsReceived += (sender, NewFields) =>
                {
                    foreach (Field Field in NewFields)
                        Fields[Field.Name] = true;
 
                    return Task.CompletedTask;
                };
 
                Request.OnStateChanged += (Sender, NewState) =>
                {
                    switch (NewState)
                    {
                        case SensorDataReadoutState.Done:
                            Done.TrySetResult(true);
                            break;
 
                        case SensorDataReadoutState.Cancelled:
                        case SensorDataReadoutState.Failure:
                            Done.TrySetResult(false);
                            break;
                    }
 
                    return Task.CompletedTask;
                };
 
                Task _ = Task.Delay(30000).ContinueWith((_) => Done.TrySetResult(false));
 
                if (await Done.Task)
                {
                    string[] Fields2 = new string[Fields.Count];
                    Fields.Keys.CopyTo(Fields2, 0);
 
                    return Fields2;
                }
                else
                    return null;
            }
            catch (Exception)
            {
                return null;
            }
        }
 
    }
}