navigator.camera.getPicture(onSuccess, onFail, { quality: 50,
    destinationType: Camera.DestinationType.DATA_URL
});

function onSuccess(imageData) {
    var image = document.getElementById('myImage');
    image.src = "data:image/jpeg;base64," + imageData;
}

function onFail(message) {
    alert('Failed because: ' + message);
}

public void takePicture(int returnType, int encodingType) {
    // Code is omitted for simplicity ...

    // Display camera
    Intent intent = new Intent("android.media.action.IMAGE_CAPTURE");

    // Specify file so that large image is captured and returned
    File photo = createCaptureFile(encodingType);
    
    intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, Uri.fromFile(photo));
    this.imageUri = Uri.fromFile(photo);

    if (this.cordova != null) {
        this.cordova.startActivityForResult((CordovaPlugin) this, intent, (CAMERA + 1) * 16 + returnType + 1);
    }
}

public void onActivityResult(int requestCode, int resultCode, Intent intent) {
    // Get src and dest types from request code
    int srcType = (requestCode / 16) - 1;
    int destType = (requestCode % 16) - 1;
    int rotate = 0;

    // If CAMERA
    if (srcType == CAMERA) {
        
        // If image available
        if (resultCode == Activity.RESULT_OK) {
                // ... Code is omitted for simplicity ...

                Bitmap bitmap = null;
                Uri uri = null;

                // If sending base64 image back
                if (destType == DATA_URL) {
                    bitmap = getScaledBitmap(FileHelper.stripFileProtocol(imageUri.toString()));
            
                    // ... Code is omitted for simplicity ...

                    this.processPicture(bitmap);
                }

                // If sending filename back
                else if (destType == FILE_URI || destType == NATIVE_URI) {
                    if (this.saveToPhotoAlbum) {
                        Uri inputUri = getUriFromMediaStore();
                        
                        //Just because we have a media URI doesn't mean we have a real file, we need to make it
                        uri = Uri.fromFile(new File(FileHelper.getRealPath(inputUri, this.cordova)));
                    } else {
                        uri = Uri.fromFile(new File(DirectoryManager.getTempDirectoryPath(this.cordova.getActivity()), System.currentTimeMillis() + ".jpg"));
                    }
                        
                    if (uri == null) {
                        this.failPicture("Error capturing image - no media storage found.");
                    }
                        
                    // ... Code is omitted for simplicity ...
                    // Send Uri back to JavaScript for viewing image
                    this.callbackContext.success(uri.toString());
                }
                        
                // ... Code is omitted for simplicity ...
            } catch (IOException e) {
                e.printStackTrace();
                this.failPicture("Error capturing image.");
            }
        }
                        
        // If cancelled
        else if (resultCode == Activity.RESULT_CANCELED) {
            this.failPicture("Camera cancelled.");
        }
                        
        // If something else
        else {
            this.failPicture("Did not complete!");
        }
    }
}

public void processPicture(Bitmap bitmap) {
    ByteArrayOutputStream jpeg_data = new ByteArrayOutputStream();
    try {
        if (bitmap.compress(CompressFormat.JPEG, mQuality, jpeg_data)) {
            byte[] code = jpeg_data.toByteArray();
            byte[] output = Base64.encode(code, Base64.DEFAULT);
            String js_out = new String(output);
            this.callbackContext.success(js_out);
            js_out = null;
            output = null;
            code = null;
        }
    } catch (Exception e) {
        this.failPicture("Error compressing image.");
    }
    jpeg_data = null;
}

CameraCaptureTask cameraTask;

public void takePicture(string options)
{
    // ... Code is omitted for simplifying things ...

    if (cameraOptions.PictureSourceType == CAMERA)
    {
        cameraTask = new CameraCaptureTask();
        cameraTask.Completed += onCameraTaskCompleted;
        cameraTask.Show();        
    }
    
    // ... Code is omitted for simplifying things ...
}

public void onCameraTaskCompleted(object sender, PhotoResult e)
{
    // ... Code is omitted for simplifying things ...    
    switch (e.TaskResult)
    {
        case TaskResult.OK:
            try
            {
                string imagePathOrContent = string.Empty;

                if (cameraOptions.DestinationType == FILE_URI)
                {
                    // Save image in media library
                    if (cameraOptions.SaveToPhotoAlbum)
                    {
                        MediaLibrary library = new MediaLibrary();
                        Picture pict = library.SavePicture(e.OriginalFileName, e.ChosenPhoto); // to save to photo-roll ...
                    }

                    int orient = ImageExifHelper.getImageOrientationFromStream(e.ChosenPhoto);
                    int newAngle = 0;
                
                    // ... Code is omitted for simplifying things ...

                    Stream rotImageStream = ImageExifHelper.RotateStream(e.ChosenPhoto, newAngle);

                    // we should return stream position back after saving stream to media library
                    rotImageStream.Seek(0, SeekOrigin.Begin);

                    WriteableBitmap image = PictureDecoder.DecodeJpeg(rotImageStream);

                    imagePathOrContent = this.SaveImageToLocalStorage(image, Path.GetFileName(e.OriginalFileName));
                }
                else if (cameraOptions.DestinationType == DATA_URL)
                {
                    imagePathOrContent = this.GetImageContent(e.ChosenPhoto);
                }
                else
                {
                    // TODO: shouldn't this happen before we launch the camera-picker?
                    DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, "Incorrect option: destinationType"));
                    return;
                }

                DispatchCommandResult(new PluginResult(PluginResult.Status.OK, imagePathOrContent));

            }
            catch (Exception)
            {
                DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, "Error retrieving image."));
            }
            break;
            
            // ... Code is omitted for simplifying things ...
    }
}

private string GetImageContent(Stream stream)
{
    int streamLength = (int)stream.Length;
    byte[] fileData = new byte[streamLength + 1];
    stream.Read(fileData, 0, streamLength);

    //use photo's actual width & height if user doesn't provide width & height
    if (cameraOptions.TargetWidth < 0 && cameraOptions.TargetHeight < 0)
    {
        stream.Close();
        return Convert.ToBase64String(fileData);
    }
    else
    {
        // resize photo
        byte[] resizedFile = ResizePhoto(stream, fileData);
        stream.Close();
        return Convert.ToBase64String(resizedFile);
    }
}

private string SaveImageToLocalStorage(WriteableBitmap image, string imageFileName)
{
    // ... Code is omitted for simplifying things ...
    var isoFile = IsolatedStorageFile.GetUserStoreForApplication();
    if (!isoFile.DirectoryExists(isoFolder))
    {
        isoFile.CreateDirectory(isoFolder);
    }

    string filePath = System.IO.Path.Combine("///" + isoFolder + "/", imageFileName);

    using (var stream = isoFile.CreateFile(filePath))
    {
        // resize image if Height and Width defined via options 
        if (cameraOptions.TargetHeight > 0 && cameraOptions.TargetWidth > 0)
        {
            image.SaveJpeg(stream, cameraOptions.TargetWidth, cameraOptions.TargetHeight, 0, cameraOptions.Quality);
        }
        else
        {
            image.SaveJpeg(stream, image.PixelWidth, image.PixelHeight, 0, cameraOptions.Quality);
        }
    }

    return new Uri(filePath, UriKind.Relative).ToString();
}