public override void ViewDidLoad()
{
base.ViewDidLoad ();
buttonLocation.TouchUpInside += (sender, e) => {
var locator = new Geolocator { DesiredAccuracy = 50 };
locator.GetPositionAsync (timeout: 10000).ContinueWith (t => {
var text = String.Format("Lat: {0}, Long: {0}", t.Result.Latitude, t.Result.Longitude);
InvokeOnMainThread(() => LabelLocation.Text = text);
});
};
buttonPicture.TouchUpInside += (sender, e) => {
var camera = new MediaPicker ();
if (!camera.IsCameraAvailable) {
Console.WriteLine("Camera unavailable!");
return;
}
var opts = new StoreCameraMediaOptions {
Name = "test.jpg",
Directory = "MiniHackDemo"
};
camera.TakePhotoAsync (opts).ContinueWith (t => {
if (t.IsCanceled)
return;
InvokeOnMainThread(() => imagePhoto.Image = UIImage.FromFile(t.Result.Path));
});
};
}
public void TakeAndStorePhoto(Action<string> onPhotoTaken)
{
var picker = new MediaPicker();
if (!picker.IsCameraAvailable || !picker.PhotosSupported)
{
MvxTrace.Trace(MvxTraceLevel.Diagnostic, "Photo taking not available");
return;
}
var photoName = string.Format("Sphero{0:yyyyMMddHHmmss}.jpg", DateTime.Now);
picker.TakePhotoAsync(new StoreCameraMediaOptions
{
Name = photoName,
Directory = PictureFolder
})
.ContinueWith(t =>
{
if (t.IsCanceled)
return;
#warning Code to do...
//var file = this.GetService<IMvxSimpleFileStoreService>();
//file.WriteFile(t.Result.Path, stream => t.Result.GetStream().CopyTo(stream));
//file.WriteFile("Test.txt", "Some text");
onPhotoTaken(t.Result.Path);
});
}
public async System.Threading.Tasks.Task<CameraFile> TakePhotoAsync ()
{
CameraFile result = new CameraFile ();
try {
var picker = new MediaPicker (Platform_Android.MainActivity);
if (!picker.IsCameraAvailable) {
result.Exception = new ArgumentException ("No camera available.");
} else {
try {
var file = await picker.TakePhotoAsync (new StoreCameraMediaOptions {
Name = "test.jpg",
Directory = "PoSDB"
});
File.WriteAllBytes (file.Path + "_small.jpg", ResizeImageAndroid (imageData: File.ReadAllBytes (file.Path)));
result.Stream = () => new MemoryStream (File.ReadAllBytes (file.Path + "_small.jpg"));
} catch (OperationCanceledException) {
result.IsCancelled = true;
}
}
} catch (Exception ex) {
result.Exception = ex;
}
return result;
}
public override void ViewDidLoad ()
{
base.ViewDidLoad ();
var picker = new MediaPicker ();
this.bntCamera.TouchUpInside += (sender, e) => {
if (!picker.IsCameraAvailable)
lblSuccess.Text = "No camera!";
else {
picker.TakePhotoAsync (new StoreCameraMediaOptions {
Name = "test.jpg",
Directory = "MediaPickerSample"
}).ContinueWith (t => {
if (t.IsCanceled) {
lblSuccess.Text = "User cancelled";
return;
}
lblSuccess.Text = "Photo succeeded";
Console.WriteLine(t.Result.Path);
}, TaskScheduler.FromCurrentSynchronizationContext());
}
};
}
protected override void OnCreate (Bundle bundle)
{
base.OnCreate (bundle);
// Set our view from the "main" layout resource
SetContentView (Resource.Layout.Main);
// Get our button from the layout resource,
// and attach an event to it
Button button = FindViewById<Button> (Resource.Id.myButton);
TextView label = FindViewById<TextView> (Resource.Id.lblSuccess);
button.Click += delegate {
var picker = new MediaPicker (this);
if (!picker.IsCameraAvailable)
label.Text = "No camera!";
else {
picker.TakePhotoAsync (new StoreCameraMediaOptions {
Name = "test.jpg",
Directory = "MediaPickerSample"
}).ContinueWith (t => {
if (t.IsCanceled) {
label.Text = "User canceled";
return;
}
label.Text = "Photo succeeded";
Console.WriteLine (t.Result.Path);
}, TaskScheduler.FromCurrentSynchronizationContext());
}
};
}
/// <summary>
/// Event handler when the user clicks the Take a Photo button
/// </summary>
/// <param name='sender'>
/// Sender
/// </param>
partial void takePhotoBtnClicked (MonoTouch.Foundation.NSObject sender)
{
Console.WriteLine("takePhotoBtnClicked");
picker = new MediaPicker ();
// Check if a camera is available and photos are supported on this device
if (!picker.IsCameraAvailable || !picker.PhotosSupported)
{
ShowUnsupported();
return;
}
// Call TakePhotoAsync, which gives us a Task<MediaFile>
picker.TakePhotoAsync (new StoreCameraMediaOptions
{
Name = "test.jpg",
Directory = "MediaPickerSample"
})
.ContinueWith (t => // Continue when the user has taken a photo
{
if (t.IsCanceled) // The user canceled
return;
// Show the photo the user took
InvokeOnMainThread( delegate {
UIImage image = UIImage.FromFile(t.Result.Path);
this.imageView.Image = image;
});
});
}
public void TakeAndStorePhoto(Action<string> onPhotoTaken)
{
var currentActivityService = this.GetService<IMvxAndroidCurrentTopActivity>();
var currentActivity = currentActivityService.Activity;
var picker = new MediaPicker(currentActivity);
if (!picker.IsCameraAvailable || !picker.PhotosSupported)
{
MvxTrace.Trace(MvxTraceLevel.Diagnostic, "Photo taking not available");
return;
}
var photoName = string.Format("Sphero{0:yyyyMMddHHmmss}.jpg", DateTime.Now);
picker.TakePhotoAsync(new StoreCameraMediaOptions
{
Name = photoName,
Directory = PictureFolder
})
.ContinueWith(t =>
{
if (t.IsCanceled)
return;
onPhotoTaken(t.Result.Path);
});
}
private async Task<MediaFile> UseCamera(MediaPicker picker) {
var fileName = DateTime.Now.Ticks + ".png";
return await picker.TakePhotoAsync(new StoreCameraMediaOptions {
Directory = "temp",
Name = fileName
//DefaultCamera = CameraDevice.Rear
});
}
public async void TakePicture ()
{
var picker = new MediaPicker();
var mediaFile = await picker.TakePhotoAsync (new StoreCameraMediaOptions () {
DefaultCamera = CameraDevice.Front,
});
System.Diagnostics.Debug.WriteLine(mediaFile.Path);
MessagingCenter.Send<IPhotoService, string>(this, "photoShot", mediaFile.Path);
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.Main);
// Get our button from the layout resource,
// and attach an event to it
Button button = FindViewById<Button>(Resource.Id.buttonLocation);
LabelLocation = FindViewById<TextView>(Resource.Id.locationLabel);
image = FindViewById<ImageView>(Resource.Id.imagePhoto);
button.Click += delegate {
var locator = new Geolocator(this) { DesiredAccuracy = 50 };
locator.GetPositionAsync(timeout: 10000).ContinueWith(t =>
{
var text = String.Format("Location : Lat: {0}, Long: {0}", t.Result.Latitude, t.Result.Longitude);
this.RunOnUiThread(() => LabelLocation.Text = text);
});
};
Button getimge = FindViewById<Button>(Resource.Id.buttonCamera);
getimge.Click += delegate
{
var camera = new MediaPicker(this);
if (!camera.IsCameraAvailable)
{
Console.WriteLine("Camera unavailable!");
return;
}
var opts = new StoreCameraMediaOptions
{
Name = "test.jpg",
Directory = "MiniHackDemo"
};
camera.TakePhotoAsync(opts).ContinueWith(t =>
{
if (t.IsCanceled)
return;
using (var bmp = Android.Graphics.BitmapFactory.DecodeFile(t.Result.Path))
{
this.RunOnUiThread(() => image.SetImageBitmap(bmp));
}
});
};
}
void BtChooseImage_TouchUpInside(object sender, EventArgs e)
{
esStat.Reset ();
var picker = new MediaPicker();
picker.TakePhotoAsync(new StoreCameraMediaOptions {
Name = "emo.jpg",
Directory = "EmotionDetector"
}).ContinueWith (async t => {
MediaFile file = t.Result;
ivImage.Image = MaxResizeImage(UIImage.FromFile(file.Path), 640, 640);
await _vm.Load (ivImage.Image.AsPNG().AsStream());
DrawRects (_vm.Emotions);
}, TaskScheduler.FromCurrentSynchronizationContext());
}
public static async Task<string> PathToPictureFromCamera (MediaPicker mediaPicker)
{
try{
if (!mediaPicker.IsCameraAvailable || !mediaPicker.PhotosSupported) {
return null;
}
var mediaFile = await mediaPicker.TakePhotoAsync (new StoreCameraMediaOptions {});
return mediaFile.Path;
} catch {
return null;
}
}
public static void PictureFromCamera (MediaPicker picker, Action<MediaFile> callback)
{
if (!picker.IsCameraAvailable || !picker.PhotosSupported) {
//ToDo: How to handle unsupported
return;
}
picker.TakePhotoAsync (new StoreCameraMediaOptions
{
Name = string.Format("photo{0}.jpg", Guid.NewGuid()),
Directory = "LB"
}).ContinueWith (t => {
if(t.IsCanceled)
return;
callback(t.Result);
});
}
partial void PhotoButton_TouchUpInside (UIButton sender)
{
var picker = new MediaPicker ();
// new MediaPicker (this); on Android
if (!picker.IsCameraAvailable)
Console.WriteLine ("No camera!");
else {
picker.TakePhotoAsync (new StoreCameraMediaOptions {
Name = "test.jpg",
Directory = "MediaPickerSample"
}).ContinueWith (t => {
if (t.IsCanceled) {
Console.WriteLine ("User canceled");
return;
}
Console.WriteLine (t.Result.Path);
});
}
}
public async Task<Stream> TakePhoto()
{
var picker = new MediaPicker();
if (!picker.IsCameraAvailable)
{
return null;
}
MediaFile mf = null;
try
{
mf = await picker.TakePhotoAsync(new StoreCameraMediaOptions());
}
catch (TaskCanceledException)
{
Debug.WriteLine("photo picker canceled");
}
if (mf == null)
{
return null;
}
return mf.GetStream();
}
async void PresentCamera ()
{
var picker = new MediaPicker (Context);
if (!picker.IsCameraAvailable)
System.Console.WriteLine ("No camera!");
else {
try {
// TakePhotoAsync is deprecated?
var file = await picker.TakePhotoAsync (new StoreCameraMediaOptions {
Name = "test.jpg",
Directory = "CouchbaseConnect",
DefaultCamera = CameraDevice.Rear
});
Console.WriteLine(file.Path);
((CameraContentPage)this.Element).Captured = file.Path;
} catch (Exception e) {
Console.WriteLine ("Take Photo Cancelled.");
}
((CameraContentPage)this.Element).IsPresented = false;
}
}
async partial void OnTakePhoto()
{
var picker = new MediaPicker ();
if (!picker.IsCameraAvailable)
await DisplayAlert("Error", "No Camera Available!", "OK");
else
{
try
{
MediaFile file = await picker.TakePhotoAsync (new StoreCameraMediaOptions {
Name = "test.jpg",
Directory = "photos",
DefaultCamera = CameraDevice.Rear,
});
Image image = new Image() { Source = new FileImageSource { File = file.Path } };
this.Content = image;
}
catch (OperationCanceledException)
{
Console.WriteLine ("Canceled");
}
}
}
public override async void ViewWillAppear (bool animated)
{
base.ViewWillAppear (animated);
if (fileName == "") {
fileName = "in-progress";
var picker = new MediaPicker ();
// new MediaPicker (this); on Android
if (!picker.IsCameraAvailable || !picker.PhotosSupported)
Console.WriteLine ("No camera!");
else {
var options = new StoreCameraMediaOptions {
Name = DateTime.Now.ToString("yyyyMMddHHmmss"),
Directory = "MediaPickerSample"
};
#if !VISUALSTUDIO
#region new style
pickerController = picker.GetTakePhotoUI (options);
PresentViewController (pickerController, true, null);
var pickerTask = pickerController.GetResultAsync ();
await pickerTask;
// We need to dismiss the controller ourselves
await DismissViewControllerAsync (true); // woot! async-ified iOS method
// User canceled or something went wrong
if (pickerTask.IsCanceled || pickerTask.IsFaulted)
return;
// We get back a MediaFile
MediaFile media = pickerTask.Result;
fileName = media.Path;
PhotoImageView.Image = new UIImage (fileName);
SavePicture(fileName);
#endregion
#else
#region old style (deprecated)
var t = picker.TakePhotoAsync (options); //.ContinueWith (t => {
await t;
if (t.IsCanceled) {
Console.WriteLine ("User canceled");
fileName = "cancelled";
//InvokeOnMainThread(() =>{
NavigationController.PopToRootViewController(false);
//});
return;
}
Console.WriteLine (t.Result.Path);
fileName = t.Result.Path;
//InvokeOnMainThread(() =>{
PhotoImageView.Image = new UIImage (fileName);
//});
SavePicture(fileName);
//});
#endregion
#endif
}
} else if (fileName == "cancelled") {
NavigationController.PopToRootViewController (true);
} else {
// populate screen with existing item
PhotoImageView.Image = new UIImage (fileName);
LocationText.Text = location;
}
var locator = new Geolocator { DesiredAccuracy = 50 };
// new Geolocator (this) { ... }; on Android
var position = await locator.GetPositionAsync (timeout: 10000); //.ContinueWith (p => {
Console.WriteLine ("Position Latitude: {0}", position.Latitude);
Console.WriteLine ("Position Longitude: {0}", position.Longitude);
location = string.Format("{0},{1}", position.Latitude, position.Longitude);
LocationText.Text = location;
}
async void OpenImagePicker(){
//It works? Don't use gallery
var robotImagePicker = new MediaPicker(Forms.Context);
await robotImagePicker.TakePhotoAsync(new StoreCameraMediaOptions {
Name = data["teamNumber"].ToString() + ".jpg",
Directory = "Robot Images"
}).ContinueWith(t=>{
robotImageFile = t.Result;
Console.WriteLine("Robot Image Path: " + robotImageFile.Path);
},TaskScheduler.FromCurrentSynchronizationContext());
robotImage.Source = robotImageFile.Path;
try{
ParseFile image = new ParseFile(data["teamNumber"].ToString()+".jpg", ImageToBinary(robotImageFile.Path));
data["robotImage"] = image;
await data.SaveAsync();
}
catch{
Console.WriteLine ("Image Save Error");
}
}
private async void AddImage(object obj)
{
var mediaPicker = new MediaPicker(App.UIContext);
var photo = await mediaPicker.TakePhotoAsync(new StoreCameraMediaOptions());
MobileServiceFile file = await this.itemManager.AddImage(this.todoItem, photo.Path);
var image = new TodoItemImageViewModel(file, this.todoItem, DeleteImage);
this.images.Add(image);
}
protected override async void OnResume ()
{
base.OnResume ();
int itemId = Intent.GetIntExtra(ShareItemIdExtraName, 0);
if(itemId > 0) {
shareItem = App.Database.GetItem(itemId);
fileName = shareItem.ImagePath;
System.Console.WriteLine("Image path: " + fileName);
Bitmap b = BitmapFactory.DecodeFile (fileName);
// Display the bitmap
photoImageView.SetImageBitmap (b);
locationText.Text = shareItem.Location;
return;
}
if (fileName == "") {
fileName = "in-progress";
var picker = new MediaPicker (this);
// new MediaPicker (); on iOS
if (!picker.IsCameraAvailable)
System.Console.WriteLine ("No camera!");
else {
var options = new StoreCameraMediaOptions {
Name = DateTime.Now.ToString("yyyyMMddHHmmss"),
Directory = "MediaPickerSample"
};
#if !VISUALSTUDIO
#region new style
if (!picker.IsCameraAvailable || !picker.PhotosSupported) {
ShowUnsupported();
return;
}
Intent intent = picker.GetTakePhotoUI (options);
StartActivityForResult (intent, 1);
#endregion
#else
#region old style (deprecated)
var t = picker.TakePhotoAsync (options);
await t;
if (t.IsCanceled) {
System.Console.WriteLine ("User canceled");
fileName = "cancelled";
// TODO: return to main screen
StartActivity(typeof(MainScreen));
return;
}
System.Console.WriteLine (t.Result.Path);
fileName = t.Result.Path;
fileNameThumb = fileName.Replace(".jpg", "_thumb.jpg");
Bitmap b = BitmapFactory.DecodeFile (fileName);
RunOnUiThread (() =>
{
// Display the bitmap
photoImageView.SetImageBitmap (b);
// Cleanup any resources held by the MediaFile instance
t.Result.Dispose();
});
var boptions = new BitmapFactory.Options {OutHeight = 128, OutWidth = 128};
var newBitmap = await BitmapFactory.DecodeFileAsync (fileName, boptions);
var @out = new System.IO.FileStream(fileNameThumb, System.IO.FileMode.Create);
newBitmap.Compress(Android.Graphics.Bitmap.CompressFormat.Jpeg, 90, @out);
//});
#endregion
#endif
}
}
try {
var locator = new Geolocator (this) { DesiredAccuracy = 50 };
// new Geolocator () { ... }; on iOS
var position = await locator.GetPositionAsync (timeout: 10000);
System.Console.WriteLine ("Position Latitude: {0}", position.Latitude);
System.Console.WriteLine ("Position Longitude: {0}", position.Longitude);
location = string.Format("{0},{1}", position.Latitude, position.Longitude);
locationText.Text = location;
} catch (Exception e) {
System.Console.WriteLine ("Position Exception: " + e.Message);
}
}
private async void CameraIconPressed(object sender, EventArgs e)
{
//use the Xamarin.Media library to take the picture
//it's cross platform and allows for quick access for taking picutres
//would want to use native calls if you need customized solution
var picturePicker = new MediaPicker();
if (!picturePicker.IsCameraAvailable)
{
//show alert that no camera is available
var alert = UIAlertController.Create("Error", "Sorry I tried to access the camera on your device, but your device told me you don't have one. I can't take a picture without one.", UIAlertControllerStyle.Alert);
//add in the ok button
alert.AddAction(UIAlertAction.Create("OK", UIAlertActionStyle.Default, null));
//show the alert dialog on the UI
PresentViewController(alert, true, null);
}
else
{
try
{
var media = await picturePicker.TakePhotoAsync(new StoreCameraMediaOptions
{
Name = string.Format("test_picture_{0}.jpg", DateTime.Now),
Directory = "CameraExample"
});
if (media != null)
{
_files.Add(media.Path);
this.TableView.ReloadData();
}
}
catch (OperationCanceledException operationCancelledException)
{
//TODO log they cancelled taking the picture
System.Console.WriteLine(operationCancelledException);
}
catch (System.Exception ex)
{
System.Console.WriteLine(ex.StackTrace);
}
}
}
void MediaChooser (object sender, EventArgs e)
{
var builder = new AlertDialog.Builder(this);
builder.SetTitle("Media Chooser");
builder.SetMessage("Camera Or Library");
builder.SetCancelable(false);
builder.SetPositiveButton("Camera"
,
delegate
{
var picker = new MediaPicker (this);
if (!picker.IsCameraAvailable)
Console.WriteLine ("No camera!");
else
{
picker.TakePhotoAsync (new StoreCameraMediaOptions {
Name = "test.jpg",
Directory = "MediaPickerSample"
}).ContinueWith (t => {
if (t.IsCanceled)
{
Console.WriteLine ("User canceled");
return;
}
Console.WriteLine (t.Result.Path);
//Load image to imageView
b = BitmapFactory.DecodeFile(t.Result.Path);
imageView.SetImageBitmap(b);
}, TaskScheduler.FromCurrentSynchronizationContext());
}
}
);
builder.SetNeutralButton("Library"
,
delegate
{
var picker = new MediaPicker (this);
picker.PickPhotoAsync()
.ContinueWith (t => {
if (t.IsCanceled)
{
Console.WriteLine ("User canceled");
return;
}
Console.WriteLine (t.Result.Path);
b = BitmapFactory.DecodeFile(t.Result.Path);
imageView.SetImageBitmap(b);
}, TaskScheduler.FromCurrentSynchronizationContext());
}
);
builder.SetNegativeButton("Cancel",delegate {});
builder.Show();
}
void ActionSheetTapped(object sender, UIButtonEventArgs e)
{
MediaPicker picker = new MediaPicker ();
if (e.ButtonIndex == 0)
{
Task<MediaFile> task = picker.TakePhotoAsync (new StoreCameraMediaOptions ()
{DefaultCamera= CameraDevice.Front});
HandlePick (task);
}
else if (e.ButtonIndex == 1)
{
PickPhotoFromLibrary (picker);
}
}
public Task<MediaFile> GetPhoto(bool takeNew)
{
#if MONOANDROID
var activity = this.GetService<Cirrious.MvvmCross.Droid.Interfaces.IMvxAndroidCurrentTopActivity>();
var picker = new MediaPicker(activity.Activity);
#else
var picker = new MediaPicker();
#endif
if (takeNew)
return picker.TakePhotoAsync(new StoreCameraMediaOptions());
else
return picker.PickPhotoAsync();
}
public WelcomeViewModel(MediaPicker picker)
{
TakeNewPhoto = new ReactiveAsyncCommand();
ChooseExistingPhoto = new ReactiveAsyncCommand();
StartEdit = new ReactiveCommand();
var defaultCamera = new StoreCameraMediaOptions() { DefaultCamera = CameraDevice.Rear, Directory = "LeeMe", Name = "turnt.jpg", };
Observable.Merge(
TakeNewPhoto.RegisterAsyncTask(_ => picker.TakePhotoAsync(defaultCamera)),
ChooseExistingPhoto.RegisterAsyncTask(_ => picker.PickPhotoAsync()))
.Select(x => x.Path)
.InvokeCommand(StartEdit);
// TODO: Write a proper UserError handler for this
TakeNewPhoto.ThrownExceptions.Subscribe(ex => Console.WriteLine(ex));
ChooseExistingPhoto.ThrownExceptions.Subscribe(ex => Console.WriteLine(ex));
}
public PhotoAlertSheet ()
{
picker = new MediaPicker ();
AddButton ("Photo Library");
if (picker.IsCameraAvailable)
AddButton ("Camera");
Dismissed += (sender, e) => {
switch (e.ButtonIndex) {
case 0:
picker.PickPhotoAsync ()
.ContinueWith (t => {
if (t.IsCanceled)
return null;
SetImage(t.Result.GetStream());
return t.Result;
});
break;
case 1:
picker.TakePhotoAsync (new StoreCameraMediaOptions())
.ContinueWith (t => {
if (t.IsCanceled)
return t.Result;
SetImage(t.Result.GetStream());
return t.Result;
});
break;
default:
break;
}
};
}
protected override void OnCreate (Bundle bundle)
{
base.OnCreate (bundle);
SetContentView (Resource.Layout.Main);
ImageView image = FindViewById<ImageView> (Resource.Id.image);
VideoView videoView = FindViewById<VideoView>(Resource.Id.surfacevideoview);
//
// Wire up the take a video button
//
Button videoButton = FindViewById<Button> (Resource.Id.takeVideoButton);
videoButton.Click += delegate
{
//
// The MediaPicker is the class used to
// invoke the camera and gallery picker
// for selecting and taking photos
// and videos
//
var picker = new MediaPicker (this);
// We can check to make sure the device has a camera
// and supports dealing with video.
if (!picker.IsCameraAvailable || !picker.VideosSupported)
{
ShowUnsupported();
return;
}
//
// TakeVideoAsync is an async API that takes a
// StoreVideoOptions object with various
// properties, such as the name and folder to
// store the resulting video. You can
// also limit the length of the video
//
picker.TakeVideoAsync (new StoreVideoOptions
{
Name = "MyVideo",
Directory = "MyVideos",
DesiredLength = TimeSpan.FromSeconds (10)
})
.ContinueWith (t =>
{
if (t.IsCanceled)
return;
//
// Because TakeVideoAsync returns a Task
// we can use ContinueWith to run more code
// after the user finishes recording the video
//
RunOnUiThread (() =>
{
//
// Toggle the visibility of the image and videoviews
//
image.Visibility = Android.Views.ViewStates.Gone;
videoView.Visibility = Android.Views.ViewStates.Visible;
//
// Load in the video file
//
videoView.SetVideoPath(t.Result.Path);
//
// optional: Handle when the video finishes playing
//
//videoView.setOnCompletionListener(this);
//
// Start playing the video
//
videoView.Start();
});
});
};
//
// Wire up the take a photo button
//
Button photoButton = FindViewById<Button> (Resource.Id.takePhotoButton);
photoButton.Click += delegate
{
var picker = new MediaPicker (this);
if (!picker.IsCameraAvailable || !picker.PhotosSupported)
{
ShowUnsupported();
return;
}
picker.TakePhotoAsync (new StoreCameraMediaOptions
{
Name = "test.jpg",
Directory = "MediaPickerSample"
})
.ContinueWith (t =>
{
if (t.IsCanceled)
return;
Bitmap b = BitmapFactory.DecodeFile (t.Result.Path);
RunOnUiThread (() =>
{
//
// Toggle the visibility of the image and video views
//
videoView.Visibility = Android.Views.ViewStates.Gone;
image.Visibility = Android.Views.ViewStates.Visible;
//
// Display the bitmap
//
image.SetImageBitmap (b);
// Cleanup any resources held by the MediaFile instance
t.Result.Dispose();
});
});
};
//
// Wire up the pick a video button
//
Button pickVideoButton = FindViewById<Button> (Resource.Id.pickVideoButton);
pickVideoButton.Click += delegate
{
//
// The MediaPicker is the class used to
// invoke the camera and gallery picker
// for selecting and taking photos
// and videos
//
var picker = new MediaPicker (this);
if (!picker.VideosSupported)
{
ShowUnsupported();
return;
}
//
// PickVideoAsync is an async API that invokes
// the native gallery
//
picker.PickVideoAsync ()
.ContinueWith (t =>
{
if (t.IsCanceled)
return;
//
// Because PickVideoAsync returns a Task
// we can use ContinueWith to run more code
// after the user finishes recording the video
//
RunOnUiThread (() =>
{
//
// Toggle the visibility of the image and video views
//
image.Visibility = Android.Views.ViewStates.Gone;
videoView.Visibility = Android.Views.ViewStates.Visible;
//
// Load in the video file
//
videoView.SetVideoPath(t.Result.Path);
//
// Optional: Handle when the video finishes playing
//
//videoView.setOnCompletionListener(this);
//
// Start playing the video
//
videoView.Start();
// Cleanup any resources held by the MediaFile instance
t.Result.Dispose();
});
});
};
//
// Wire up the pick a photo button
//
Button pickPhotoButton = FindViewById<Button> (Resource.Id.pickPhotoButton);
pickPhotoButton.Click += delegate
{
var picker = new MediaPicker (this);
if (!picker.PhotosSupported)
{
ShowUnsupported();
return;
}
picker.PickPhotoAsync ()
.ContinueWith (t =>
{
if (t.IsCanceled)
return;
Bitmap b = BitmapFactory.DecodeFile (t.Result.Path);
RunOnUiThread (() =>
{
//
// Toggle the visibility of the image and video views
//
videoView.Visibility = Android.Views.ViewStates.Gone;
image.Visibility = Android.Views.ViewStates.Visible;
//
// Display the bitmap
//
image.SetImageBitmap (b);
// Cleanup any resources held by the MediaFile instance
t.Result.Dispose();
});
});
};
}
private void TakePhoto()
{
var picker = new MediaPicker (this);
if (picker.IsCameraAvailable) {
picker.TakePhotoAsync (new StoreCameraMediaOptions ())
.ContinueWith (r => ProcessImage (r));
} else {
picker.PickPhotoAsync ().ContinueWith (r => ProcessImage (r));
}
}
void MediaChooser (object sender, UIButtonEventArgs e)
{
if (e.ButtonIndex == 1) {
System.Console.WriteLine ("Camera");
var picker = new MediaPicker ();
if (!picker.IsCameraAvailable)
Console.WriteLine ("No camera!");
else
{
picker.TakePhotoAsync (new StoreCameraMediaOptions {
Name = "test.jpg",
Directory = "MediaPickerSample"
}).ContinueWith (t => {
if (t.IsCanceled)
{
Console.WriteLine ("User canceled");
return;
}
Console.WriteLine (t.Result.Path);
imageView.Image = new UIImage(t.Result.Path);
}, TaskScheduler.FromCurrentSynchronizationContext());
}
}
else if (e.ButtonIndex == 2)
{
System.Console.WriteLine ("Library");
var picker = new MediaPicker ();
// new MediaPicker (this); on Android
picker.PickPhotoAsync()
.ContinueWith (t => {
if (t.IsCanceled)
{
Console.WriteLine ("User canceled");
return;
}
Console.WriteLine (t.Result.Path);
imageView.Image = new UIImage(t.Result.Path);
}, TaskScheduler.FromCurrentSynchronizationContext());
}
}