public static IImageSourceHandler GetHandler(this ImageSource source)
{
IImageSourceHandler returnValue = null;
if (source is UriImageSource)
returnValue = new ImageLoaderSourceHandler();
else if (source is FileImageSource)
returnValue = new FileImageSourceHandler();
else if (source is StreamImageSource)
returnValue = new StreamImagesourceHandler();
return returnValue;
}
/// <summary>
/// Returns the proper <see cref="T:Xamarin.Forms.Platform.iOS.IImageSourceHandler"/>
/// based on the type of <see cref="T:Xamarin.Forms.ImageSource"/> provided.
/// </summary>
/// <param name="source">The <see cref="T:Xamarin.Forms.ImageSource"/> to get the handler for.</param>
/// <returns>
/// The needed handler.
/// </returns>
private static IImageSourceHandler GetHandler(ImageSource source)
{
var imageSourceHandler = (IImageSourceHandler)null;
if(source is UriImageSource)
imageSourceHandler = new ImageLoaderSourceHandler();
else if(source is FileImageSource)
imageSourceHandler = new FileImageSourceHandler();
else if(source is StreamImageSource)
imageSourceHandler = new StreamImagesourceHandler();
return imageSourceHandler;
}
private static IImageSourceHandler GetHandler(Xamarin.Forms.ImageSource source)
{
IImageSourceHandler returnValue = null;
if (source is Xamarin.Forms.UriImageSource)
{
returnValue = new UriImageSourceHandler();
}
else if (source is Xamarin.Forms.FileImageSource)
{
returnValue = new FileImageSourceHandler();
}
else if (source is Xamarin.Forms.StreamImageSource)
{
returnValue = new StreamImageSourceHandler();
}
return(returnValue);
}
/// <summary>
/// Helper method to initialize the respective <see cref="IImageSourceHandler"/> to native <see cref="ImageView"/> using <see cref="SfImage.Source"/> property.
/// </summary>
/// <param name="source">Represents the <see cref="ImageSource"/>.</param>
/// <returns>Returns the <see cref="IImageSourceHandler"/> based on <see cref="ImageSource"/>.</returns>
private IImageSourceHandler GetHandler(ImageSource source)
{
IImageSourceHandler sourcehandler = null;
if (source is UriImageSource)
{
sourcehandler = new ImageLoaderSourceHandler();
}
else if (source is FileImageSource)
{
sourcehandler = new FileImageSourceHandler();
}
else if (source is StreamImageSource)
{
sourcehandler = new StreamImagesourceHandler();
}
return(sourcehandler);
}
public static Task <UIImage> ToUIImage(this ImageSource imageSource)
{
IImageSourceHandler handler = null;
if (imageSource is UriImageSource)
{
handler = new ImageLoaderSourceHandler();
}
else if (imageSource is FileImageSource)
{
handler = new FileImageSourceHandler();
}
else if (imageSource is StreamImageSource)
{
handler = new StreamImagesourceHandler();
}
return(handler.LoadImageAsync(imageSource));
}
private IImageSourceHandler GetHandler(Xamarin.Forms.ImageSource imageSource)
{
IImageSourceHandler returnValue = null;
if (imageSource is Xamarin.Forms.UriImageSource)
{
returnValue = new ImageLoaderSourceHandler();
}
else if (imageSource is Xamarin.Forms.FileImageSource)
{
returnValue = new FileImageSourceHandler();
}
else if (imageSource is Xamarin.Forms.StreamImageSource)
{
returnValue = new StreamImagesourceHandler();
}
return(returnValue);
}
private static Task <UIImage> GetImageFromImageSourceAsync(ImageSource imageSource)
{
IImageSourceHandler handler = null;
if (imageSource is FileImageSource)
{
handler = new FileImageSourceHandler();
}
else if (imageSource is StreamImageSource)
{
handler = new StreamImagesourceHandler();
}
else if (imageSource is UriImageSource)
{
handler = new ImageLoaderSourceHandler();
}
return(handler?.LoadImageAsync(imageSource));
}
private static IImageSourceHandler GetHandler(ImageSource source)
{
IImageSourceHandler returnValue = null;
if (source is UriImageSource)
{
returnValue = new ImageLoaderSourceHandler();
}
else if (source is FileImageSource)
{
returnValue = new FileImageSourceHandler();
}
else if (source is StreamImageSource)
{
returnValue = new StreamImagesourceHandler();
}
return(returnValue);
}
async void IPicture.SavePictureToDisk(ImageSource imgSrc, string fileName)
{
var renderer = new FileImageSourceHandler();
var photo = await renderer.LoadImageAsync(imgSrc, Android.App.Application.Context);
if (photo == null)
{
#if DEBUG
Console.WriteLine("!!!LoadImage failed!!!");
#endif
return;
}
var dir = Android.OS.Environment.GetExternalStoragePublicDirectory(Android.OS.Environment.DirectoryDcim);
var Dcim = dir.AbsolutePath;
string cameraFolder = System.IO.Path.Combine(Dcim, "Camera");
string jpgFileName = System.IO.Path.Combine(cameraFolder, fileName);
#if DEBUG
Console.WriteLine("!!!file path to save: " + jpgFileName);
#endif
try
{
var stream = new FileStream(jpgFileName, FileMode.Create);
photo.Compress(Bitmap.CompressFormat.Jpeg, 100, stream);
stream.Close();
#if DEBUG
Console.WriteLine("!!!!File saved!!!!");
#endif
//mediascan adds the saved image into the gallery
// this code will return error: [SendBroadcastPermission] action:android.intent.action.MEDIA_SCANNER_SCAN_FILE, mPermissionType:0
var mediaScanIntent = new Intent(Intent.ActionMediaScannerScanFile);
mediaScanIntent.SetData(Android.Net.Uri.FromFile(new Java.IO.File(jpgFileName)));
Xamarin.Forms.Forms.Context.SendBroadcast(mediaScanIntent);
}
catch (SystemException e)
{
#if DEBUG
System.Console.WriteLine(e.Message);
#endif
}
}
private Task <Bitmap> GetImageFromImageSourceAsync(ImageSource imageSource)
{
IImageSourceHandler handler = null;
if (imageSource is FileImageSource)
{
handler = new FileImageSourceHandler();
}
else if (imageSource is StreamImageSource)
{
handler = new StreamImagesourceHandler();
}
else if (imageSource is UriImageSource)
{
handler = new ImageLoaderSourceHandler();
}
return(handler?.LoadImageAsync(imageSource, _context));
}
public static IImageSourceHandler GetHandler (this ImageSource source)
{
//Image source handler to return
IImageSourceHandler returnValue = null;
//check the specific source type and return the correct image source handler
if (source is UriImageSource)
{
returnValue = new ImageLoaderSourceHandler();
}
else if (source is FileImageSource)
{
returnValue = new FileImageSourceHandler();
}
else if (source is StreamImageSource)
{
returnValue = new StreamImagesourceHandler();
}
return returnValue;
}
private async void SetSource(System.Windows.Controls.Image image)
{
IImageSourceHandler handler;
var source = (this.Element as BlurImageView).Source;
if (source is FileImageSource)
{
handler = new FileImageSourceHandler();
}
else if (source is StreamImageSource)
{
handler = new StreamImagesourceHandler(); // sic
}
else if (source is UriImageSource)
{
handler = new ImageLoaderSourceHandler(); // sic
}
else
{
throw new NotImplementedException();
}
System.Windows.Media.ImageSource imagesource;
try
{
imagesource = await handler.LoadImageAsync(source, new CancellationToken());
}
catch (TaskCanceledException ex)
{
imagesource = (System.Windows.Media.ImageSource)null;
}
// Blur
if (imagesource is BitmapImage)
{
var bmpImage = imagesource as BitmapImage;
var wr = new WriteableBitmap(bmpImage);
BoxBlurHorizontal(wr, 40);
BoxBlurVertical(wr, 40);
image.Source = wr;
}
}
public static async Task <UIImage> GetUIImage(this ImageSource imageSource, CancellationToken cancellationToken)
{
try
{
IImageSourceHandler handler = null;
if (imageSource is FileImageSource)
{
handler = new FileImageSourceHandler();
}
else if (imageSource is StreamImageSource)
{
handler = new StreamImagesourceHandler();
}
else if (imageSource is UriImageSource)
{
handler = new ImageLoaderSourceHandler();
}
else
{
throw new NotImplementedException("Image source type is not supported.");
}
using (var image = await handler.LoadImageAsync(imageSource, cancellationToken, (float)UIScreen.MainScreen.Scale))
//using (var image = await handler.LoadImageAsync(imageSource))
{
if (image == null)
{
return(null);
}
UIGraphics.BeginImageContext(image.Size);
image.Draw(new CGRect(0, 0, image.Size.Width, image.Size.Height));
return(UIGraphics.GetImageFromCurrentImageContext());
}
//return handler.LoadImageAsync (imageSource, cancellationToken, (float)UIScreen.MainScreen.Scale);
}
catch (Exception ex)
{
return(null);
}
}
public static IImageSourceHandler GetHandler(this ImageSource source)
{
IImageSourceHandler returnValue = null;
switch (source)
{
case UriImageSource _:
returnValue = new ImageLoaderSourceHandler();
break;
case FileImageSource _:
returnValue = new FileImageSourceHandler();
break;
case StreamImageSource _:
returnValue = new StreamImagesourceHandler();
break;
}
return(returnValue);
}
public static IImageSourceHandler GetDefaultHandler(this ImageSource source)
{
IImageSourceHandler handler = null;
if (source is UriImageSource)
{
handler = new ImageLoaderSourceHandler();
}
else if (source is FileImageSource)
{
handler = new FileImageSourceHandler();
}
else if (source is StreamImageSource)
{
handler = new StreamImagesourceHandler();
}
else if (source is FontImageSource)
{
handler = new FontImageSourceHandler();
}
return(handler);
}
private async Task <BitmapDecoder> GetImageFromImageSource(ImageSource imageSource)
{
IImageSourceHandler handler;
if (imageSource is FileImageSource)
{
handler = new FileImageSourceHandler();
}
else if (imageSource is StreamImageSource)
{
handler = new StreamImageSourceHandler();
var stream = await((IStreamImageSource)imageSource).GetStreamAsync();
if (stream != null)
{
return(await BitmapDecoder.CreateAsync(WindowsRuntimeStreamExtensions.AsRandomAccessStream(stream)));
}
}
else if (imageSource is UriImageSource)
{
handler = new UriImageSourceHandler();
}
else
{
throw new NotImplementedException();
}
var bitmapImage = await handler.LoadImageAsync(imageSource) as BitmapImage;
if (bitmapImage?.UriSource != null)
{
using (IRandomAccessStreamWithContentType streamWithContent = await RandomAccessStreamReference.CreateFromUri(bitmapImage.UriSource).OpenReadAsync())
{
return(await BitmapDecoder.CreateAsync(streamWithContent));
}
}
throw new NotImplementedException();
}
private async Task <Bitmap> GetImageFromImageSource(ImageSource imageSource)
{
IImageSourceHandler handler;
if (imageSource is FileImageSource)
{
handler = new FileImageSourceHandler();
}
else if (imageSource is StreamImageSource)
{
handler = new StreamImagesourceHandler(); // sic
}
else if (imageSource is UriImageSource)
{
handler = new ImageLoaderSourceHandler(); // sic
}
else
{
throw new NotImplementedException();
}
return(await handler.LoadImageAsync(imageSource, this.Control.Context));
}
public static Task <Bitmap> GetImage(this ImageSource imageSource)
{
IImageSourceHandler handler = null;
if (imageSource is FileImageSource)
{
handler = new FileImageSourceHandler();
}
else if (imageSource is StreamImageSource)
{
handler = new StreamImagesourceHandler();
}
else if (imageSource is UriImageSource)
{
handler = new ImageLoaderSourceHandler();
}
else
{
throw new NotImplementedException("Image source type is not supported.");
}
return(handler.LoadImageAsync(imageSource, Forms.Context));
}
private async Task <Bitmap> LoadBitmapFromImageSource(Context context, ImageSource imageSource)
{
IImageSourceHandler handler;
if (imageSource is FileImageSource)
{
handler = new FileImageSourceHandler();
}
else if (imageSource is StreamImageSource)
{
handler = new StreamImagesourceHandler();
}
else if (imageSource is UriImageSource)
{
handler = new ImageLoaderSourceHandler();
}
else
{
return(null);
}
return(await handler.LoadImageAsync(imageSource, context));
}
private async Task <UIImage> LoadImageFromImageSource(ImageSource imageSource)
{
IImageSourceHandler handler;
if (imageSource is FileImageSource)
{
handler = new FileImageSourceHandler();
}
else if (imageSource is StreamImageSource)
{
handler = new StreamImagesourceHandler();
}
else if (imageSource is UriImageSource)
{
handler = new ImageLoaderSourceHandler();
}
else
{
return(null);
}
return(await handler.LoadImageAsync(imageSource));
}
public static IImageSourceHandler GetImageSourceHandler(ImageSource source)
{
IImageSourceHandler sourceHandler = null;
if (source is UriImageSource)
{
sourceHandler = new ImageLoaderSourceHandler();
}
else if (source is FileImageSource)
{
sourceHandler = new FileImageSourceHandler();
}
else if (source is StreamImageSource)
{
sourceHandler = new StreamImagesourceHandler();
}
else if (source is FontImageSource)
{
sourceHandler = new FontImageSourceHandler();
}
return(sourceHandler);
}
Task <UIImage> GetImage(ImageSource imageSource)
{
IImageSourceHandler handler;
if (imageSource is FileImageSource)
{
handler = new FileImageSourceHandler();
}
else if (imageSource is StreamImageSource)
{
handler = new StreamImagesourceHandler(); // sic
}
else if (imageSource is UriImageSource)
{
handler = new ImageLoaderSourceHandler(); // sic
}
else
{
throw new NotImplementedException();
}
return(handler.LoadImageAsync(imageSource));
}
protected override void OnElementChanged(VisualElementChangedEventArgs e)
{
base.OnElementChanged(e);
if (e.OldElement is iOSSearchPage oldSearchPage)
{
oldSearchPage.PropertyChanged -= this.OnSearchPagePropertyChanged;
}
if (e.NewElement is iOSSearchPage iosSearchPage)
{
iosSearchPage.PropertyChanged += this.OnSearchPagePropertyChanged;
this.searchController.SearchBar.Placeholder = iosSearchPage.SearchPlaceholder;
this.searchController.SearchBar.Text = iosSearchPage.SearchText;
Task.Run(async() =>
{
if (iosSearchPage.ActionImage != null)
{
try
{
var handler = new FileImageSourceHandler();
var actionImage = await handler.LoadImageAsync(iosSearchPage.ActionImage);
InvokeOnMainThread(() =>
{
this.searchController.SearchBar.SetImageforSearchBarIcon(actionImage, UISearchBarIcon.Bookmark, UIControlState.Normal);
this.searchController.SearchBar.ShowsBookmarkButton = true;
});
}
catch (Exception ex)
{
Debug.WriteLine($"Error loading ActionImage: {ex.Message}");
}
}
});
}
}
private static IImageSourceHandler GetHandler(ImageSource source)
{
IImageSourceHandler returnValue = null;
switch (source)
{
case UriImageSource _:
returnValue = new ImageLoaderSourceHandler();
break;
case FileImageSource _:
returnValue = new FileImageSourceHandler();
break;
case StreamImageSource _:
returnValue = new StreamImagesourceHandler();
break;
case SKBitmapImageSource _:
returnValue = new SKImageSourceHandler();
break;
}
return(returnValue);
}
public async static Task <SKBitmap> BitmapFromNativeFile(string fileName)
{
var imageSource = ImageSource.FromFile(fileName);
IImageSourceHandler imageLoader = new FileImageSourceHandler();
#if __ANDROID__
if (context == null)
{
throw new Exception("ImageLoader not initialized.");
}
Bitmap image = await imageLoader.LoadImageAsync(imageSource, context);
return(image.ToSKBitmap());
#else
UIImage image = await imageLoader.LoadImageAsync(imageSource);
return(image.ToSKBitmap());
//fix the problem of drawing abnormal pixels
//CGImage cgImage = image.CGImage;
//var info = new SKImageInfo((int)cgImage.Width, (int)cgImage.Height);
//var bitmap = new SKBitmap(info);
//using (var pixmap = bitmap.PeekPixels())
//using (var colorSpace = CGColorSpace.CreateDeviceRGB())
//using (var context = new CGBitmapContext(pixmap.GetPixels(), pixmap.Width, pixmap.Height, 8, pixmap.RowBytes, colorSpace, CGBitmapFlags.PremultipliedLast | CGBitmapFlags.ByteOrder32Big))
//{
// CheckBytes(bitmap.Bytes);
// CGRect rect = new CGRect(0, 0, cgImage.Width, cgImage.Height);
// context.ClearRect(rect);
// CheckBytes(bitmap.Bytes);
// context.DrawImage(rect, cgImage);
// CheckBytes(bitmap.Bytes);
//}
//return bitmap;
#endif
}
async void SetMasterLeftBarButton(UIViewController containerController, MasterDetailPage masterDetailPage)
{
if (!masterDetailPage.ShouldShowToolbarButton())
{
containerController.NavigationItem.LeftBarButtonItem = null;
return;
}
EventHandler handler = (o, e) => masterDetailPage.IsPresented = !masterDetailPage.IsPresented;
bool shouldUseIcon = masterDetailPage.Master.Icon != null;
if (shouldUseIcon)
{
try
{
// Simplified the following code because we do not have access to Internals.Registrar.
//
// var source = Internals.Registrar.Registered.GetHandler<IImageSourceHandler>(masterDetailPage.Master.Icon.GetType());
var source = new FileImageSourceHandler();
var icon = await source.LoadImageAsync(masterDetailPage.Master.Icon);
containerController.NavigationItem.LeftBarButtonItem = new UIBarButtonItem(icon, UIBarButtonItemStyle.Plain, handler);
}
catch (Exception)
{
// Throws Exception otherwise would catch more specific exception type
shouldUseIcon = false;
}
}
if (!shouldUseIcon)
{
containerController.NavigationItem.LeftBarButtonItem = new UIBarButtonItem(masterDetailPage.Master.Title, UIBarButtonItemStyle.Plain, handler);
}
}
public async void SavePictureToDisk(ImageSource imgSrc, string fileName)
{
var renderer = new FileImageSourceHandler();
var photo = await renderer.LoadImageAsync(imgSrc);
var documentsDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyPictures);
string jpgFileName = System.IO.Path.Combine(documentsDirectory, fileName);
NSData imgData = photo.AsJPEG();
NSError err = null;
bool saved = imgData.Save(jpgFileName, false, out err);
#if DEBUG
if (saved)
{
Console.WriteLine("!!!!iOS: QRCode file saved!!!");
//return true;
}
else
{
Console.WriteLine("!!!iOS: NOT saved as " + jpgFileName + " because " + err.LocalizedDescription);
//return false;
}
#endif
}
Task <UIImage> GetImage(FileImageSource image)
{
var handler = new FileImageSourceHandler();
return(handler.LoadImageAsync(image));
}
public object ConvertToNative(Brush brush, object context)
{
winMedia.Brush winBrush = null;
// SolidColorBrush
if (brush is SolidColorBrush)
{
SolidColorBrush xamBrush = brush as SolidColorBrush;
winBrush = new winMedia.SolidColorBrush
{
Color = ConvertColor(xamBrush.Color)
};
}
// LinearGradientBrush
else if (brush is LinearGradientBrush)
{
LinearGradientBrush xamBrush = brush as LinearGradientBrush;
winBrush = new winMedia.LinearGradientBrush
{
StartPoint = ConvertPoint(xamBrush.StartPoint),
EndPoint = ConvertPoint(xamBrush.EndPoint),
SpreadMethod = ConvertGradientSpread(xamBrush.SpreadMethod)
};
foreach (GradientStop xamGradientStop in xamBrush.GradientStops)
{
winMedia.GradientStop winGradientStop = new winMedia.GradientStop
{
Color = ConvertColor(xamGradientStop.Color),
Offset = xamGradientStop.Offset
};
(winBrush as winMedia.LinearGradientBrush).GradientStops.Add(winGradientStop);
}
}
else if (brush is ImageBrush)
{
ImageBrush xamBrush = brush as ImageBrush;
winBrush = new winMedia.ImageBrush
{
Stretch = (winMedia.Stretch)(int) xamBrush.Stretch,
AlignmentX = (winMedia.AlignmentX)(int) xamBrush.AlignmentX,
AlignmentY = (winMedia.AlignmentY)(int) xamBrush.AlignmentY,
};
ImageSource xamImageSource = (brush as ImageBrush).ImageSource;
if (xamImageSource != null)
{
IImageSourceHandler handler = null;
if (xamImageSource.GetType() == typeof(FileImageSource))
{
handler = new FileImageSourceHandler();
}
else if (xamImageSource.GetType() == typeof(StreamImageSource))
{
handler = new StreamImageSourceHandler();
}
else if (xamImageSource.GetType() == typeof(UriImageSource))
{
handler = new UriImageSourceHandler();
}
if (handler != null)
{
Task <winMedia.ImageSource> winImageSourceTask = handler.LoadImageAsync(xamImageSource);
winImageSourceTask.ContinueWith((task) =>
{
winFound.IAsyncAction asyncAction = winBrush.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
(winBrush as winMedia.ImageBrush).ImageSource = task.Result;
});
});
}
}
}
if (winBrush != null)
{
winBrush.Transform = brush.Transform?.GetNativeObject() as winMedia.MatrixTransform;
// TODO: RelativeTransform and Opacity
}
return(winBrush);
}
private async Task <Bitmap> GetImageFromImageSource(ImageSource imageSource, Context context)
{
IImageSourceHandler handler;
bool isUriImage = false;
if (imageSource is FileImageSource)
{
handler = new FileImageSourceHandler();
}
else if (imageSource is StreamImageSource)
{
handler = new StreamImagesourceHandler(); // sic
}
else if (imageSource is UriImageSource)
{
isUriImage = true;
handler = new ImageLoaderSourceHandler(); // sic
}
else
{
throw new NotImplementedException();
}
Bitmap originalBitmap = null;
if (isUriImage)
{
var uri = Element.Source.GetValue(UriImageSource.UriProperty) as Uri;
if (imageDownloader.HasLocallyCachedCopy(uri))
{
var bitmap = imageDownloader.GetImage(uri);
if (BaseControl.ImagePlaceholder != null && bitmap == null)
{
}
else
{
originalBitmap = bitmap;
}
}
else
{
await imageDownloader.GetImageAsync(uri).ContinueWith(t =>
{
if (t != null)
{
if (!t.IsFaulted)
{
//imageDownloader.RemoveDownloadProgress(uri);
if (BaseControl == null)
{
return;
}
if (BaseControl.ImagePlaceholder != null && t.Result == null)
{
return;
}
originalBitmap = t.Result;
}
}
}, TaskScheduler.FromCurrentSynchronizationContext());
}
}
else
{
originalBitmap = await handler.LoadImageAsync(imageSource, context);
}
return(originalBitmap);
}
Task <Bitmap> GetBitmap(FileImageSource image)
{
var handler = new FileImageSourceHandler();
return(handler.LoadImageAsync(image, this.Control.Context));
}
internal static IImageSourceHandler GetHandler(this ImageSource source)
{
IImageSourceHandler returnValue = new FileImageSourceHandler();
return(returnValue);
}
