Xamarin all OS: take a photo with CrossMedia.Current.TakePhotoAsync

Bug

I’m creating a project where I have to take a lot of pictures. In my previous project for iOS all are working fine. I’m using the same code for a new project for all platforms (iOS, Android and UWP).

When I take a photo on Android the stream is empty. In UWP when I try to open the page where I can take a photo, the application is blocked: after 3-5 minutes it’s unblocked and I can take a photo.

Version Number of Plugin: 2.3.0 Device Tested On:

• Nokia Lumia 735 (Windows 10)
• Cubot Rainbow Sim Free Smartphone Dual Sim 3G Unlocked 5 Inch HD Android 6.0 Quad Core 1.3 GHz 1 GB Ram 16GB Rom Smart Phone 13MP Camera GPS WIFI Hots
• iPhone 6s

Simulator Tested On:

• Android 6.0 as Nexus 6P API 23 x86
• my desktop with Windows 10

Expected Behavior

I can take take a photo to save it on disk

Steps to reproduce the Behavior

        /// <summary>
        /// Gets the camera command.
        /// </summary>
        /// <value>The camera command.</value>
        public ICommand CameraCommand
        {
            get { return _cameraCommand ?? new Command(async () => await ExecuteCameraCommand(), () => CanExecuteCameraCommand()); }
        }

        /// <summary>
        /// Determines whether this instance can execute camera command.
        /// </summary>
        /// <returns><c>true</c> if this instance can execute camera command; otherwise, <c>false</c>.</returns>
        public bool CanExecuteCameraCommand() {
            if (!CrossMedia.Current.IsCameraAvailable || !CrossMedia.Current.IsTakePhotoSupported) {
                return false;
            }
            return true;
        }

        /// <summary>
        /// Executes the camera command.
        /// </summary>
        /// <returns>The camera command.</returns>
        public async Task ExecuteCameraCommand() {
            var file = await CrossMedia.Current.TakePhotoAsync(new Plugin.Media.Abstractions.StoreCameraMediaOptions());

            if (file == null)
                return;

            byte[] imageAsBytes = null;
            using (var memoryStream = new MemoryStream()) {
                file.GetStream().CopyTo(memoryStream);
                file.Dispose();
                imageAsBytes = memoryStream.ToArray();
            }

            if (imageAsBytes.Length > 0) {
                var resizer = DependencyService.Get<IImageResize>();
                imageAsBytes = resizer.ResizeImage(imageAsBytes, 1080, 1080);

                var imageSource = ImageSource.FromStream(() => new MemoryStream(imageAsBytes));
                _images.Add(new GalleryImage { Source = imageSource, OrgImage = imageAsBytes });
            }
        }

Thank you for your job!

[jamesmontemagno]

@erportico

You should call the Initialize() before you call the take photo:

 public async Task ExecuteCameraCommand()
        {

            await CrossMedia.Current.Initialize();
            var file = await CrossMedia.Current.TakePhotoAsync(new Plugin.Media.Abstractions.StoreCameraMediaOptions());

of do it in the pages on appearing:

 bool initialized;
        protected override async void OnAppearing()
        {
            base.OnAppearing();
            await CrossMedia.Current.Initialize();
            initialized = true;
            ((Command)CameraCommand).ChangeCanExecute();
        }

For UWP you must call initialize before calling anything else, so update your CanExecute to:

public bool CanExecuteCameraCommand()
        {
            if (!initialized)
                return false;

            if (!CrossMedia.Current.IsCameraAvailable || !CrossMedia.Current.IsTakePhotoSupported)
            {
                return false;
            }
            return true;
        }

Also, make sure in your MainActivity you copied this code in for Android:

public override void OnRequestPermissionsResult(int requestCode, string[] permissions, Permission[] grantResults)
        {
            PermissionsImplementation.Current.OnRequestPermissionsResult(requestCode, permissions, grantResults);
        }

I assume you also set your target to 23:

I tested the code out that you posed with my modifications on my Nexus 6P running 7.0 stock and it worked perfect. I got a file and got the stream from it.

For UWP I set the Webcam capability in the appxmanifest. In this instance your Command will have an issue because Small optimization: Finally, you should make sure you actually are creating a new command in your getter for the command:

public ICommand CameraCommand
        {
            get { return _cameraCommand ?? (_cameraCommand = new Command(async () => await ExecuteCameraCommand(), () => CanExecuteCameraCommand())); }
        }

Else it will just create a new one every time.

Closing as I tested this on all platforms with production level, and here is a test app that I used:

App36.zip

[erportico]

My fix at this problem is

[...]
byte[] imageAsBytes = null;
using (var memoryStream = new MemoryStream()) {
   file.GetStream().CopyTo(memoryStream);
   imageAsBytes = memoryStream.ToArray();

   if (imageAsBytes.Length == 0) {
      imageAsBytes = await FileHelper.GetImageAsByte(file.Path);
   }
   file.Dispose();
}
[...]