private void AddImageAction(string fakeImagePath, int cropSize, bool isMakePhoto) { Task <MediaFile> imageTask = null; var options = new CameraMediaStorageOptions { DefaultCamera = CameraDevice.Rear, MaxPixelDimension = 400, }; if (isMakePhoto && AppProvider.MediaPicker.IsCameraAvailable) { imageTask = AppProvider.MediaPicker.TakePhotoAsync(options); } else { imageTask = AppProvider.MediaPicker.SelectPhotoAsync(options); } imageTask.ContinueWith(delegate(Task <MediaFile> arg) { MediaFile file = arg.Result; if (file != null) { AppProvider.IOManager.DeleteFile(fakeImagePath); AppProvider.ImageService.CropAndResizeImage(file.Path, fakeImagePath, cropSize); OnImageChanged(); //onExecuted.Invoke(); } }); }
/// <summary> /// Creates the media intent. /// </summary> /// <param name="id">The identifier.</param> /// <param name="type">The type of intent.</param> /// <param name="action">The action.</param> /// <param name="options">The options.</param> /// <param name="tasked">if set to <c>true</c> [tasked].</param> /// <returns>Intent to create media.</returns> private Intent CreateMediaIntent( int id, string type, string action, CameraMediaStorageOptions options, bool tasked = true) { // Create the intent var pickerIntent = new Intent(MediaPickerDroid.Context, typeof(MediaPickerActivity)); pickerIntent.SetFlags(ActivityFlags.NewTask); pickerIntent.PutExtra(MediaPickerActivity.ExtraId, id); pickerIntent.PutExtra(MediaPickerActivity.ExtraType, type); pickerIntent.PutExtra(MediaPickerActivity.ExtraAction, action); pickerIntent.PutExtra(MediaPickerActivity.ExtraTasked, tasked); // Set the additional options if (options != null) { pickerIntent.PutExtra(MediaPickerActivity.ExtraPath, options.Directory); pickerIntent.PutExtra(MediaStore.Images.ImageColumns.Title, options.Name); } // Remove the created intent return(pickerIntent); }
/// <summary> /// Takes the photo from the device camera. /// </summary> private void TakePhoto() { // If the camera available var picker = MediaPicker.Instance; if ((picker != null) && picker.IsCameraAvailable) { // Take the photo var options = new CameraMediaStorageOptions(); var scheduler = TaskScheduler.FromCurrentSynchronizationContext(); var task = picker.TakePhotoAsync(options); if (task != null) { // Process taken photo task.ContinueWith(this.OnPhotoChoosen, scheduler); } else { App.DisplayAlert( Localization.ErrorDialogTitle, Localization.ErrorCameraForbidden, Localization.DialogDismiss); } } else { App.DisplayAlert( Localization.ErrorDialogTitle, Localization.ErrorCameraUnavailable, Localization.DialogDismiss); } }
/// <summary> /// Takes the picture. /// </summary> /// <param name="options">The storage options.</param> /// <returns>Task representing the asynchronous operation.</returns> public override Task <MediaFile> TakePhotoAsync(CameraMediaStorageOptions options) { // Create a new instance of the file picker var filePicker = new FileOpenPicker { SuggestedStartLocation = PickerLocationId.PicturesLibrary, ViewMode = PickerViewMode.Thumbnail }; // Filter to include a sample subset of file types filePicker.FileTypeFilter.Clear(); filePicker.FileTypeFilter.Add(".bmp"); filePicker.FileTypeFilter.Add(".png"); filePicker.FileTypeFilter.Add(".jpeg"); filePicker.FileTypeFilter.Add(".jpg"); // If the choose photo operation is in progress var source = new TaskCompletionSource <MediaFile>(); if (Interlocked.CompareExchange(ref this.completionSource, source, null) != null) { throw new InvalidOperationException("Only one operation can be active at a time"); } // Choose the photo this.view = CoreApplication.GetCurrentView(); filePicker.PickSingleFileAndContinue(); this.view.Activated += this.OnViewActivated; return(this.completionSource.Task); }
/// <summary> /// Setups the controller. /// </summary> /// <param name="mediaDelegate">The media picker delegate.</param> /// <param name="sourceType">Media source type.</param> /// <param name="mediaType">Media type.</param> /// <param name="options">The options.</param> /// <returns>The configured media picker controller.</returns> private static MediaPickerController SetupController( MediaPickerDelegate mediaDelegate, UIImagePickerControllerSourceType sourceType, string mediaType, CameraMediaStorageOptions options = null) { // Create the media picker var picker = new MediaPickerController(mediaDelegate) { MediaTypes = new[] { mediaType }, SourceType = sourceType }; // If the image is from camera if (sourceType == UIImagePickerControllerSourceType.Camera) { if ((mediaType == MediaPickerIOS.TypeImage) && (options != null)) { // Configure the camera picker.CameraDevice = MediaPickerIOS.GetCameraDevice(options.DefaultCamera); picker.CameraCaptureMode = UIImagePickerControllerCameraCaptureMode.Photo; } } return(picker); }
private async Task TakeImage() { var cameraOpts = new CameraMediaStorageOptions(); cameraOpts.PercentQuality = 50; cameraOpts.MaxPixelDimension = 1200; var result = await UIUtils.ShowSelectList("Take a photo", "Choose from library", this); System.Threading.Tasks.Task <MediaFile> taskMedia = null; if (result == 1) { taskMedia = DependencyService.Get <IMediaPicker>().TakePhotoAsync(cameraOpts); } else if (result == 2) { taskMedia = DependencyService.Get <IMediaPicker>().SelectPhotoAsync(cameraOpts); } else { return; } await taskMedia.ContinueWith((t, o) => { if (t.IsCanceled || t.Result == null) { return; } photoFile = t.Result; }, null); }
/// <summary> /// Verifies the camera options. /// </summary> /// <param name="options">The options.</param> /// <exception cref="ArgumentException">options.Camera is not a member of CameraDevice</exception> private static void VerifyCameraOptions(CameraMediaStorageOptions options) { VerifyOptions(options); if (!Enum.IsDefined(typeof(CameraDevice), options.DefaultCamera)) { throw new ArgumentException("options.Camera is not a member of CameraDevice"); } }
/// <summary> /// Select a picture from library. /// </summary> /// <param name="options">The storage options.</param> /// <returns>Task<IMediaFile>.</returns> /// <exception cref="NotSupportedException"></exception> public Task <MediaFile> SelectPhotoAsync(CameraMediaStorageOptions options) { if (!IsPhotosSupported) { throw new NotSupportedException(); } return(GetMediaAsync(UIImagePickerControllerSourceType.PhotoLibrary, TypeImage)); }
private async Task <MediaFile> TakePic() { var mediaStorageOptions = new CameraMediaStorageOptions { DefaultCamera = CameraDevice.Rear }; var mediaFile = await _device.MediaPicker.TakePhotoAsync(mediaStorageOptions); return(mediaFile); }
/// <summary> /// Select a picture from library. /// </summary> /// <param name="options">The storage options.</param> /// <returns>Task with a return type of MediaFile.</returns> /// <exception cref="System.NotSupportedException">Throws an exception if feature is not supported.</exception> public Task <MediaFile> SelectPhotoAsync(CameraMediaStorageOptions options) { if (!IsCameraAvailable) { throw new NotSupportedException(); } options.VerifyOptions(); return(TakeMediaAsync("image/*", Intent.ActionPick, options)); }
// ... //private byte[] ConvertYuvToJpeg(byte[] yuvData, CameraDevice camera) //{ // var cameraParameters = camera.; // var width = cameraParameters.PreviewSize.Width; // var height = cameraParameters.PreviewSize.Height; // var yuv = new YuvImage(yuvData, cameraParameters.PreviewFormat, width, height, null); // var ms = new MemoryStream(); // var quality = 80; // adjust this as needed // yuv.CompressToJpeg(new Rect(0, 0, width, height), quality, ms); // var jpegData = ms.ToArray(); // return jpegData; //} private async Task <MediaFile> TakePic() { var mediaStorageOptions = new CameraMediaStorageOptions { DefaultCamera = CameraDevice.Rear }; var mediaFile = await _device.MediaPicker.TakePhotoAsync(mediaStorageOptions); _recognizedTextLabel.Text = "Loading.."; return(mediaFile); }
/// <summary> /// Takes the picture. /// </summary> /// <param name="options">The storage options.</param> /// <returns>Task with a return type of MediaFile.</returns> /// <exception cref="System.NotSupportedException">Throws an exception if feature is not supported.</exception> public Task <MediaFile> TakePhotoAsync(CameraMediaStorageOptions options) { if (!IsCameraAvailable) { throw new NotSupportedException(); } options.VerifyOptions(); return(TakeMediaAsync("image/*", MediaStore.ActionImageCapture, options)); }
public async Task <MediaFile> TakePhotoAsync(CameraMediaStorageOptions options) { var captureUI = new CameraCaptureUI(); captureUI.PhotoSettings.Format = CameraCaptureUIPhotoFormat.Png; var photo = await captureUI.CaptureFileAsync(CameraCaptureUIMode.Photo); if (photo == null) { return(null); } return(new MediaFile(photo.Name, () => photo.OpenStreamForReadAsync().Result)); }
/// <summary> /// Takes the picture. /// </summary> /// <param name="options">The storage options.</param> /// <returns>Task<IMediaFile>.</returns> /// <exception cref="InvalidOperationException">Only one operation can be active at a time</exception> /// <exception cref="System.NotImplementedException"></exception> public Task <MediaFile> TakePhotoAsync(CameraMediaStorageOptions options) { options.VerifyOptions(); var ntcs = new TaskCompletionSource <MediaFile>(options); if (Interlocked.CompareExchange(ref _completionSource, ntcs, null) != null) { throw new InvalidOperationException("Only one operation can be active at a time"); } _cameraCapture.Show(); return(ntcs.Task); }
/// <summary> /// Takes the picture. /// </summary> /// <param name="options">The storage options.</param> /// <returns>Task<IMediaFile>.</returns> /// <exception cref="NotSupportedException"> /// </exception> public Task <MediaFile> TakePhotoAsync(CameraMediaStorageOptions options) { if (!IsPhotosSupported) { throw new NotSupportedException(); } if (!IsCameraAvailable) { throw new NotSupportedException(); } VerifyCameraOptions(options); return(GetMediaAsync(UIImagePickerControllerSourceType.Camera, TypeImage, options)); }
/// <summary> /// Takes the media asynchronous. /// </summary> /// <param name="type">The type of intent.</param> /// <param name="action">The action.</param> /// <param name="options">The options.</param> /// <returns>Task with a return type of MediaFile.</returns> /// <exception cref="System.InvalidOperationException">Only one operation can be active at a time.</exception> private Task <MediaFile> TakeMediaAsync(string type, string action, CameraMediaStorageOptions options) { // Create the completion source var id = this.GetRequestId(); var source = new TaskCompletionSource <MediaFile>(id); if (Interlocked.CompareExchange(ref this.completionSource, source, null) != null) { throw new InvalidOperationException("Only one operation can be active at a time"); } // Start the media activity MediaPickerDroid.Context.StartActivity(this.CreateMediaIntent(id, type, action, options)); // Set the media picked event handler EventHandler <MediaPickerActivity.MediaPickedEventArgs> handler = null; handler = (s, e) => { // Remove the handler var taskCompletion = Interlocked.Exchange(ref this.completionSource, null); MediaPickerActivity.MediaPicked -= handler; // Validate the request identifier if (e.RequestId != id) { return; } // Set the task result if (e.Error != null) { taskCompletion.SetException(e.Error); } else if (e.IsCanceled) { taskCompletion.SetCanceled(); } else { taskCompletion.SetResult(e.Media); } }; // Register the handler MediaPickerActivity.MediaPicked += handler; return(source.Task); }
public Task <MediaFile> SelectPhotoAsync(CameraMediaStorageOptions options) { var dlg = new OpenFileDialog { Title = "Select Photo For Task" }; var result = dlg.ShowDialog(); if (result == true) { var filename = dlg.FileName; return(Task.FromResult(new MediaFile(filename, () => File.OpenRead(filename)))); } return(Task.FromResult <MediaFile>(null)); }
async void ScanTextBtn_Clicked(object sender, EventArgs e) { scanTextBtn.IsEnabled = false; mainPageBtn.IsEnabled = false; resultLabel.Text = "Opening camera. Might take a while so please be patient!"; originalPhoto.Source = ""; //tesseractille whitelist sallituista merkeistä //tesseractApi.SetVariable("tessedit_char_whitelist", "012345789()/-+*"); //kameran käyttöön optiot HUOM! pienentäminen ei toimi näissä kuin windowsilla var options = new CameraMediaStorageOptions { DefaultCamera = CameraDevice.Rear }; MediaFile picture = await mediaPicker.TakePhotoAsync(options); resultLabel.Text = "Processing image and recognizing text.."; if (picture != null && picture.Source != null) { bool readSuccess = await imageParser.parseTextFromImageASync(picture); if (readSuccess) { originalPhoto.Source = ImageSource.FromStream(() => picture.Source); string calculation = imageParser.returnParsedText(); //tässä rajoitetaan laskutoimituksen pituus if (calculation.Length <= 10) { //HUOM! tässä ei tarkisteta menevää stringiä mitenkään joten ohjelma kaatuu jos sinne pääsee mitäsattuu läpi string result = CalculateString(calculation); resultLabel.Text = calculation + " = " + result; } //jos ei saada järkevää stringiä luettua ts. siitä tulee aivan liian pitkä niin => else { resultLabel.Text = "OCR result unclear, please try again."; } } } scanTextBtn.IsEnabled = true; mainPageBtn.IsEnabled = true; scanTextBtn.Text = "Calculate again"; }
public async Task <MediaFile> TakePhotoAsync(CameraMediaStorageOptions options) { m_photo = await m_captureUI.CaptureFileAsync(CameraCaptureUIMode.Photo); m_Stream = await m_photo.OpenStreamForReadAsync(); // Func<string, string> convert = delegate (string s) // { return s.ToUpper(); }; Func <Stream> conv = new Func <Stream>(getStream);///({ return await m_photo.OpenStreamForReadAsync(); }; MediaFile p = new MediaFile(m_photo.Path, conv); if (m_photo == null) { // User cancelled photo capture return(null); } return(p); }
/// <summary> /// Initializes a new instance of the <see cref="MediaPickerDelegate"/> class. /// </summary> /// <param name="viewController">The view controller.</param> /// <param name="sourceType">Type of the source.</param> /// <param name="options">The options.</param> internal MediaPickerDelegate( UIViewController viewController, UIImagePickerControllerSourceType sourceType, CameraMediaStorageOptions options) { // Setup the current media picker delegate this.viewController = viewController; this.source = sourceType; this.options = options ?? new CameraMediaStorageOptions(); // Add the observer if (viewController != null) { UIDevice.CurrentDevice.BeginGeneratingDeviceOrientationNotifications(); this.observer = NSNotificationCenter.DefaultCenter.AddObserver( UIDevice.OrientationDidChangeNotification, this.DidRotate); } }
public async Task <MediaFile> SelectPhotoAsync(CameraMediaStorageOptions options) { var picker = new FileOpenPicker(); picker.ViewMode = PickerViewMode.Thumbnail; picker.SuggestedStartLocation = PickerLocationId.PicturesLibrary; picker.FileTypeFilter.Add(".png"); picker.FileTypeFilter.Add(".jpg"); picker.FileTypeFilter.Add(".jpeg"); var file = await picker.PickSingleFileAsync(); if (file != null) { return(new MediaFile(file.Name, () => file.OpenStreamForReadAsync().Result)); } return(null); }
public async Task <MediaFile> TakePicture() { var cmso = new CameraMediaStorageOptions { DefaultCamera = CameraDevice.Rear, SaveMediaOnCapture = false }; return(await m_MediaPicker.TakePhotoAsync(cmso).ContinueWith(t => { if (t.IsCompleted && t.Status == TaskStatus.RanToCompletion) { var mediaFile = t.Result; return mediaFile; } return null; }, m_Scheduler)); }
/// <summary> /// Verifies the camera options. /// </summary> /// <param name="options">The camera options.</param> private static void VerifyCameraOptions(CameraMediaStorageOptions options) { // If options are not specified if (options == null) { throw new ArgumentNullException(nameof(options)); } // If path is rooted if ((options.Directory != null) && Path.IsPathRooted(options.Directory)) { // ReSharper disable once LocalizableElement throw new ArgumentException("Directory must be a relative path", nameof(options)); } // Validate the camera options if (!Enum.IsDefined(typeof(CameraDevice), options.DefaultCamera)) { throw new ArgumentException("Camera is not a member of CameraDevice"); } }
public void AddImage(string fakeImagePath, int cropSize) { Task <MediaFile> imageTask = null; var options = new CameraMediaStorageOptions { DefaultCamera = CameraDevice.Rear, MaxPixelDimension = 400, }; imageTask = AppProvider.MediaPicker.SelectPhotoAsync(options); imageTask.ContinueWith(delegate(Task <MediaFile> arg) { MediaFile file = arg.Result; if (file != null) { AppProvider.IOManager.DeleteFile(fakeImagePath); AppProvider.ImageService.CropAndResizeImage(file.Path, fakeImagePath, cropSize); OnImageChanged(); } }); }
async void AnalyzeAction() { try { //TODO:check if camera etc os available media.phot etc. var options = new CameraMediaStorageOptions() { SaveMediaOnCapture = false, }; var result = await mediaPicker.TakePhotoAsync(options); var data = receiptAnalyser.Analyse(result.Source); ShoppingItems = new ObservableCollection <ShoppingItem>(data); ; } catch (Exception ex) { logger.Log(ex.Message + ex.StackTrace, Category.Exception, Priority.Medium); await pageDialogService.DisplayAlertAsync(locale.RUnknownErrorTitle, locale.RUnknonwnMessage, locale.RUnknownErrorConfirm); } }
/// <summary> /// Takes the picture. /// </summary> /// <param name="options">The storage options.</param> /// <returns>Task representing the asynchronous operation.</returns> /// <exception cref="NotSupportedException">No camera is present on the current device.</exception> public override Task <MediaFile> TakePhotoAsync(CameraMediaStorageOptions options) { // If no camera available if (!this.IsCameraAvailable) { throw new NotSupportedException(); } // Validate options if (options == null) { throw new ArgumentNullException(nameof(options)); } // If path is rooted if (Path.IsPathRooted(options.Directory)) { throw new ArgumentException("options.Directory must be a relative folder"); } // Take the photo return(this.TakeMediaAsync("image/*", MediaStore.ActionImageCapture, options)); }
/////// <summary> /////// Select a picture from library. /////// </summary> /////// <param name="options">The storage options.</param> /////// <returns>Task representing the asynchronous operation.</returns> ////public Task<MediaFile> SelectPhotoAsync(CameraMediaStorageOptions options) ////{ //// // If photos are not supported //// if (!this.IsPhotosSupported) //// { //// throw new NotSupportedException(); //// } //// // Get the image from pictures //// return this.GetMediaAsync(UIImagePickerControllerSourceType.PhotoLibrary, MediaPickerIOS.TypeImage); ////} /// <summary> /// Takes the picture. /// </summary> /// <param name="options">The storage options.</param> /// <returns>Task representing the asynchronous operation.</returns> public override Task <MediaFile> TakePhotoAsync(CameraMediaStorageOptions options) { // If photos are not supported if (!this.IsPhotosSupported) { throw new NotSupportedException(); } // If camera is not supported if (!this.IsCameraAvailable) { throw new NotSupportedException(); } // If the camera permission is not determined var status = AVCaptureDevice.GetAuthorizationStatus(AVMediaType.Video); if (status == AVAuthorizationStatus.NotDetermined) { var granted = AVCaptureDevice.RequestAccessForMediaTypeAsync(AVMediaType.Video); granted.Wait(); if (!granted.Result) { return(null); } } // If camera is restricted if ((status == AVAuthorizationStatus.Denied) || (status == AVAuthorizationStatus.Restricted)) { return(null); } // Take the camera photo MediaPickerIOS.VerifyCameraOptions(options); return(this.GetMediaAsync(UIImagePickerControllerSourceType.Camera, MediaPickerIOS.TypeImage, options)); }
public Task <MediaFile> TakePhotoAsync(CameraMediaStorageOptions options) { throw new NotImplementedException(); }
/// <summary> /// Gets the media asynchronous. /// </summary> /// <param name="sourceType">Type of the source.</param> /// <param name="mediaType">Type of the media.</param> /// <param name="options">The options.</param> /// <returns>Task representing the asynchronous operation.</returns> private Task <MediaFile> GetMediaAsync( UIImagePickerControllerSourceType sourceType, string mediaType, CameraMediaStorageOptions options = null) { // Get the active window var window = UIApplication.SharedApplication.KeyWindow; if (window == null) { throw new InvalidOperationException("There's no current active window"); } // Get the view controller var viewController = window.RootViewController; #if __IOS_10__ if (viewController == null || (viewController.PresentedViewController != null && viewController.PresentedViewController.GetType() == typeof(UIAlertController))) { window = UIApplication.SharedApplication.Windows.OrderByDescending(w => w.WindowLevel) .FirstOrDefault(w => w.RootViewController != null); if (window == null) { throw new InvalidOperationException("Could not find current view controller"); } viewController = window.RootViewController; } #endif // Get the root view controller while (viewController.PresentedViewController != null) { viewController = viewController.PresentedViewController; } // Create a new media picker delegate var newDelegate = new MediaPickerDelegate(viewController, sourceType, options); var operationResult = Interlocked.CompareExchange(ref this.pickerDelegate, newDelegate, null); if (operationResult != null) { throw new InvalidOperationException("Only one operation can be active at at time"); } // Setup the view controller var picker = MediaPickerIOS.SetupController(newDelegate, sourceType, mediaType, options); // If the image is from photo library if ((UIDevice.CurrentDevice.UserInterfaceIdiom == UIUserInterfaceIdiom.Pad) && (sourceType == UIImagePickerControllerSourceType.PhotoLibrary)) { // Create a photo choosing popover newDelegate.Popover = new UIPopoverController(picker) { Delegate = new MediaPickerPopoverDelegate(newDelegate, picker) }; newDelegate.DisplayPopover(); } else { // Show the media picker view viewController.PresentViewController(picker, true, null); } // Get the media return(newDelegate.Task.ContinueWith( t => { // Dispose popover if any if (this.popover != null) { this.popover.Dispose(); this.popover = null; } // Release the media picker delegate Interlocked.Exchange(ref this.pickerDelegate, null); return t; }).Unwrap()); }