Esempio n. 1
0
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (value is Character character)
            {
                var source = new CustomStreamImageSource
                {
                    // FFImageLoading uses a unique key value to cache the image, I use the data item's ID
                    Key = character.Id.ToString(),

                    Stream = (token) => Task.FromResult(_client.GetStreamAsync(character.Image.ThumbUrl).Result)
                };

                // this will be returned to the CachedImage instance
                return(source);
            }

            return(null);
        }
Esempio n. 2
0
        public async override void OnNavigatedTo(INavigationParameters parameters)
        {
            base.OnNavigatedTo(parameters);

            if (parameters.ContainsKey("ImageInfos"))
            {
                parameters.TryGetValue("ImageInfos", out List <string> images);

                foreach (var url in images)
                {
                    try
                    {
                        var config = new FFImageLoading.Config.Configuration()
                        {
                            ExecuteCallbacksOnUIThread = true
                        };
                        byte[]      byteArray;
                        CacheStream cacheStream = null;
                        try
                        {
                            cacheStream = await ImageService.Instance.Config.DownloadCache.DownloadAndCacheIfNeededAsync(url,
                                                                                                                         ImageService.Instance.LoadUrl(url),
                                                                                                                         ImageService.Instance.Config,
                                                                                                                         CancellationToken.None);
                        }
                        catch (Exception)
                        {
                            var timg = "Wesley.Client.Resources/images/loading.gif";
                            cacheStream = await ImageService.Instance.Config.DownloadCache.DownloadAndCacheIfNeededAsync(timg,
                                                                                                                         ImageService.Instance.LoadUrl(timg),
                                                                                                                         ImageService.Instance.Config,
                                                                                                                         CancellationToken.None);
                        }

                        if (cacheStream != null)
                        {
                            using (cacheStream.ImageStream)
                                using (var memoryStream = new MemoryStream())
                                {
                                    await cacheStream.ImageStream.CopyToAsync(memoryStream);

                                    byteArray = memoryStream.ToArray();
                                }

                            var tp = new CustomStreamImageSource()
                            {
                                Key    = url,
                                Stream = (token) => Task.FromResult <Stream>(new MemoryStream(byteArray))
                            };

                            ImagesUrls.Add(tp);
                        }
                    }
                    catch (Exception)
                    {
                    }
                }
                ;

                if (ImagesUrls.Count > 0)
                {
                    this.ImagesUrls = new ObservableRangeCollection <ImageSource>(ImagesUrls);
                }
            }
        }