public async Task StartPlayingSoundAsync()
{
AutoResetEvent soundPlaybackCompletedEvent = new AutoResetEvent(false);
bool failed = false;
var tcs = new TaskCompletionSource <object>();
RoutedEventHandler openedLambda = (s, e) =>
tcs.TrySetResult(null);
ExceptionRoutedEventHandler openFailed = (s, e) =>
{
failed = true;
tcs.TrySetResult(null);
};
try
{
soundOutputElement.MediaOpened += openedLambda;
soundOutputElement.MediaFailed += openFailed;
soundOutputElement.Play();
await tcs.Task;
}
finally
{
soundOutputElement.MediaEnded -= openedLambda;
soundOutputElement.MediaFailed -= openFailed;
}
if (failed)
{
throw new Exception("Sound playback failed");
}
}
/// <summary>
/// Determines the duration of the media source.
///
/// </summary>
/// <param name="element"></param>
/// <param name="stream"></param>
/// <returns>the duration</returns>
private static Task <TimeSpan> Duration <T>(this MediaElement element, T source, Action <MediaElement, T> setSource)
{
var tcs = new TaskCompletionSource <TimeSpan>();
RoutedEventHandler handler = null;
handler = (s, e) => {
element.MediaOpened -= handler;
var duration = element.NaturalDuration;
if (duration.HasTimeSpan)
{
tcs.SetResult(duration.TimeSpan);
}
else
{
tcs.SetException(new AudioException("The media element duration is not a TimeSpan."));
}
};
ExceptionRoutedEventHandler errorHandler = null;
errorHandler = (s, e) => {
element.MediaFailed -= errorHandler;
tcs.SetException(new AudioException(e.ErrorMessage));
};
element.MediaOpened += handler;
element.MediaFailed += errorHandler;
setSource(element, source);
return(tcs.Task);
}
public object this[string index]
{
get
{
BitmapImage alreadyLoadedImage = null;
customBitmapsAlreadyChecked.TryGetValue(index, out alreadyLoadedImage);
if (alreadyLoadedImage != null)
{
return(alreadyLoadedImage);
}
else
{
var image = new BitmapImage();
ExceptionRoutedEventHandler failedHandler = null;
failedHandler = (s, e) =>
{
var img = s as BitmapImage;
img.ImageFailed -= failedHandler;
img.UriSource = new Uri("ms-appx:///" + WebBrowserHelper.AssemblyNameWithoutExtension + "/Assets/" + index + ".png");
};
image.ImageFailed += failedHandler;
var customUri = new Uri("ms-appx:///Assets/HockeyApp/" + index + ".png");
image.UriSource = customUri;
customBitmapsAlreadyChecked.Add(index, image);
return(image);
}
}
}
public async static Task <ExceptionRoutedEventArgs> WaitForLoadedAsync(this BitmapImage bitmapImage)
{
var tcs = new TaskCompletionSource <ExceptionRoutedEventArgs>();
// Need to set it to noll so that the compiler does not
// complain about use of unassigned local variable.
RoutedEventHandler reh = null;
ExceptionRoutedEventHandler ereh = null;
reh = (s, e) =>
{
bitmapImage.ImageOpened -= reh;
bitmapImage.ImageFailed -= ereh;
tcs.SetResult(null);
};
ereh = (s, e) =>
{
bitmapImage.ImageOpened -= reh;
bitmapImage.ImageFailed -= ereh;
tcs.SetResult(e);
};
bitmapImage.ImageOpened += reh;
bitmapImage.ImageFailed += ereh;
return(await tcs.Task);
}
public static async Task PlayStreamAsync(this MediaElement mediaElement, IRandomAccessStream stream)
{
// bool is irrelevant here, just using this to flag task completion.
TaskCompletionSource <bool> taskCompleted = new TaskCompletionSource <bool>();
// Note that the MediaElement needs to be in the UI tree for events
// like MediaEnded to fire.
RoutedEventHandler endOfPlayHandler = (s, e) =>
{
taskCompleted.SetResult(true);
};
RoutedEventHandler stateChangedHandler = (s, e) =>
{
if (mediaElement.CurrentState == Windows.UI.Xaml.Media.MediaElementState.Stopped)
{
taskCompleted.SetResult(true);
}
};
ExceptionRoutedEventHandler failedHandler = (s, e) =>
{
taskCompleted.SetResult(true);
};
mediaElement.MediaEnded += endOfPlayHandler;
mediaElement.CurrentStateChanged += stateChangedHandler;
mediaElement.MediaFailed += failedHandler;
mediaElement.SetSource(stream, string.Empty);
mediaElement.Play();
await taskCompleted.Task;
mediaElement.MediaEnded -= endOfPlayHandler;
mediaElement.CurrentStateChanged -= stateChangedHandler;
mediaElement.MediaFailed -= failedHandler;
}
private static async Task WaitOnAllImagesAsync(UIElement el)
{
int countRemaining = 0;
ExceptionRoutedEventHandler failedHandler = new ExceptionRoutedEventHandler(delegate
{
countRemaining--;
});
RoutedEventHandler openedHandler = new RoutedEventHandler(delegate
{
countRemaining--;
});
foreach (var shape in GetAllDescendants(el).OfType <Shape>())
{
if (shape.Fill is ImageBrush)
{
countRemaining++;
(shape.Fill as ImageBrush).ImageFailed += failedHandler;
(shape.Fill as ImageBrush).ImageOpened += openedHandler;
}
}
foreach (var img in GetAllDescendants(el).OfType <Image>())
{
countRemaining++;
img.ImageFailed += failedHandler;
img.ImageOpened += openedHandler;
}
while (countRemaining > 0)
{
await Task.Delay(10);
}
}
public async Task PlayCompleteSoundAsync()
{
AutoResetEvent soundPlaybackCompletedEvent = new AutoResetEvent(false);
string failedMessage = null;
var tcs = new TaskCompletionSource <object>();
RoutedEventHandler endedLambda = (s, e) =>
tcs.TrySetResult(null);
ExceptionRoutedEventHandler endedFailed = (s, e) =>
{
failedMessage = e.ErrorMessage;
tcs.TrySetResult(null);
};
try
{
soundOutputElement.MediaEnded += endedLambda;
soundOutputElement.MediaFailed += endedFailed;
soundOutputElement.Play();
await tcs.Task;
}
finally
{
soundOutputElement.MediaEnded -= endedLambda;
soundOutputElement.MediaFailed -= endedFailed;
}
if (failedMessage != null)
{
throw new Exception("Sound playback error: " + failedMessage);
}
}
private static async Task PlayStreamAsync(IRandomAccessStream stream, string mimeType, CancellationToken token)
{
var tcs = new TaskCompletionSource <Unit>();
token.Register(tcs.SetCanceled);
RoutedEventHandler successHandler = null;
ExceptionRoutedEventHandler failedHandler = null;
var soundPlayer = new MediaElement();
soundPlayer.SetSource(stream, mimeType);
successHandler = (a, s) => tcs.SetResult(Unit.Default);
failedHandler = (a, s) => tcs.SetResult(Unit.Default);
soundPlayer.MediaEnded += successHandler;
soundPlayer.MediaFailed += failedHandler;
soundPlayer.Play();
try
{
await tcs.Task;
}
catch (TaskCanceledException)
{
}
soundPlayer.Stop();
}
// When compiled in Unity in the same assembly it complains about hiding RoutedEventArgs InvokeHandler member
#pragma warning disable 0108
private static void InvokeHandler(Delegate handler, IntPtr sender, IntPtr args)
{
ExceptionRoutedEventHandler handler_ = (ExceptionRoutedEventHandler)handler;
if (handler_ != null)
{
handler_(Noesis.BaseComponent.GetProxy(sender), new ExceptionRoutedEventArgs(args, false));
}
}
/// <summary>
/// Extends BeginInvoke so that when a state object is not needed, null does not need to be passed.
/// <example>
/// exceptionroutedeventhandler.BeginInvoke(sender, e, callback);
/// </example>
/// </summary>
public static IAsyncResult BeginInvoke(this ExceptionRoutedEventHandler exceptionroutedeventhandler, Object sender, ExceptionRoutedEventArgs e, AsyncCallback callback)
{
if (exceptionroutedeventhandler == null)
{
throw new ArgumentNullException("exceptionroutedeventhandler");
}
return(exceptionroutedeventhandler.BeginInvoke(sender, e, callback, null));
}
/// <summary>
/// Remove Image Failed handler
/// </summary>
/// <param name="handler">Exception Routed Event Handler</param>
protected void RemoveImageFailed(ExceptionRoutedEventHandler handler)
{
if (Image is Image image)
{
image.ImageFailed -= handler;
}
else if (Image is ImageBrush brush)
{
brush.ImageFailed -= handler;
}
}
private async Task SlideImage()
{
await _uiLock.WaitAsync();
try
{
var items = _items;
if (items == null || items.Count < 0)
{
return;
}
if (_slideTimer.IsEnabled)
{
_slideTimer.Stop();
}
_currentIndex = _currentIndex % items.Count;
var item = items[_currentIndex++];
var image = new BitmapImage();
ExceptionRoutedEventHandler imageFailedHandler = null;
RoutedEventHandler imageOpenedHandler = null;
imageFailedHandler = (_, __) =>
{
image.ImageFailed -= imageFailedHandler;
_ = SlideImage();
};
image.ImageFailed += imageFailedHandler;
imageOpenedHandler = (_, __) =>
{
image.ImageFailed -= imageFailedHandler;
OnImageSourceLoaded(item);
};
image.ImageOpened += imageOpenedHandler;
ImageSource = image;
await image.SetSourceAsync(await item.File.OpenReadAsync());
}
catch (Exception ex)
{
Log.e(ex);
if (!_slideTimer.IsEnabled)
{
_slideTimer.Start();
}
}
finally
{
_uiLock.Release();
}
}
private static async Task WaitOnAllImagesAsync(UIElement el)
{
int imageCountRemaining = 0;
int totalLoops = 0;
const int maxLoops = 500;
int loopsUnchanged = 0;
ExceptionRoutedEventHandler failedHandler = new ExceptionRoutedEventHandler(delegate
{
imageCountRemaining--;
});
RoutedEventHandler openedHandler = new RoutedEventHandler(delegate
{
imageCountRemaining--;
});
EventHandler <object> layoutHandler = new EventHandler <object>(delegate
{
loopsUnchanged = 0;
});
(el as FrameworkElement).LayoutUpdated += layoutHandler;
foreach (var shape in GetAllDescendants(el).OfType <Shape>())
{
if (shape.Fill is ImageBrush)
{
imageCountRemaining++;
(shape.Fill as ImageBrush).ImageFailed += failedHandler;
(shape.Fill as ImageBrush).ImageOpened += openedHandler;
}
}
foreach (var img in GetAllDescendants(el).OfType <Image>())
{
imageCountRemaining++;
img.ImageFailed += failedHandler;
img.ImageOpened += openedHandler;
}
while (((imageCountRemaining > 0) || (loopsUnchanged < 2)) && (totalLoops < maxLoops))
{
totalLoops++;
loopsUnchanged++;
await Task.Delay(10);
}
(el as FrameworkElement).LayoutUpdated -= layoutHandler;
}
/// <summary>
/// Remove Image Failed handler
/// </summary>
/// <param name="handler">Excpetion Routed Event Handler</param>
protected void RemoveImageFailed(ExceptionRoutedEventHandler handler)
{
var image = Image as Image;
var brush = Image as ImageBrush;
if (image != null)
{
image.ImageFailed -= handler;
}
else if (brush != null)
{
brush.ImageFailed -= handler;
}
}
/// <summary>
/// Install custom event emitters on the given view.
/// </summary>
/// <param name="reactContext">The React context.</param>
/// <param name="view">The view instance.</param>
protected override void AddEventEmitters(ThemedReactContext reactContext, Border view)
{
var imageBrush = (ImageBrush)view.Background;
var imageFailedHandler = new ExceptionRoutedEventHandler(
(sender, args) => OnImageFailed(view, args));
imageBrush.ImageFailed += imageFailedHandler;
var imageOpenedHandler = new RoutedEventHandler(
(sender, args) => OnImageOpened(view, args));
imageBrush.ImageOpened += imageOpenedHandler;
_imageFailedHandlers.Add(view, imageFailedHandler);
}
private async void btnPicture_Click(object sender, RoutedEventArgs e)
{
FileOpenPicker openPicker = new FileOpenPicker();
openPicker.ViewMode = PickerViewMode.Thumbnail;
openPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
openPicker.FileTypeFilter.Add(".jpg");
openPicker.FileTypeFilter.Add(".jpeg");
openPicker.FileTypeFilter.Add(".png");
StorageFile file = await openPicker.PickSingleFileAsync();
if (file != null)
{
var source = new BitmapImage();
var newElement = new C1InlineUIContainer {
Content = source, ContentTemplate = ImageAttach.ImageTemplate
};
ExceptionRoutedEventHandler failed = delegate
{
newElement.Remove();
};
source.ImageFailed += failed;
var stream = await file.OpenAsync(FileAccessMode.Read);
source.SetSource(stream);
using (var dataReader = new DataReader(stream))
{
stream.Seek(0);
var bytes = new byte[stream.Size];
await dataReader.LoadAsync((uint)stream.Size);
dataReader.ReadBytes(bytes);
ImageAttach.SetStream(source, bytes);
}
using (new DocumentHistoryGroup(rtb.DocumentHistory))
{
rtb.Selection.Delete();
rtb.Selection.Start.InsertInline(newElement);
}
rtb.Focus(FocusState.Programmatic);
}
}
public ImageWaiter(UIElement el)
{
if (el == null)
{
return;
}
ExpandShowCards(el);
NormalizeTimePickers(el);
ExceptionRoutedEventHandler failedHandler = new ExceptionRoutedEventHandler(delegate
{
_imageCountRemaining--;
});
RoutedEventHandler openedHandler = new RoutedEventHandler(delegate
{
_imageCountRemaining--;
});
EventHandler <object> layoutHandler = new EventHandler <object>(delegate
{
_loopsUnchanged = 0;
});
(el as FrameworkElement).LayoutUpdated += layoutHandler;
foreach (var shape in UWPTestLibrary.RenderTestHelpers.GetAllDescendants(el).OfType <Shape>())
{
if (shape.Fill is ImageBrush)
{
_imageCountRemaining++;
(shape.Fill as ImageBrush).ImageFailed += failedHandler;
(shape.Fill as ImageBrush).ImageOpened += openedHandler;
}
}
foreach (var img in UWPTestLibrary.RenderTestHelpers.GetAllDescendants(el).OfType <Image>())
{
_imageCountRemaining++;
img.ImageFailed += failedHandler;
img.ImageOpened += openedHandler;
}
}
public async static Task <ExceptionRoutedEventArgs> WaitForLoadedAsync(this BitmapImage bitmapImage)
{
var tcs = new TaskCompletionSource <ExceptionRoutedEventArgs>();
// TODO: NOTE: This returns immediately if the image is already loaded,
// but if the image already failed to load - the task will never complete and the app might hang.
if (bitmapImage.PixelWidth > 0 ||
bitmapImage.PixelHeight > 0)
{
tcs.SetResult(null);
return(await tcs.Task);
}
// Need to set it to null so that the compiler does not
// complain about use of unassigned local variable.
RoutedEventHandler reh = null;
ExceptionRoutedEventHandler ereh = null;
reh = (s, e) =>
{
bitmapImage.ImageOpened -= reh;
bitmapImage.ImageFailed -= ereh;
tcs.SetResult(null);
};
ereh = (s, e) =>
{
bitmapImage.ImageOpened -= reh;
bitmapImage.ImageFailed -= ereh;
tcs.SetResult(e);
};
bitmapImage.ImageOpened += reh;
bitmapImage.ImageFailed += ereh;
return(await tcs.Task);
}
public override void SpriteSetup(Canvas canvas)
{
bool failed = false;
var tcs = new TaskCompletionSource <object>();
AutoResetEvent loadCompletedEvent = new AutoResetEvent(false);
RoutedEventHandler endedLambda = (s, e) =>
{
if (!widthSet)
{
this.widthValue = spriteBitmapImage.PixelWidth;
}
if (!heightSet)
{
this.heightValue = spriteBitmapImage.PixelHeight;
}
aspectRatio = (double)spriteBitmapImage.PixelWidth / (double)spriteBitmapImage.PixelHeight;
spriteImage.Visibility = Visibility.Collapsed;
tcs.TrySetResult(null);
};
ExceptionRoutedEventHandler endedFailed = (s, e) =>
{
failed = true;
tcs.TrySetResult(null);
};
Task doit = runAsync(
async() =>
{
try {
spriteImage = new Image();
spriteImage.Stretch = Stretch.Fill;
elementValue = spriteImage;
canvas.Children.Add(elementValue);
Uri imageURI = new Uri(imageURL, UriKind.RelativeOrAbsolute);
spriteBitmapImage = new BitmapImage();
spriteBitmapImage.ImageFailed += endedFailed;
spriteBitmapImage.ImageOpened += endedLambda;
spriteBitmapImage.UriSource = imageURI;
spriteImage.Source = spriteBitmapImage;
await tcs.Task;
if (failed)
{
imageURI = new Uri("ms-appx:///Images/ImageNotFound.png");
spriteBitmapImage.UriSource = imageURI;
spriteImage.Source = spriteBitmapImage;
await tcs.Task;
}
loadCompletedEvent.Set();
}
finally
{
spriteBitmapImage.ImageFailed -= endedFailed;
spriteBitmapImage.ImageOpened -= endedLambda;
}
loadCompletedEvent.Set();
});
loadCompletedEvent.WaitOne();
}
public bool DoDisplayUrlImage(Uri imageURI, Image graphicsImage)
{
AutoResetEvent DisplayComplete = new AutoResetEvent(false);
AutoResetEvent loadCompletedEvent = new AutoResetEvent(false);
BitmapImage result = null;
bool failed = false;
var tcs = new TaskCompletionSource <object>();
RoutedEventHandler endedLambda = (s, e) =>
tcs.TrySetResult(null);
ExceptionRoutedEventHandler endedFailed = (s, e) =>
{
failed = true;
tcs.TrySetResult(null);
};
InvokeOnUIThread(
async() =>
{
if (graphicsImage.Opacity == 1)
{
await FadeElements.FadeElementOpacityAsync(graphicsImage, 1, 0, new TimeSpan(0, 0, 1));
}
try
{
result = new BitmapImage();
result.ImageFailed += endedFailed;
result.ImageOpened += endedLambda;
try
{
result.UriSource = imageURI;
graphicsImage.Width = graphicsCanvas.ActualWidth;
graphicsImage.Height = graphicsCanvas.ActualHeight;
graphicsImage.Source = result;
await tcs.Task;
}
catch
{
failed = true;
}
if (failed)
{
imageURI = new Uri("ms-appx:///Images/ImageNotFound.png");
result.UriSource = imageURI;
graphicsImage.Source = result;
await tcs.Task;
}
}
finally
{
result.ImageFailed -= endedFailed;
result.ImageOpened -= endedLambda;
}
await FadeElements.FadeElementOpacityAsync(graphicsImage, 0, 1, new TimeSpan(0, 0, 1));
DisplayComplete.Set();
});
DisplayComplete.WaitOne();
return(!failed);
}
/// <summary>
/// Waits for the BitmapImage to load.
/// </summary>
/// <param name="bitmapImage">The bitmap image.</param>
/// <param name="timeoutInMs">The timeout in ms.</param>
/// <returns></returns>
public async static Task <ExceptionRoutedEventArgs> WaitForLoadedAsync(this BitmapImage bitmapImage, int timeoutInMs = 0)
{
var tcs = new TaskCompletionSource <ExceptionRoutedEventArgs>();
// TODO: NOTE: This returns immediately if the image is already loaded,
// but if the image already failed to load - the task will never complete and the app might hang.
if (bitmapImage.PixelWidth > 0 ||
bitmapImage.PixelHeight > 0)
{
tcs.SetResult(null);
return(await tcs.Task);
}
//var tc = new TimeoutCheck(bitmapImage);
// Need to set it to null so that the compiler does not
// complain about use of unassigned local variable.
RoutedEventHandler reh = null;
ExceptionRoutedEventHandler ereh = null;
EventHandler <object> progressCheckTimerTickHandler = null;
var progressCheckTimer = new DispatcherTimer();
Action dismissWatchmen = () =>
{
bitmapImage.ImageOpened -= reh;
bitmapImage.ImageFailed -= ereh;
progressCheckTimer.Tick -= progressCheckTimerTickHandler;
progressCheckTimer.Stop();
//tc.Stop();
};
int totalWait = 0;
progressCheckTimerTickHandler = (sender, o) =>
{
totalWait += 10;
if (bitmapImage.PixelWidth > 0)
{
dismissWatchmen.Invoke();
tcs.SetResult(null);
}
else if (timeoutInMs > 0 && totalWait >= timeoutInMs)
{
dismissWatchmen.Invoke();
tcs.SetResult(null);
//ErrorMessage = string.Format("BitmapImage loading timed out after {0}ms for {1}.", totalWait, bitmapImage.UriSource)
}
};
progressCheckTimer.Interval = TimeSpan.FromMilliseconds(10);
progressCheckTimer.Tick += progressCheckTimerTickHandler;
progressCheckTimer.Start();
reh = (s, e) =>
{
dismissWatchmen.Invoke();
tcs.SetResult(null);
};
ereh = (s, e) =>
{
dismissWatchmen.Invoke();
tcs.SetResult(e);
};
bitmapImage.ImageOpened += reh;
bitmapImage.ImageFailed += ereh;
return(await tcs.Task);
}
public bool DoDisplayUrlImage(string imageURL, Image graphicsImage, int width, int height)
{
AutoResetEvent DisplayComplete = new AutoResetEvent(false);
AutoResetEvent loadCompletedEvent = new AutoResetEvent(false);
BitmapImage result = null;
bool failed = false;
var tcs = new TaskCompletionSource <object>();
RoutedEventHandler endedLambda = (s, e) =>
tcs.TrySetResult(null);
ExceptionRoutedEventHandler endedFailed = (s, e) =>
{
failed = true;
tcs.TrySetResult(null);
};
InvokeOnUIThread(
async() =>
{
if (graphicsImage.Opacity == 1)
{
await FadeElements.FadeElementOpacityAsync(graphicsImage, 1, 0, new TimeSpan(0, 0, 1));
}
try
{
Uri imageURI = new Uri(imageURL, UriKind.RelativeOrAbsolute);
result = new BitmapImage();
result.ImageFailed += endedFailed;
result.ImageOpened += endedLambda;
result.UriSource = imageURI;
graphicsImage.Source = result;
await tcs.Task;
if (failed)
{
imageURI = new Uri("ms-appx:///Images/ImageNotFound.png");
result.UriSource = imageURI;
graphicsImage.Source = result;
await tcs.Task;
}
}
finally
{
result.ImageFailed -= endedFailed;
result.ImageOpened -= endedLambda;
}
graphicsImage.Width = width;
graphicsImage.Height = height;
graphicsImage.HorizontalAlignment = HorizontalAlignment.Stretch;
await FadeElements.FadeElementOpacityAsync(graphicsImage, 0, 1, new TimeSpan(0, 0, 1));
DisplayComplete.Set();
});
DisplayComplete.WaitOne();
return(!failed);
}
