/// <summary> /// Write a data to local cache folder. /// </summary> /// <param name="this">The image cacher</param> /// <param name="relativePath">Path relative to temporary folder to file where a data will be stored</param> /// <param name="cancellationToken">The token to monitor for cancellation requests.</param> /// <param name="getStream">Provide a stream which must be written to cache</param> /// <returns>Full path to file where a cached data is stored</returns> /// <remarks> /// This function will create a subfolder and a file if not exists in path relative to cache folder. Then /// open it and call a getStream callback to copy an incomming data. /// </remarks> public static Task <string> CacheAsync(this IImageCacher @this, string relativePath, CancellationToken cancellationToken, Func <Stream> getStream) { return(@this.CacheAsync(relativePath, cancellationToken, async(s, ct) => { using (var stream = getStream()) await stream.CopyToAsync(s, 80 * 1024, ct); })); }
public async Task <ToastImageSource> FromResourceAsync(string resourcePath, Assembly assembly, CancellationToken cancellationToken = default) { var asn = assembly.GetName(); var fullFn = await imageCacher.CacheAsync( resourceToFileNameStrategy.Convert(resourcePath, assembly), cancellationToken, () => assembly.GetManifestResourceStream(resourcePath)); var result = await FromFileAsync(fullFn, cancellationToken); return(result); }
public async Task <ToastImageSource> FromUriAsync(Uri uri, CancellationToken cancellationToken = default) { string contentType = ""; var fullFn = await imageCacher.CacheAsync(uriToFileNameStrategy.Convert(uri), cancellationToken, async (stream, ct) => { var hc = httpClientFactory.CreateClient(nameof(IToastImageSourceFactory)); using (var response = await hc.GetAsync(uri)) { contentType = response.Content.Headers.ContentType.MediaType; using (var src = await response.Content.ReadAsStreamAsync()) await src.CopyToAsync(stream, 1024 * 80, cancellationToken); } }); if (string.IsNullOrEmpty(contentType)) { using (var fs = File.OpenRead(fullFn)) contentType = await mimeDetector.DetectAsync(fs); } return(new SealedToastImageSource(CreateAttachment(uri.ToString(), NSUrl.FromFilename(fullFn), UTType.CreatePreferredIdentifier(UTType.TagClassMIMEType, contentType, null)))); }
/// <summary> /// Write a data to local cache folder. /// </summary> /// <param name="this">The image cacher</param> /// <param name="relativePath">Path relative to temporary folder to file where a data will be stored</param> /// <param name="getStream">Provide a stream which must be written to cache</param> /// <returns>Full path to file where a cached data is stored</returns> /// <remarks> /// This function will create a subfolder and a file if not exists in path relative to cache folder. Then /// open it and call a getStream callback to copy an incomming data. /// </remarks> public static Task <string> CacheAsync(this IImageCacher @this, string relativePath, Func <Stream> getStream) => @this.CacheAsync(relativePath, default, getStream);
/// <summary> /// Write a data to local cache folder. /// </summary> /// <param name="this">The image cacher</param> /// <param name="relativePath">Path relative to temporary folder to file where a data will be stored</param> /// <param name="getStreamAsync">Provide a stream which must be written to cache</param> /// <returns>Full path to file where a cached data is stored</returns> /// <remarks> /// This function will create a subfolder and a file if not exists in path relative to cache folder. Then /// open it and call a getStreamAsync callback to copy an incomming data. /// </remarks> public static Task <string> CacheAsync(this IImageCacher @this, string relativePath, Func <CancellationToken, Task <Stream> > getStreamAsync) => @this.CacheAsync(relativePath, default, getStreamAsync);
/// <summary> /// Write a data to local cache folder. /// </summary> /// <param name="this">The image cacher</param> /// <param name="relativePath">Path relative to temporary folder to file where a data will be stored</param> /// <param name="copyToAsync">Callback which will write to provided file stream</param> /// <returns>Full path to file where a cached data is stored</returns> /// <remarks> /// This function will create a subfolder and a file if not exists in path relative to cache folder. Then /// open it and call a copyToAsync callback with a file stream as a parameter. /// </remarks> public static Task <string> CacheAsync(this IImageCacher @this, string relativePath, Func <Stream, CancellationToken, Task> copyToAsync) => @this.CacheAsync(relativePath, default, copyToAsync);