Added Stream as a media source for all platforms except Tizen

Author: matt-goldman

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

@@ -54,6 +54,7 @@ public override bool CanConvertTo(ITypeDescriptorContext? context, Type? destina
 		UriMediaSource uriMediaSource => uriMediaSource.ToString(),
 		FileMediaSource fileMediaSource => fileMediaSource.ToString(),
 		ResourceMediaSource resourceMediaSource => resourceMediaSource.ToString(),
+		StreamMediaSource streamMediaSource => streamMediaSource.ToString(),
 		MediaSource => string.Empty,
 		_ => throw new ArgumentException($"Invalid Media Source", nameof(value))
 	};

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

@@ -57,6 +57,13 @@ internal event EventHandler SourceChanged
 	/// <returns>A <see cref="FileMediaSource"/> instance.</returns>
 	public static MediaSource FromFile(string? path) => new FileMediaSource { Path = path };
 
+	/// <summary>
+	/// Creates a <see cref="StreamMediaSource"/> from a <see cref="Stream"/>.
+	/// </summary>
+	/// <param name="stream">The stream to use as a media source.</param>
+	/// <returns>A <see cref="StreamMediaSource"/> instance.</returns>
+	public static StreamMediaSource FromStream(Stream stream) => new StreamMediaSource { Stream = stream };
+
 	/// <summary>
 	/// Creates a <see cref="UriMediaSource"/> from an absolute URI.
 	/// </summary>

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

@@ -0,0 +1,43 @@
+using Microsoft.Maui.Controls;
+
+namespace CommunityToolkit.Maui.Views;
+
+/// <summary>
+/// Represents a source, loaded from a <see cref="System.IO.Stream"/>, that can be played by <see cref="MediaElement"/>.
+/// </summary>
+public sealed partial class StreamMediaSource : MediaSource
+{
+	/// <summary>
+	/// Backing store for the <see cref="Stream"/> property.
+	/// </summary>
+	public static readonly BindableProperty StreamProperty
+		= BindableProperty.Create(nameof(Stream), typeof(Stream), typeof(StreamMediaSource), propertyChanged: OnStreamMediaSourceChanged);
+
+	/// <summary>
+	/// An implicit operator to convert a <see cref="System.IO.Stream"/> value into a <see cref="StreamMediaSource"/>.
+	/// </summary>
+	/// <param name="stream">The stream to use as a media source.</param>
+	public static implicit operator StreamMediaSource?(Stream? stream) => stream is not null ? FromStream(stream) : null;
+
+	/// <summary>
+	/// An implicit operator to convert a <see cref="StreamMediaSource"/> into a <see cref="System.IO.Stream"/> value.
+	/// </summary>
+	/// <param name="streamMediaSource">A <see cref="StreamMediaSource"/> instance to convert to a <see cref="System.IO.Stream"/> value.</param>
+	public static implicit operator Stream?(StreamMediaSource? streamMediaSource) => streamMediaSource?.Stream;
+
+	/// <summary>
+	/// Gets or sets the stream to use as a media source.
+	/// This is a bindable property.
+	/// </summary>
+	public Stream? Stream
+	{
+		get => (Stream?)GetValue(StreamProperty);
+		set => SetValue(StreamProperty, value);
+	}
+
+	/// <inheritdoc/>
+	public override string ToString() => $"Stream: {Stream?.GetType().Name ?? "null"}";
+
+	static void OnStreamMediaSourceChanged(BindableObject bindable, object oldValue, object newValue) =>
+		((StreamMediaSource)bindable).OnSourceChanged();
+}

src/CommunityToolkit.Maui.MediaElement/Platforms/Android/StreamDataSource.android.cs

@@ -0,0 +1,124 @@
+using AndroidX.Media3.Common;
+using AndroidX.Media3.DataSource;
+
+namespace CommunityToolkit.Maui.Core.Views;
+
+/// <summary>
+/// A custom DataSource for ExoPlayer that wraps a .NET Stream.
+/// </summary>
+sealed class StreamDataSource : Java.Lang.Object, IDataSource
+{
+	readonly Stream stream;
+	readonly long length;
+	Android.Net.Uri? uri;
+	long bytesRemaining;
+
+	public StreamDataSource(Stream stream)
+	{
+		ArgumentNullException.ThrowIfNull(stream);
+		
+		this.stream = stream;
+		length = stream.CanSeek ? stream.Length : C.LengthUnset;
+		bytesRemaining = 0;
+	}
+
+	public void AddTransferListener(ITransferListener? transferListener)
+	{
+		// No-op: transfer listeners not supported for stream sources
+	}
+
+	public Android.Net.Uri? Uri => uri;
+
+	public long Open(DataSpec? dataSpec)
+	{
+		if (dataSpec is null)
+		{
+			throw new ArgumentNullException(nameof(dataSpec));
+		}
+
+		uri = dataSpec.Uri;
+
+		if (stream.CanSeek && dataSpec.Position > 0)
+		{
+			stream.Seek(dataSpec.Position, SeekOrigin.Begin);
+		}
+
+		bytesRemaining = dataSpec.Length != C.LengthUnset 
+			? dataSpec.Length 
+			: (length != C.LengthUnset ? length - dataSpec.Position : C.LengthUnset);
+
+		return bytesRemaining;
+	}
+
+	public int Read(byte[]? buffer, int offset, int length)
+	{
+		if (buffer is null)
+		{
+			throw new ArgumentNullException(nameof(buffer));
+		}
+
+		if (length == 0)
+		{
+			return 0;
+		}
+
+		if (bytesRemaining == 0)
+		{
+			return C.ResultEndOfInput;
+		}
+
+		int bytesToRead = bytesRemaining != C.LengthUnset 
+			? (int)Math.Min(bytesRemaining, length) 
+			: length;
+
+		int bytesRead = stream.Read(buffer, offset, bytesToRead);
+
+		if (bytesRead == 0)
+		{
+			return C.ResultEndOfInput;
+		}
+
+		if (bytesRemaining != C.LengthUnset)
+		{
+			bytesRemaining -= bytesRead;
+		}
+
+		return bytesRead;
+	}
+
+	public void Close()
+	{
+		uri = null;
+		// Don't dispose the stream here - let the caller manage its lifetime
+	}
+
+	protected override void Dispose(bool disposing)
+	{
+		if (disposing)
+		{
+			Close();
+		}
+		base.Dispose(disposing);
+	}
+
+	public IDictionary<string, IList<string>>? ResponseHeaders => null;
+}
+
+/// <summary>
+/// Factory for creating StreamDataSource instances.
+/// </summary>
+sealed class StreamDataSourceFactory : Java.Lang.Object, IDataSourceFactory
+{
+	readonly Stream stream;
+
+	public StreamDataSourceFactory(Stream stream)
+	{
+		ArgumentNullException.ThrowIfNull(stream);
+		this.stream = stream;
+	}
+
+	public IDataSource CreateDataSource()
+	{
+		return new StreamDataSource(stream);
+	}
+}

src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.android.cs

@@ -8,6 +8,7 @@
 using AndroidX.Media3.Common;
 using AndroidX.Media3.Common.Text;
 using AndroidX.Media3.Common.Util;
+using AndroidX.Media3.DataSource;
 using AndroidX.Media3.ExoPlayer;
 using AndroidX.Media3.Session;
 using AndroidX.Media3.UI;
@@ -39,6 +40,7 @@ public partial class MediaManager : Java.Lang.Object, IPlayerListener
 	MediaSession? session;
 	MediaItem.Builder? mediaItem;
 	BoundServiceConnection? connection;
+	StreamDataSourceFactory? currentStreamDataSourceFactory;
 
 	/// <summary>
 	/// The platform native counterpart of <see cref="MediaElement"/>.
@@ -366,9 +368,19 @@ protected virtual async partial ValueTask PlatformUpdateSource()
 			MediaElement.Duration = TimeSpan.Zero;
 			MediaElement.CurrentStateChanged(MediaElementState.None);
 
+			currentStreamDataSourceFactory?.Dispose();
+			currentStreamDataSourceFactory = null;
+
 			return;
 		}
 
+		// Clear previous stream data source if switching sources
+		if (MediaElement.Source is not StreamMediaSource)
+		{
+			currentStreamDataSourceFactory?.Dispose();
+			currentStreamDataSourceFactory = null;
+		}
+
 		MediaElement.CurrentStateChanged(MediaElementState.Opening);
 		Player.PlayWhenReady = MediaElement.ShouldAutoPlay;
 		cancellationTokenSource ??= new();
@@ -378,7 +390,18 @@ protected virtual async partial ValueTask PlatformUpdateSource()
 
 		if (item?.MediaMetadata is not null)
 		{
-			Player.SetMediaItem(item);
+			// If we have a custom stream data source, we need to set the media source differently
+			if (currentStreamDataSourceFactory is not null && MediaElement.Source is StreamMediaSource)
+			{
+				var mediaSource = new AndroidX.Media3.ExoPlayer.Source.ProgressiveMediaSource.Factory(currentStreamDataSourceFactory)
+					.CreateMediaSource(item);
+				Player.SetMediaSource(mediaSource);
+			}
+			else
+			{
+				Player.SetMediaItem(item);
+			}
+			
 			Player.Prepare();
 			hasSetSource = true;
 		}
@@ -541,6 +564,9 @@ protected override void Dispose(bool disposing)
 				connection = null;
 			}
 
+			currentStreamDataSourceFactory?.Dispose();
+			currentStreamDataSourceFactory = null;
+
 			client.Dispose();
 		}
 	}
@@ -697,7 +723,7 @@ void StopService(in BoundServiceConnection boundServiceConnection)
 
 					break;
 				}
-			case ResourceMediaSource resourceMediaSource:
+				case ResourceMediaSource resourceMediaSource:
 				{
 					var package = PlayerView?.Context?.PackageName ?? "";
 					var path = resourceMediaSource.Path;
@@ -707,6 +733,15 @@ void StopService(in BoundServiceConnection boundServiceConnection)
 						return await CreateMediaItem(assetFilePath, cancellationToken).ConfigureAwait(false);
 					}
 
+					break;
+				}
+			case StreamMediaSource streamMediaSource:
+				{
+					if (streamMediaSource.Stream is not null)
+					{
+						return await CreateMediaItemFromStream(streamMediaSource.Stream, cancellationToken).ConfigureAwait(false);
+					}
+
 					break;
 				}
 			default:
@@ -735,6 +770,30 @@ void StopService(in BoundServiceConnection boundServiceConnection)
 		return mediaItem;
 	}
 
+	async Task<MediaItem.Builder> CreateMediaItemFromStream(Stream stream, CancellationToken cancellationToken = default)
+	{
+		MediaMetadata.Builder mediaMetaData = new();
+		mediaMetaData.SetArtist(MediaElement.MetadataArtist);
+		mediaMetaData.SetTitle(MediaElement.MetadataTitle);
+		var data = await GetBytesFromMetadataArtworkUrl(MediaElement.MetadataArtworkUrl, cancellationToken).ConfigureAwait(true);
+		if (data is not null && data.Length > 0)
+		{
+			mediaMetaData.SetArtworkData(data, (Java.Lang.Integer)MediaMetadata.PictureTypeFrontCover);
+		}
+
+		// Create MediaItem with metadata
+		// The stream will be handled via custom data source factory when needed
+		mediaItem = new MediaItem.Builder();
+		mediaItem.SetUri("stream://media");
+		mediaItem.SetMediaId("stream://media");
+		mediaItem.SetMediaMetadata(mediaMetaData.Build());
+
+		// Store the stream for later use with custom MediaSource
+		currentStreamDataSourceFactory = new StreamDataSourceFactory(stream);
+
+		return mediaItem;
+	}
+
 	#region PlayerListener implementation method stubs
 	public void OnAudioAttributesChanged(AudioAttributes? audioAttributes) { }
 	public void OnAudioSessionIdChanged(int audioSessionId) { }

src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.macios.cs

@@ -14,6 +14,7 @@ namespace CommunityToolkit.Maui.Core.Views;
 public partial class MediaManager : IDisposable
 {
 	Metadata? metaData;
+	StreamAssetResourceLoader? streamResourceLoader;
 
 	// Media would still start playing when Speed was set although ShouldAutoPlay=False
 	// This field was added to overcome that.
@@ -220,6 +221,13 @@ protected virtual async partial ValueTask PlatformUpdateSource()
 			return;
 		}
 
+		// Clean up previous stream resource loader if switching sources
+		if (MediaElement.Source is not StreamMediaSource)
+		{
+			streamResourceLoader?.Dispose();
+			streamResourceLoader = null;
+		}
+
 		metaData ??= new(Player);
 		Metadata.ClearNowPlaying();
 		PlayerViewController?.ContentOverlayView?.Subviews.FirstOrDefault()?.RemoveFromSuperview();
@@ -260,6 +268,26 @@ protected virtual async partial ValueTask PlatformUpdateSource()
 				Logger.LogWarning("Invalid file path for ResourceMediaSource.");
 			}
 		}
+		else if (MediaElement.Source is StreamMediaSource streamMediaSource)
+		{
+			if (streamMediaSource.Stream is not null)
+			{
+				// Create a custom URL scheme for the stream
+				var streamUrl = new NSUrl("stream://media");
+				
+				// Create an AVURLAsset with the custom scheme
+				var urlAsset = new AVUrlAsset(streamUrl);
+				
+				// Create and set up the resource loader
+				streamResourceLoader?.Dispose();
+				streamResourceLoader = new StreamAssetResourceLoader(streamMediaSource.Stream, GetStreamContentType(streamMediaSource.Stream));
+				
+				// Assign the resource loader delegate
+				urlAsset.ResourceLoader.SetDelegate(streamResourceLoader, DispatchQueue.MainQueue);
+				
+				asset = urlAsset;
+			}
+		}
 
 		PlayerItem = asset is not null
 			? new AVPlayerItem(asset)
@@ -453,11 +481,24 @@ protected virtual void Dispose(bool disposing)
 				Player = null;
 			}
 
+			streamResourceLoader?.Dispose();
+			streamResourceLoader = null;
+
 			PlayerViewController?.Dispose();
 			PlayerViewController = null;
 		}
 	}
 
+	static string GetStreamContentType(Stream stream)
+	{
+		// Default to a generic media type
+		// In a more sophisticated implementation, you could:
+		// 1. Read magic bytes from the stream to detect type
+		// 2. Accept content type as a parameter on StreamMediaSource
+		// 3. Use file extension if available
+		return "video/mp4"; // Default assumption
+	}
+
 	static TimeSpan ConvertTime(CMTime cmTime) => TimeSpan.FromSeconds(double.IsNaN(cmTime.Seconds) ? 0 : cmTime.Seconds);
 
 	static async Task<(int Width, int Height)> GetVideoDimensions(AVPlayerItem avPlayerItem)