private async Task CleanupFailedOpenAsync(Task <IMediaReader>[] readerTasks)
{
Debug.WriteLine("SmMediaManager.CleanupFailedOpenAsync() state " + State);
_playbackCancellationTokenSource.Cancel();
if (_readers == null && null != readerTasks)
{
_readers = readerTasks.Where(r =>
{
if (null == r)
{
return(false);
}
AggregateException exception = r.Exception;
if (null == exception)
{
return(r.IsCompleted);
}
Debug.WriteLine("SmMediaManager.CleanupFailedOpenAsync(): reader create failed: " + exception.Message);
return(false);
}).Select(r => r.Result).ToArray();
await CloseReadersAsync().ConfigureAwait(false);
DisposeReaders();
}
if (null != _readerManager)
{
_readerManager.DisposeSafe();
_readerManager = null;
}
}
private async Task CleanupFailedOpenAsync(Task <IMediaReader>[] readerTasks)
{
Debug.WriteLine("SmMediaManager.CleanupFailedOpenAsync() state " + (object)this.State);
this._playbackCancellationTokenSource.Cancel();
if (this._readers == null && null != readerTasks)
{
this._readers = Enumerable.ToArray <IMediaReader>(Enumerable.Select <Task <IMediaReader>, IMediaReader>(Enumerable.Where <Task <IMediaReader> >((IEnumerable <Task <IMediaReader> >)readerTasks, (Func <Task <IMediaReader>, bool>)(r =>
{
if (null == r)
{
return(false);
}
AggregateException exception = r.Exception;
if (null == exception)
{
return(r.IsCompleted);
}
Debug.WriteLine("SmMediaManager.CleanupFailedOpenAsync(): reader create failed: " + exception.Message);
return(false);
})), (Func <Task <IMediaReader>, IMediaReader>)(r => r.Result)));
await this.CloseReadersAsync().ConfigureAwait(false);
this.DisposeReaders();
}
if (null != this._readerManager)
{
DisposeExtensions.DisposeSafe((IDisposable)this._readerManager);
this._readerManager = (ISegmentReaderManager)null;
}
}
private async Task OpenAsync(ICollection <Uri> source)
{
Debug.WriteLine("SmMediaManager.OpenAsync() state " + State);
State = MediaManagerState.Opening;
++_openCount;
ResetCancellationToken();
Task <IMediaReader>[] readerTasks = null;
Exception exception;
try
{
_mediaStreamConfigurator.Initialize();
_readerManager = await _segmentReaderManagerFactory.CreateAsync(new SegmentManagerParameters()
{
Source = source
}, ContentType, _playbackCancellationTokenSource.Token).ConfigureAwait(false);
if (null == _readerManager)
{
Debug.WriteLine("SmMediaManager.OpenAsync() unable to create reader manager");
SetMediaState(MediaManagerState.Error, "Unable to create reader");
return;
}
else
{
readerTasks = _readerManager.SegmentManagerReaders.Select(CreateReaderPipeline).ToArray();
_readers = await TaskEx.WhenAll <IMediaReader>(readerTasks).ConfigureAwait(false);
foreach (IMediaReader mediaReader in _readers)
{
mediaReader.IsEnabled = true;
}
TimeSpan timeSpan = await _readerManager.StartAsync(_playbackCancellationTokenSource.Token).ConfigureAwait(false);
_mediaStreamConfigurator.MediaManager = (this);
StartReaders();
return;
}
}
catch (OperationCanceledException ex)
{
SetMediaState(MediaManagerState.Error, "Media play canceled");
exception = ex;
}
catch (Exception ex)
{
Debug.WriteLine("SmMediaManager.OpenAsync() failed: " + ex.Message);
SetMediaState(MediaManagerState.Error, "Unable to play media");
exception = new AggregateException(ex.Message, ex);
}
await CleanupFailedOpenAsync(readerTasks);
throw exception;
}
private async Task CloseCleanupAsync()
{
Debug.WriteLine("SmMediaManager.CloseCleanupAsync()");
List <Task> tasks = new List <Task>();
ISegmentReaderManager readerManager = this._readerManager;
if (null != readerManager)
{
this._readerManager = (ISegmentReaderManager)null;
tasks.Add(readerManager.StopAsync());
}
IMediaStreamConfigurator msc = this._mediaStreamConfigurator;
if (null != msc)
{
tasks.Add(msc.CloseAsync());
}
if (this._readers != null && this._readers.Length > 0)
{
tasks.Add(this.CloseReadersAsync());
}
if (null != this._playTask)
{
tasks.Add(this._playTask);
}
if (tasks.Count > 0)
{
while (Enumerable.Any <Task>((IEnumerable <Task>)tasks, (Func <Task, bool>)(t => !t.IsCompleted)))
{
try
{
Task t = TaskEx.Delay(2500);
Debug.WriteLine("SmMediaManager.CloseCleanupAsync() waiting for tasks");
Task task = await TaskEx.WhenAny(t, TaskEx.WhenAll((IEnumerable <Task>)tasks)).ConfigureAwait(false);
Debug.WriteLine("SmMediaManager.CloseCleanupAsync() finished tasks");
}
catch (Exception ex)
{
Debug.WriteLine("SmMediaManager.CloseCleanupAsync() play task failed: " + ExceptionExtensions.ExtendedMessage(ex));
}
}
}
if (null != msc)
{
msc.MediaManager = (IMediaManager)null;
}
this.DisposeReaders();
if (null != readerManager)
{
DisposeExtensions.DisposeSafe((IDisposable)readerManager);
}
}
private async Task CloseCleanupAsync()
{
Debug.WriteLine("SmMediaManager.CloseCleanupAsync()");
List <Task> tasks = new List <Task>();
ISegmentReaderManager readerManager = _readerManager;
if (null != readerManager)
{
_readerManager = null;
tasks.Add(readerManager.StopAsync());
}
IMediaStreamConfigurator msc = _mediaStreamConfigurator;
if (null != msc)
{
tasks.Add(msc.CloseAsync());
}
if (_readers != null && _readers.Length > 0)
{
tasks.Add(CloseReadersAsync());
}
if (null != _playTask)
{
tasks.Add(_playTask);
}
if (tasks.Count > 0)
{
while (tasks.Any(t => !t.IsCompleted))
{
try
{
Task t = TaskEx.Delay(2500);
Debug.WriteLine("SmMediaManager.CloseCleanupAsync() waiting for tasks");
Task task = await TaskEx.WhenAny(t, TaskEx.WhenAll(tasks)).ConfigureAwait(false);
Debug.WriteLine("SmMediaManager.CloseCleanupAsync() finished tasks");
}
catch (Exception ex)
{
Debug.WriteLine("SmMediaManager.CloseCleanupAsync() play task failed: " + ex.ExtendedMessage());
}
}
}
if (null != msc)
{
msc.MediaManager = null;
}
DisposeReaders();
readerManager?.DisposeSafe();
}
public static async Task <TimeSpan> StartAsync(this ISegmentReaderManager segmentManager, CancellationToken cancellationToken)
{
await segmentManager.StartAsync().ConfigureAwait(false);
return(await segmentManager.SeekAsync(TimeSpan.Zero, cancellationToken).ConfigureAwait(false));
}
async Task CleanupFailedOpenAsync(Task<IMediaReader>[] readerTasks)
{
Debug.WriteLine("SmMediaManager.CleanupFailedOpenAsync() state " + State);
_playbackCancellationTokenSource.Cancel();
if (null == _readers && null != readerTasks)
{
// Clean up any stragglers.
_readers = readerTasks.Where(
r =>
{
if (null == r)
return false;
var readerException = r.Exception;
if (null != readerException)
{
Debug.WriteLine("SmMediaManager.CleanupFailedOpenAsync(): reader create failed: " + readerException.Message);
return false;
}
return r.IsCompleted;
})
.Select(r => r.Result)
.ToArray();
await CloseReadersAsync().ConfigureAwait(false);
DisposeReaders();
}
if (null != _readerManager)
{
_readerManager.DisposeSafe();
_readerManager = null;
}
}
async Task OpenAsync(ICollection<Uri> source)
{
Debug.WriteLine("SmMediaManager.OpenAsync() state " + State);
State = MediaManagerState.Opening;
++_openCount;
ResetCancellationToken();
Exception exception;
Task<IMediaReader>[] readerTasks = null;
try
{
_mediaStreamConfigurator.Initialize();
_readerManager = await _segmentReaderManagerFactory.CreateAsync(
new SegmentManagerParameters
{
Source = source,
ContentType = ContentType,
StreamContentType = StreamContentType
}, _playbackCancellationTokenSource.Token).ConfigureAwait(false);
if (null == _readerManager)
{
Debug.WriteLine("SmMediaManager.OpenAsync() unable to create reader manager");
SetMediaState(MediaManagerState.Error, "Unable to create reader");
return;
}
readerTasks = _readerManager.SegmentManagerReaders
.Select(CreateReaderPipeline)
.ToArray();
_readers = await Task.WhenAll(readerTasks)
.ConfigureAwait(false);
foreach (var reader in _readers)
reader.IsEnabled = true;
await _readerManager.StartAsync(_playbackCancellationTokenSource.Token).ConfigureAwait(false);
_mediaStreamConfigurator.MediaManager = this;
StartReaders();
return;
}
catch (OperationCanceledException ex)
{
SetMediaState(MediaManagerState.Error, "Media play canceled");
exception = ex;
}
catch (Exception ex)
{
Debug.WriteLine("SmMediaManager.OpenAsync() failed: " + ex.Message);
SetMediaState(MediaManagerState.Error, "Unable to play media");
exception = new AggregateException(ex.Message, ex);
}
await CleanupFailedOpenAsync(readerTasks);
throw exception;
}
async Task CloseCleanupAsync()
{
Debug.WriteLine("SmMediaManager.CloseCleanupAsync()");
var tasks = new List<Task>();
var readerManager = _readerManager;
if (null != readerManager)
{
//Debug.WriteLine("SmMediaManager.CloseCleanupAsync() calling readerManager.StopAsync()");
_readerManager = null;
tasks.Add(readerManager.StopAsync());
}
var msc = _mediaStreamConfigurator;
if (null != msc)
tasks.Add(msc.CloseAsync());
if (null != _readers && _readers.Length > 0)
tasks.Add(CloseReadersAsync());
if (null != _playTask)
tasks.Add(_playTask);
if (tasks.Count > 0)
{
while (tasks.Any(t => !t.IsCompleted))
try
{
var t = Task.Delay(2500);
Debug.WriteLine("SmMediaManager.CloseCleanupAsync() waiting for tasks");
await Task.WhenAny(t, Task.WhenAll(tasks)).ConfigureAwait(false);
Debug.WriteLine("SmMediaManager.CloseCleanupAsync() finished tasks");
}
catch (Exception ex)
{
Debug.WriteLine("SmMediaManager.CloseCleanupAsync() play task failed: " + ex.ExtendedMessage());
}
}
if (null != msc)
msc.MediaManager = null;
DisposeReaders();
readerManager?.DisposeSafe();
}
