PhotosLoader.cs

using NeuroAccessMaui.Extensions;
using NeuroAccessMaui.UI.Pages;
using SkiaSharp;
using System.Collections.ObjectModel;
using System.Security.Cryptography;
using Waher.Content;
using Waher.Content.Images;
using Waher.Content.Images.Exif;
using Waher.Events;
using Waher.Networking.XMPP.Contracts;
using Waher.Runtime.Temporary;
using NeuroAccessMaui.Services.Cache.AttachmentCache;
 
namespace NeuroAccessMaui.Services.UI.Photos
{
    public class PhotosLoader(ObservableCollection<Photo> Photos) : BaseViewModel
    {
        private readonly ObservableCollection<Photo> photos = Photos;
        private readonly List<string> attachmentIds = [];
        private DateTime loadPhotosTimestamp;
 
        public PhotosLoader() : this([])
        {
        }
 
        public Task<Photo?> LoadPhotos(Attachment[] Attachments, SignWith SignWith, Action? WhenDoneAction = null)
        {
            return this.LoadPhotos(Attachments, SignWith, DateTime.UtcNow, WhenDoneAction);
        }
 
        public void CancelLoadPhotos()
        {
            try
            {
                this.loadPhotosTimestamp = DateTime.UtcNow;
                this.attachmentIds.Clear();
                this.photos.Clear();
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        public async Task<(byte[]?, string, int)> LoadOnePhoto(Attachment Attachment, SignWith SignWith)
        {
            try
            {
                return await this.GetPhoto(Attachment, SignWith, DateTime.UtcNow);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
 
            return (null, string.Empty, 0);
        }
 
        private async Task<Photo?> LoadPhotos(Attachment[] Attachments, SignWith SignWith, DateTime Now, Action? WhenDoneAction)
        {
            if (Attachments is null || Attachments.Length <= 0)
            {
                WhenDoneAction?.Invoke();
                return null;
            }
 
            List<Attachment> AttachmentsList = Attachments.GetImageAttachments().ToList();
            List<string> NewAttachmentIds = AttachmentsList.Select(x => x.Id).ToList();
 
            if (this.attachmentIds.HasSameContentAs(NewAttachmentIds))
            {
                WhenDoneAction?.Invoke();
 
                foreach (Photo Photo in this.photos)
                    return Photo;
 
                return null;
            }
 
            this.attachmentIds.Clear();
            this.attachmentIds.AddRange(NewAttachmentIds);
 
            Photo? First = null;
 
            foreach (Attachment Attachment in AttachmentsList)
            {
                if (Array.IndexOf(ImageCodec.ImageContentTypes, Attachment.ContentType) < 0)
                    continue;
 
                if (this.loadPhotosTimestamp > Now)
                {
                    WhenDoneAction?.Invoke();
 
                    foreach (Photo Photo in this.photos)
                        return Photo;
 
                    return null;
                }
 
                try
                {
                    (byte[]? Bin, string ContentType, int Rotation) = await this.GetPhoto(Attachment, SignWith, Now);
 
                    if (Bin is null)
                        continue;
 
                    Photo Photo = new(Bin, Rotation, Attachment);
                    First ??= Photo;
 
                    if (Bin is not null)
                    {
                        TaskCompletionSource<bool> PhotoAddedTaskSource = new();
 
                        MainThread.BeginInvokeOnMainThread(() =>
                        {
                            this.photos.Add(Photo);
                            PhotoAddedTaskSource.TrySetResult(true);
                        });
 
                        await PhotoAddedTaskSource.Task;
                    }
                }
                catch (Exception ex)
                {
                    ServiceRef.LogService.LogException(ex);
                }
            }
 
            WhenDoneAction?.Invoke();
 
            return First;
        }
 
        private async Task<(byte[]?, string, int)> GetPhoto(Attachment Attachment, SignWith SignWith, DateTime Now)
        {
            if (Attachment is null)
                return (null, string.Empty, 0);
 
            (byte[]? Bin, string ContentType) = await ServiceRef.AttachmentCacheService.TryGet(Attachment.Url);
 
            if (Bin is not null)
                return (Bin, ContentType, GetImageRotation(Bin));
 
            if (!ServiceRef.NetworkService.IsOnline || !ServiceRef.XmppService.IsOnline)
                return (null, string.Empty, 0);
 
            KeyValuePair<string, TemporaryFile> pair = await ServiceRef.XmppService.GetAttachment(Attachment.Url, SignWith, Constants.Timeouts.DownloadFile);
 
            using TemporaryFile file = pair.Value;
 
            if (this.loadPhotosTimestamp > Now)     // If download has been cancelled any time _during_ download, stop here.
                return (null, string.Empty, 0);
 
            if (pair.Value.Length > int.MaxValue)   // Too large
                return (null, string.Empty, 0);
 
            file.Reset();
 
            ContentType = pair.Key;
            Bin = new byte[file.Length];
 
            if (file.Length != file.Read(Bin, 0, (int)file.Length))
                return (null, string.Empty, 0);
 
            bool IsContact = await ServiceRef.XmppService.IsContact(Attachment.LegalId);
 
            await ServiceRef.AttachmentCacheService.Add(Attachment.Url, Attachment.LegalId, IsContact, Bin, ContentType);
 
            return (Bin, ContentType, GetImageRotation(Bin));
        }
 
        public static int GetImageRotation(byte[] JpegImage)
        {
            if (DeviceInfo.Platform == DevicePlatform.iOS)
                return 0;
 
            if (JpegImage is null)
                return 0;
 
            if (!EXIF.TryExtractFromJPeg(JpegImage, out ExifTag[] Tags))
                return 0;
 
            return GetImageRotation(Tags);
        }
 
        public static int GetImageRotation(ExifTag[] Tags)
        {
            foreach (ExifTag Tag in Tags)
            {
                if (Tag.Name == ExifTagName.Orientation)
                {
                    if (Tag.Value is ushort Orientation)
                    {
                        return Orientation switch
                        {
                            1 => 0,// Top left. Default orientation.
                            2 => 0,// Top right. Horizontally reversed.
                            3 => 180,// Bottom right. Rotated by 180 degrees.
                            4 => 180,// Bottom left. Rotated by 180 degrees and then horizontally reversed.
                            5 => -90,// Left top. Rotated by 90 degrees counterclockwise and then horizontally reversed.
                            6 => 90,// Right top. Rotated by 90 degrees clockwise.
                            7 => 90,// Right bottom. Rotated by 90 degrees clockwise and then horizontally reversed.
                            8 => -90,// Left bottom. Rotated by 90 degrees counterclockwise.
                            _ => 0,
                        };
                    }
                }
            }
 
            return 0;
        }
 
        public static async Task<(byte[]?, string, int)> LoadPhoto(Attachment Attachment)
        {
            PhotosLoader Loader = new();
 
            (byte[]?, string, int) Image = await Loader.LoadOnePhoto(Attachment, SignWith.LatestApprovedIdOrCurrentKeys);
 
            return Image;
        }
 
        public static Task<(string?, int, int)> LoadPhotoAsTemporaryFile(Attachment[] Attachments, int MaxWith, int MaxHeight)
        {
            Attachment? Photo = null;
 
            foreach (Attachment Attachment in Attachments.GetImageAttachments())
            {
                if (Attachment.ContentType == Constants.MimeTypes.Png)
                {
                    Photo = Attachment;
                    break;
                }
                else
                    Photo ??= Attachment;
            }
 
            if (Photo is null)
                return Task.FromResult<(string?, int, int)>((null, 0, 0));
            else
                return LoadPhotoAsTemporaryFile(Photo, MaxWith, MaxHeight);
        }
 
        public static async Task<(string?, int, int)> LoadPhotoAsTemporaryFile(Attachment Attachment, int MaxWith, int MaxHeight)
        {
            (byte[]? Data, string _, int _) = await LoadPhoto(Attachment);
 
            if (Data is not null)
            {
                string FileName = await GetTemporaryFile(Data);
                int Width;
                int Height;
 
                using (SKBitmap Bitmap = SKBitmap.Decode(Data))
                {
                    Width = Bitmap.Width;
                    Height = Bitmap.Height;
                }
 
                double ScaleWidth = ((double)MaxWith) / Width;
                double ScaleHeight = ((double)MaxHeight) / Height;
                double Scale = Math.Min(ScaleWidth, ScaleHeight);
 
                if (Scale < 1)
                {
                    Width = (int)(Width * Scale + 0.5);
                    Height = (int)(Height * Scale + 0.5);
                }
 
                return (FileName, Width, Height);
            }
            else
                return (null, 0, 0);
        }
 
        #region From Waher.Content.Markdown.Model.Multimedia.ImageContent, with permission
 
        public static Task<string> GetTemporaryFile(byte[] BinaryImage)
        {
            return GetTemporaryFile(BinaryImage, "tmp");
        }
 
        public static async Task<string> GetTemporaryFile(byte[] BinaryImage, string FileExtension)
        {
            byte[] Digest = SHA256.HashData(BinaryImage);
            string FileName = Path.Combine(Path.GetTempPath(), "tmp" + Base64Url.Encode(Digest) + "." + FileExtension);
 
            if (!File.Exists(FileName))
            {
                await Waher.Runtime.IO.Files.WriteAllBytesAsync(FileName, BinaryImage);
 
                lock (synchObject)
                {
                    if (temporaryFiles is null)
                    {
                        temporaryFiles = [];
                        Log.Terminating += CurrentDomain_ProcessExit;
                    }
 
                    temporaryFiles[FileName] = true;
                }
            }
 
            return FileName;
        }
 
        private static Dictionary<string, bool>? temporaryFiles = null;
        private static readonly object synchObject = new();
 
        private static Task CurrentDomain_ProcessExit(object? sender, EventArgs e)
        {
            lock (synchObject)
            {
                if (temporaryFiles is not null)
                {
                    foreach (string FileName in temporaryFiles.Keys)
                    {
                        try
                        {
                            File.Delete(FileName);
                        }
                        catch (Exception)
                        {
                            // Ignore
                        }
                    }
 
                    temporaryFiles.Clear();
                }
            }
 
            return Task.CompletedTask;
        }
 
        #endregion
    }
}