/// <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);
}
