PushTokenRegistrar.cs

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using NeuroAccessMaui.Services.Resilience;
using NeuroAccessMaui.Services;
using NeuroAccessMaui.Services.Xmpp;
using NeuroAccessMaui.UI.MVVM.Policies;
using Waher.Networking.XMPP.Push;
using Waher.Runtime.Settings;
 
namespace NeuroAccessMaui.Services.Push
{
    public sealed class PushTokenRegistrar : IPushTokenRegistrar
    {
        private readonly IXmppService xmppService;
        private const int MaxAttempts = 3;
 
        public PushTokenRegistrar(IXmppService XmppService)
        {
            this.xmppService = XmppService;
        }
 
        public async Task<bool> ReportTokenAsync(TokenInformation TokenInformation, bool ForceReport, CancellationToken CancellationToken)
        {
            CancellationToken.ThrowIfCancellationRequested();
 
            if (!ForceReport && !await ForceTokenReportAsync(TokenInformation))
                return false;
 
            string? Token = TokenInformation.Token;
            if (string.IsNullOrEmpty(Token))
                return false;
 
            IAsyncPolicy RetryPolicy = Policies.Retry(
                MaxAttempts,
                (Attempt, _) => TimeSpan.FromSeconds(Math.Pow(2, Attempt - 1)),
                (Attempt, ex, delay) => ServiceRef.LogService.LogWarning(
                    "Push token registration retry scheduled.",
                    new KeyValuePair<string, object?>("attempt", Attempt),
                    new KeyValuePair<string, object?>("delayMs", delay.TotalMilliseconds),
                    new KeyValuePair<string, object?>("exception", ex.Message)));
 
            try
            {
                await PolicyRunner.RunAsync(
                    async _ =>
                    {
                        await this.xmppService.ReportNewPushNotificationToken(Token, TokenInformation.Service, TokenInformation.ClientType);
                        await RuntimeSettings.SetAsync(Constants.Settings.PushNotificationToken, TokenInformation.Token);
                        await RuntimeSettings.SetAsync(Constants.Settings.PushNotificationReportDate, DateTime.UtcNow);
                    },
                    CancellationToken,
                    RetryPolicy);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogInformational("Push token registration failed after retries.");
                ServiceRef.LogService.LogException(
                    ex,
                    new KeyValuePair<string, object?>("service", TokenInformation.Service.ToString()),
                    new KeyValuePair<string, object?>("clientType", TokenInformation.ClientType.ToString()));
                return false;
            }
 
            ServiceRef.LogService.LogInformational(
                "Push token reported.",
                new KeyValuePair<string, object?>("service", TokenInformation.Service.ToString()),
                new KeyValuePair<string, object?>("clientType", TokenInformation.ClientType.ToString()));
 
            return true;
        }
 
        private static async Task<bool> ForceTokenReportAsync(TokenInformation TokenInformation)
        {
            string OldToken = await RuntimeSettings.GetAsync(Constants.Settings.PushNotificationToken, string.Empty);
            DateTime ReportDate = await RuntimeSettings.GetAsync(Constants.Settings.PushNotificationReportDate, DateTime.MinValue);
 
            return (DateTime.UtcNow.Subtract(ReportDate).TotalDays > 7) || (TokenInformation.Token != OldToken);
        }
    }
}