/// <summary> /// Submits a request for prefetching to the disk cache. /// </summary> /// <param name="uri">The image uri.</param> /// <param name="token">The cancellation token.</param> /// <returns> /// An IDataSource that can safely be ignored. /// </returns> public Task PrefetchToDiskCacheAsync( Uri uri, CancellationToken token = default(CancellationToken)) { var taskCompletionSource = new TaskCompletionSource <object>(); var dataSource = PrefetchToDiskCache(ImageRequest.FromUri(uri), null); var dataSubscriber = new BaseDataSubscriberImpl <object>( response => { taskCompletionSource.SetResult(null); return(Task.CompletedTask); }, response => { Exception error = response.GetFailureCause(); taskCompletionSource.SetException(error); }); dataSource.Subscribe(dataSubscriber, _handleResultExecutor); token.Register(() => { dataSource.Close(); taskCompletionSource.TrySetCanceled(); }); return(taskCompletionSource.Task); }
public void getSize(string uriString, IPromise promise) { if (string.IsNullOrEmpty(uriString)) { promise.Reject(ErrorInvalidUri, "Cannot get the size of an image for an empty URI."); return; } var uri = new Uri(uriString); var imagePipeline = ImagePipelineFactory.Instance.GetImagePipeline(); var request = ImageRequestBuilder.NewBuilderWithSource(uri).Build(); var dataSource = imagePipeline.FetchDecodedImage(request, null); var dataSubscriber = new BaseDataSubscriberImpl <CloseableReference <CloseableImage> >( response => { if (!response.IsFinished()) { return(Task.CompletedTask); } CloseableReference <CloseableImage> reference = response.GetResult(); if (reference != null) { try { CloseableImage image = reference.Get(); promise.Resolve(new JObject { { "width", image.Width }, { "height", image.Height }, }); } catch (Exception ex) { promise.Reject(ErrorGetSizeFailure, ex.Message); } finally { CloseableReference <CloseableImage> .CloseSafely(reference); } } else { promise.Reject(ErrorGetSizeFailure, Invariant($"Invalid URI '{uri}' provided.")); } return(Task.CompletedTask); }, response => { promise.Reject(ErrorGetSizeFailure, response.GetFailureCause()); }); dataSource.Subscribe(dataSubscriber, FBCore.Concurrency.CallerThreadExecutor.Instance); }
public void TestFetchDecodedImageSuccess() { var completion = new ManualResetEvent(false); var dataSource = _imagePipeline.FetchDecodedImage(ImageRequest.FromUri(IMAGE_URL), null); var dataSubscriber = new BaseDataSubscriberImpl <CloseableReference <CloseableImage> >( async response => { CloseableReference <CloseableImage> reference = response.GetResult(); if (reference != null) { SoftwareBitmap bitmap = ((CloseableBitmap)reference.Get()).UnderlyingBitmap; try { Assert.IsTrue(bitmap.PixelWidth != 0); Assert.IsTrue(bitmap.PixelHeight != 0); Assert.IsTrue(_imagePipeline.IsInBitmapMemoryCache(ImageRequest.FromUri(IMAGE_URL))); Assert.IsTrue(await _imagePipeline.IsInDiskCacheAsync(IMAGE_URL).ConfigureAwait(false)); } catch (Exception) { Assert.Fail(); } finally { CloseableReference <CloseableImage> .CloseSafely(reference); completion.Set(); } } else { Assert.Fail(); completion.Set(); } }, response => { Assert.Fail(); completion.Set(); }); dataSource.Subscribe(dataSubscriber, CallerThreadExecutor.Instance); completion.WaitOne(); }
public void TestFetchEncodedImageSuccess() { var completion = new ManualResetEvent(false); var dataSource = _imagePipeline.FetchEncodedImage(ImageRequest.FromUri(IMAGE_URL), null); var dataSubscriber = new BaseDataSubscriberImpl <CloseableReference <IPooledByteBuffer> >( async response => { CloseableReference <IPooledByteBuffer> reference = response.GetResult(); if (reference != null) { IPooledByteBuffer inputStream = reference.Get(); try { Assert.IsTrue(inputStream.Size != 0); Assert.IsTrue(await _imagePipeline.IsInDiskCacheAsync(IMAGE_URL).ConfigureAwait(false)); } catch (Exception) { Assert.Fail(); } finally { CloseableReference <IPooledByteBuffer> .CloseSafely(reference); completion.Set(); } } else { Assert.Fail(); completion.Set(); } }, response => { Assert.Fail(); completion.Set(); }); dataSource.Subscribe(dataSubscriber, CallerThreadExecutor.Instance); completion.WaitOne(); }
public async Task TestCancellingPrefetchToDiskCache1() { var failed = false; var dataSource = _imagePipeline.PrefetchToDiskCache(ImageRequest.FromUri(IMAGE4_URL), null); var dataSubscriber = new BaseDataSubscriberImpl <object>( response => { failed = true; return(Task.CompletedTask); }, response => { failed = true; }); dataSource.Subscribe(dataSubscriber, CallerThreadExecutor.Instance); dataSource.Close(); Assert.IsFalse(failed); Assert.IsFalse(await _imagePipeline.IsInDiskCacheAsync(IMAGE4_URL).ConfigureAwait(false)); }
public async Task TestCancellingFetchEncodedImage1() { var failed = false; var dataSource = _imagePipeline.FetchEncodedImage(ImageRequest.FromUri(IMAGE3_URL), null); var dataSubscriber = new BaseDataSubscriberImpl <CloseableReference <IPooledByteBuffer> >( response => { failed = true; return(Task.CompletedTask); }, response => { failed = true; }); dataSource.Subscribe(dataSubscriber, CallerThreadExecutor.Instance); dataSource.Close(); Assert.IsFalse(failed); Assert.IsFalse(await _imagePipeline.IsInDiskCacheAsync(IMAGE3_URL).ConfigureAwait(false)); }
public void TestFetchDecodedImageFail() { var completion = new ManualResetEvent(false); var dataSource = _imagePipeline.FetchDecodedImage(ImageRequest.FromUri(FAILURE_URL), null); var dataSubscriber = new BaseDataSubscriberImpl <CloseableReference <CloseableImage> >( response => { Assert.Fail(); completion.Set(); return(Task.CompletedTask); }, response => { Assert.IsTrue(response.GetFailureCause().GetType() == typeof(IOException)); completion.Set(); }); dataSource.Subscribe(dataSubscriber, CallerThreadExecutor.Instance); completion.WaitOne(); }
public void UpdateImage(Image image, Uri uri) { ImageRequest request = ImageRequestBuilder .NewBuilderWithSource(uri) .SetProgressiveRenderingEnabled(true) .Build(); var dataSource = _imagePipeline.FetchDecodedImage(request, null); var dataSubscriber = new BaseDataSubscriberImpl <CloseableReference <CloseableImage> >( async bitmapDataSource => { if (bitmapDataSource != null) { var reference = bitmapDataSource.GetResult(); try { SoftwareBitmap bitmap = ((CloseableBitmap)reference.Get()).UnderlyingBitmap; await DispatcherHelpers.RunOnDispatcherAsync(() => { var writeableBitmap = new WriteableBitmap(bitmap.PixelWidth, bitmap.PixelHeight); bitmap.CopyToBuffer(writeableBitmap.PixelBuffer); image.Source = writeableBitmap; }) .ConfigureAwait(false); } finally { CloseableReference <CloseableImage> .CloseSafely(reference); } } }, _ => { }); dataSource.Subscribe(dataSubscriber, CallerThreadExecutor.Instance); }
/// <summary> /// Fetches the encoded BitmapImage. /// </summary> /// <param name="uri">The image uri.</param> /// <param name="token">The cancellation token.</param> /// <param name="dispatcher"> /// The current view's dispatcher, used to create BitmapImage. /// </param> /// <returns>The encoded BitmapImage.</returns> /// <exception cref="IOException"> /// If the image uri can't be found. /// </exception> public Task <BitmapImage> FetchEncodedBitmapImageAsync( Uri uri, CancellationToken token = default(CancellationToken), CoreDispatcher dispatcher = null) { var taskCompletionSource = new TaskCompletionSource <BitmapImage>(); var dataSource = FetchEncodedImage(ImageRequest.FromUri(uri), null); var dataSubscriber = new BaseDataSubscriberImpl <CloseableReference <IPooledByteBuffer> >( async response => { CloseableReference <IPooledByteBuffer> reference = response.GetResult(); if (reference != null) { //---------------------------------------------------------------------- // Phong Cao: InMemoryRandomAccessStream can't write anything < 16KB. // http://stackoverflow.com/questions/25928408/inmemoryrandomaccessstream-incorrect-behavior //---------------------------------------------------------------------- IPooledByteBuffer inputStream = reference.Get(); int supportedSize = Math.Max(16 * ByteConstants.KB, inputStream.Size); // Allocate temp buffer for stream convert byte[] bytesArray = default(byte[]); CloseableReference <byte[]> bytesArrayRef = default(CloseableReference <byte[]>); try { bytesArrayRef = _flexByteArrayPool.Get(supportedSize); bytesArray = bytesArrayRef.Get(); } catch (Exception) { // Allocates the byte array since the pool couldn't provide one bytesArray = new byte[supportedSize]; } try { inputStream.Read(0, bytesArray, 0, inputStream.Size); await DispatcherHelpers.CallOnDispatcherAsync(async() => { using (var outStream = new InMemoryRandomAccessStream()) using (var writeStream = outStream.AsStreamForWrite()) { await writeStream.WriteAsync(bytesArray, 0, supportedSize); outStream.Seek(0); BitmapImage bitmapImage = new BitmapImage(); await bitmapImage.SetSourceAsync(outStream).AsTask().ConfigureAwait(false); taskCompletionSource.SetResult(bitmapImage); } }, dispatcher).ConfigureAwait(false); } catch (Exception e) { taskCompletionSource.SetException(e); } finally { CloseableReference <IPooledByteBuffer> .CloseSafely(reference); CloseableReference <byte[]> .CloseSafely(bytesArrayRef); } } else { taskCompletionSource.SetResult(null); } }, response => { taskCompletionSource.SetException(response.GetFailureCause()); }); dataSource.Subscribe(dataSubscriber, _handleResultExecutor); token.Register(() => { dataSource.Close(); taskCompletionSource.TrySetCanceled(); }); return(taskCompletionSource.Task); }