Refactor media artwork handling and async updates

Updated `PlatformUpdateSource` to be asynchronous, re-implemented `SetPoster` method for robustness, and replaced `MetadataArtworkUrl` with `MetadataArtworkSource` across the project.

- Replaced `MetadataArtworkUrl` with `MetadataArtworkSource` in `MediaElementPage.xaml` and related files.
- Introduced `loadCustomMediaSource` constant and `saveDirectory` string in `MediaElementPage.xaml.cs`.
- Updated `ChangeSourceClicked` method to handle new media source and artwork property.
- Added file handling methods: `Savefile`, `GetFileName`, and `PickAndShow`.
- Updated `IMediaElement` and `MediaElement` class to use `MetadataArtworkSource`.
- Modified `SetMetadata` in `Metadata.macios.cs` for new artwork property.
- Removed `Metadata` class from `Metadata.windows.cs`.
- Enhanced `MediaManager.android.cs` to handle new artwork property and fetch image data.
- Added `BlankByteArray` method and `PlaybackState` class in `MediaManager.android.cs`.
- Made `PlatformUpdateSource` in `MediaManager.macios.cs` asynchronous, updated `Dispose` method.
- Added `GetArtwork` struct for fetching artwork in `MediaManager.macios.cs`.
- Updated `MediaManager.windows.cs` to handle new artwork property and added `ArtworkUrl` method.
- Updated `MediaElementTests` for new artwork property.

Author: ne0rrmatrix

samples/CommunityToolkit.Maui.Sample/Pages/Views/MediaElement/MediaElementPage.xaml

@@ -30,7 +30,7 @@
                 x:Name="MediaElement"
                 ShouldAutoPlay="True"
                 Source="https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4"
-                MetadataArtworkUrl="https://lh3.googleusercontent.com/pw/AP1GczNRrebWCJvfdIau1EbsyyYiwAfwHS0JXjbioXvHqEwYIIdCzuLodQCZmA57GADIo5iB3yMMx3t_vsefbfoHwSg0jfUjIXaI83xpiih6d-oT7qD_slR0VgNtfAwJhDBU09kS5V2T5ZML-WWZn8IrjD4J-g=w1792-h1024-s-no-gm"
+                MetadataArtworkSource="https://lh3.googleusercontent.com/pw/AP1GczNRrebWCJvfdIau1EbsyyYiwAfwHS0JXjbioXvHqEwYIIdCzuLodQCZmA57GADIo5iB3yMMx3t_vsefbfoHwSg0jfUjIXaI83xpiih6d-oT7qD_slR0VgNtfAwJhDBU09kS5V2T5ZML-WWZn8IrjD4J-g=w1792-h1024-s-no-gm"
                 MetadataTitle="Big Buck Bunny"
                 MetadataArtist="Blender Foundation"
                 MediaEnded="OnMediaEnded"

samples/CommunityToolkit.Maui.Sample/Pages/Views/MediaElement/MediaElementPage.xaml.cs

@@ -16,7 +16,8 @@ public partial class MediaElementPage : BasePage<MediaElementViewModel>
 	const string loadLocalResource = "Load Local Resource";
 	const string resetSource = "Reset Source to null";
 	const string loadMusic = "Load Music";
-
+	const string loadCustomMediaSource = "Load Custom Image Source";
+	static readonly string saveDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData));
 	const string buckBunnyMp4Url = "https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4";
 	const string botImageUrl = "https://lh3.googleusercontent.com/pw/AP1GczNRrebWCJvfdIau1EbsyyYiwAfwHS0JXjbioXvHqEwYIIdCzuLodQCZmA57GADIo5iB3yMMx3t_vsefbfoHwSg0jfUjIXaI83xpiih6d-oT7qD_slR0VgNtfAwJhDBU09kS5V2T5ZML-WWZn8IrjD4J-g=w1792-h1024-s-no-gm";
 	const string hlsStreamTestUrl = "https://mtoczko.github.io/hls-test-streams/test-gap/playlist.m3u8";
@@ -161,34 +162,34 @@ void Button_Clicked(object? sender, EventArgs e)
 	async void ChangeSourceClicked(Object sender, EventArgs e)
 	{
 		var result = await DisplayActionSheet("Choose a source", "Cancel", null,
-			loadOnlineMp4, loadHls, loadLocalResource, resetSource, loadMusic);
+			loadOnlineMp4, loadHls, loadLocalResource, resetSource, loadMusic, loadCustomMediaSource);
 
 		switch (result)
 		{
 			case loadOnlineMp4:
 				MediaElement.MetadataTitle = "Big Buck Bunny";
-				MediaElement.MetadataArtworkUrl = botImageUrl;
+				MediaElement.MetadataArtworkSource = MediaSource.FromUri(botImageUrl);
 				MediaElement.MetadataArtist = "Big Buck Bunny Album";
 				MediaElement.Source =
 					MediaSource.FromUri(buckBunnyMp4Url);
 				return;
 
 			case loadHls:
 				MediaElement.MetadataArtist = "HLS Album";
-				MediaElement.MetadataArtworkUrl = botImageUrl;
+				MediaElement.MetadataArtworkSource = botImageUrl;
 				MediaElement.MetadataTitle = "HLS Title";
 				MediaElement.Source = MediaSource.FromUri(hlsStreamTestUrl);
 				return;
 
 			case resetSource:
-				MediaElement.MetadataArtworkUrl = string.Empty;
+				MediaElement.MetadataArtworkSource = string.Empty;
 				MediaElement.MetadataTitle = string.Empty;
 				MediaElement.MetadataArtist = string.Empty;
 				MediaElement.Source = null;
 				return;
 
 			case loadLocalResource:
-				MediaElement.MetadataArtworkUrl = botImageUrl;
+				MediaElement.MetadataArtworkSource = MediaSource.FromResource("robot.jpg");
 				MediaElement.MetadataTitle = "Local Resource Title";
 				MediaElement.MetadataArtist = "Local Resource Album";
 
@@ -210,10 +211,57 @@ async void ChangeSourceClicked(Object sender, EventArgs e)
 			case loadMusic:
 				MediaElement.MetadataTitle = "HAL 9000";
 				MediaElement.MetadataArtist = "HAL 9000 Album";
-				MediaElement.MetadataArtworkUrl = botImageUrl;
+				MediaElement.MetadataArtworkSource = botImageUrl;
 				MediaElement.Source = MediaSource.FromUri(hal9000AudioUrl);
 				return;
+			case loadCustomMediaSource:
+				var fileresult = await PickAndShow(new PickOptions
+				{
+					PickerTitle = "Pick a media file",
+					FileTypes = FilePickerFileType.Images,
+				});
+				var fileName = await Savefile(fileresult);
+				if (fileName is not null)
+				{
+					MediaElement.MetadataArtworkSource = MediaSource.FromFile(fileName);
+					MediaElement.MetadataTitle = "Big Buck Bunny";
+					MediaElement.MetadataArtist = "Big Buck Bunny Album";
+					MediaElement.Source =
+						MediaSource.FromUri(buckBunnyMp4Url);
+				}
+
+				return;
+		}
+	}
+	static async Task<string?> Savefile(FileResult? fileresult)
+	{
+		if (fileresult is null)
+		{
+			System.Diagnostics.Trace.WriteLine("File result is null");
+			return null;
+		}
+		try
+		{
+			using Stream fileStream = await fileresult.OpenReadAsync();
+			using StreamReader reader = new(fileStream);
+			var fileName = GetFileName(fileresult.FileName);
+			using FileStream output = File.Create(fileName);
+			await fileStream.CopyToAsync(output);
+			fileStream.Seek(0, SeekOrigin.Begin);
+			FileStream.Synchronized(output);
+			return fileName;
+		}
+		catch (Exception ex)
+		{
+			System.Diagnostics.Trace.WriteLine(ex.Message);
+			return null;
 		}
+		
+	}
+	static string GetFileName(string name)
+	{
+		var filename = Path.GetFileName(name);
+		return Path.Combine(saveDirectory, filename);
 	}
 
 	async void ChangeAspectClicked(object? sender, EventArgs e)
@@ -274,4 +322,24 @@ void DisplayPopup(object sender, EventArgs e)
 			popupMediaElement.Handler?.DisconnectHandler();
 		};
 	}
+	static async Task<FileResult?> PickAndShow(PickOptions options)
+	{
+		try
+		{
+			var result = await FilePicker.Default.PickAsync(options);
+			if (result is not null)
+			{
+				using var stream = await result.OpenReadAsync();
+				var image = ImageSource.FromStream(() => stream);
+			}
+
+			return result;
+		}
+		catch (Exception ex)
+		{
+			System.Diagnostics.Debug.WriteLine(ex.Message);
+		}
+
+		return null;
+	}
 }

samples/CommunityToolkit.Maui.Sample/Resources/Raw/robot.jpg

@@ -19,9 +19,9 @@ public interface IMediaElement : IView, IAsynchronousMediaElementHandler
 	string MetadataArtist { get; set; }
 
 	/// <summary>
-	/// Gets or sets the artwork Image Url.
+	/// Gets or sets the artwork Image source.
 	/// </summary>
-	string MetadataArtworkUrl { get; set; }
+	public MediaSource? MetadataArtworkSource { get; set; }
 
 	/// <summary>
 	/// Gets the media aspect ratio.

src/CommunityToolkit.Maui.MediaElement/Interfaces/IMediaElement.cs

@@ -116,10 +116,10 @@ public partial class MediaElement : View, IMediaElement, IDisposable
 	public static readonly BindableProperty MetadataArtistProperty = BindableProperty.Create(nameof(MetadataArtist), typeof(string), typeof(MediaElement), string.Empty);
 
 	/// <summary>
-	/// Backing store for the <see cref="MetadataArtworkUrl"/> property.
+	/// Backing store for the <see cref="MetadataArtworkSource"/> property.
 	/// </summary>
-	public static readonly BindableProperty MetadataArtworkUrlProperty = BindableProperty.Create(nameof(MetadataArtworkUrl), typeof(string), typeof(MediaElement), string.Empty);
-
+	public static readonly BindableProperty MetadataArtworkSourceProperty = BindableProperty.Create(nameof(MetadataArtworkSource), typeof(MediaSource), typeof(MediaElement));
+	
 	readonly WeakEventManager eventManager = new();
 	readonly SemaphoreSlim seekToSemaphoreSlim = new(1, 1);
 
@@ -362,13 +362,14 @@ public string MetadataArtist
 	}
 
 	/// <summary>
-	/// Gets or sets the Artwork Image Url of the media.
+	/// Gets or sets the Artwork Image Source of the media.
 	/// This is a bindable property.
 	/// </summary>
-	public string MetadataArtworkUrl
+	[TypeConverter(typeof(MediaSourceConverter))]
+	public MediaSource? MetadataArtworkSource
 	{
-		get => (string)GetValue(MetadataArtworkUrlProperty);
-		set => SetValue(MetadataArtworkUrlProperty, value);
+		get => (MediaSource)GetValue(MetadataArtworkSourceProperty);
+		set => SetValue(MetadataArtworkSourceProperty, value);
 	}
 
 	/// <summary>
@@ -577,7 +578,6 @@ void ClearTimer()
 		timer.Stop();
 		timer = null;
 	}
-
 	void OnSourceChanged(object? sender, EventArgs eventArgs)
 	{
 		OnPropertyChanged(SourceProperty.PropertyName);

src/CommunityToolkit.Maui.MediaElement/MediaElement.shared.cs

@@ -1,4 +1,5 @@
 using AVFoundation;
+using CommunityToolkit.Maui.Views;
 using CoreMedia;
 using Foundation;
 using MediaPlayer;
@@ -69,40 +70,32 @@ public Metadata(PlatformMediaElement player)
 	/// </summary>
 	/// <param name="playerItem"></param>
 	/// <param name="mediaElement"></param>
-	public void SetMetadata(AVPlayerItem? playerItem, IMediaElement? mediaElement)
+	public async Task SetMetadata(AVPlayerItem? playerItem, IMediaElement? mediaElement)
 	{
 		if (mediaElement is null)
 		{
-			Metadata.ClearNowPlaying();
 			return;
 		}
+		ClearNowPlaying();
+		var artwork = await MetadataArtworkUrl(mediaElement.MetadataArtworkSource).ConfigureAwait(false);
 
+		if (artwork is not null && artwork is UIImage image)
+		{
+			NowPlayingInfo.Artwork = new(boundsSize: new(320, 240), requestHandler: _ => image);
+		}
+		else
+		{
+			NowPlayingInfo.Artwork = new(boundsSize: new(0, 0), requestHandler: _ => defaultUIImage);
+		}
 		NowPlayingInfo.Title = mediaElement.MetadataTitle;
 		NowPlayingInfo.Artist = mediaElement.MetadataArtist;
 		NowPlayingInfo.PlaybackDuration = playerItem?.Duration.Seconds ?? 0;
 		NowPlayingInfo.IsLiveStream = false;
 		NowPlayingInfo.PlaybackRate = mediaElement.Speed;
 		NowPlayingInfo.ElapsedPlaybackTime = playerItem?.CurrentTime.Seconds ?? 0;
-		NowPlayingInfo.Artwork = new(boundsSize: new(320, 240), requestHandler: _ => GetImage(mediaElement.MetadataArtworkUrl));
 		MPNowPlayingInfoCenter.DefaultCenter.NowPlaying = NowPlayingInfo;
 	}
 
-	static UIImage GetImage(string imageUri)
-	{
-		try
-		{
-			if (imageUri.StartsWith(Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase))
-			{
-				return UIImage.LoadFromData(NSData.FromUrl(new NSUrl(imageUri))) ?? defaultUIImage;
-			}
-			return defaultUIImage;
-		}
-		catch
-		{
-			return defaultUIImage;
-		}
-	}
-
 	MPRemoteCommandHandlerStatus SeekCommand(MPRemoteCommandEvent? commandEvent)
 	{
 		if (commandEvent is not MPChangePlaybackPositionCommandEvent eventArgs)
@@ -179,4 +172,70 @@ MPRemoteCommandHandlerStatus ToggleCommand(MPRemoteCommandEvent? commandEvent)
 
 		return MPRemoteCommandHandlerStatus.Success;
 	}
+
+	public static async Task<UIImage?> MetadataArtworkUrl(MediaSource? artworkUrl, CancellationToken cancellationToken = default)
+	{
+		if (artworkUrl is UriMediaSource uriMediaSource)
+		{
+			var uri = uriMediaSource.Uri;
+			return GetBitmapFromUrl(uri?.AbsoluteUri);
+		}
+		else if (artworkUrl is FileMediaSource fileMediaSource)
+		{
+			var uri = fileMediaSource.Path;
+
+			return await GetBitmapFromFile(uri, cancellationToken).ConfigureAwait(false);
+		}
+		else if (artworkUrl is ResourceMediaSource resourceMediaSource)
+		{
+			var path = resourceMediaSource.Path;
+			return await GetBitmapFromResource(path, cancellationToken).ConfigureAwait(false);
+		}
+		return null;
+	}
+
+	static async Task<UIImage?> GetBitmapFromFile(string? resource, CancellationToken cancellationToken = default)
+	{
+		if (string.IsNullOrWhiteSpace(resource))
+		{
+			return null;
+		}
+		using var fileStream = File.OpenRead(resource);
+		using var memoryStream = new MemoryStream();
+		await fileStream.CopyToAsync(memoryStream, cancellationToken).ConfigureAwait(false);
+		memoryStream.Position = 0;
+		NSData temp = NSData.FromStream(memoryStream) ?? new NSData();
+		return UIImage.LoadFromData(temp);
+	}
+	static UIImage? GetBitmapFromUrl(string? resource)
+	{
+		if (string.IsNullOrEmpty(resource))
+		{
+			return null;
+		}
+		return UIImage.LoadFromData(NSData.FromUrl(new NSUrl(resource)));
+	}
+	static async Task<UIImage?> GetBitmapFromResource(string? resource, CancellationToken cancellationToken = default)
+	{
+		if (string.IsNullOrWhiteSpace(resource))
+		{
+			return null;
+		}
+		using var inputStream = await FileSystem.OpenAppPackageFileAsync(resource).ConfigureAwait(false);
+		using var memoryStream = new MemoryStream();
+		if (inputStream is null)
+		{
+			System.Diagnostics.Trace.TraceError($"{inputStream} is null.");
+			return null;
+		}
+		await inputStream.CopyToAsync(memoryStream, cancellationToken).ConfigureAwait(false);
+		memoryStream.Position = 0;
+		NSData? nsdata = NSData.FromStream(memoryStream);
+		if (nsdata is null)
+		{
+			System.Diagnostics.Trace.TraceError($"{nsdata} is null.");
+			return null;
+		}
+		return UIImage.LoadFromData(nsdata);
+	}
 }