CB-13714 Updated version and RELEASENOTES.md for release 4.0.1 (via coho)

CB-13701 Fix to allow 4.0.0 version install

.appveyor.yml

@@ -0,0 +1,28 @@
+# appveyor file
+# http://www.appveyor.com/docs/appveyor-yml
+
+max_jobs: 1
+
+shallow_clone: true
+
+init:
+  - git config --global core.autocrlf true
+
+image:
+  - Visual Studio 2017
+
+environment:
+  nodejs_version: "4"
+  matrix:
+    - PLATFORM: windows-10-store
+      JUST_BUILD: --justBuild
+install:
+  - npm cache clean -f
+  - node --version
+  - npm install -g cordova-paramedic@https://github.com/apache/cordova-paramedic.git
+  - npm install -g cordova
+
+build: off
+
+test_script:
+  - cordova-paramedic --config pr\%PLATFORM% --plugin . %JUST_BUILD%

.eslintrc.yml

@@ -0,0 +1,10 @@
+root: true
+extends: semistandard
+rules:
+  indent:
+    - error
+    - 4
+  camelcase: off
+  padded-blocks: off
+  operator-linebreak: off
+  no-throw-literal: off

.gitattributes

@@ -0,0 +1,94 @@
+* text eol=lf
+
+# source code
+*.php text
+*.css text
+*.sass text
+*.scss text
+*.less text
+*.styl text
+*.js text
+*.coffee text
+*.json text
+*.htm text
+*.html text
+*.xml text
+*.svg text
+*.txt text
+*.ini text
+*.inc text
+*.pl text
+*.rb text
+*.py text
+*.scm text
+*.sql text
+*.sh text
+*.bat text
+
+# templates
+*.ejs text
+*.hbt text
+*.jade text
+*.haml text
+*.hbs text
+*.dot text
+*.tmpl text
+*.phtml text
+
+# server config
+.htaccess text
+
+# git config
+.gitattributes text
+.gitignore text
+.gitconfig text
+
+# code analysis config
+.jshintrc text
+.jscsrc text
+.jshintignore text
+.csslintrc text
+
+# misc config
+*.yaml text
+*.yml text
+.editorconfig text
+
+# build config
+*.npmignore text
+*.bowerrc text
+
+# Heroku
+Procfile text
+.slugignore text
+
+# Documentation
+*.md text
+LICENSE text
+AUTHORS text
+
+
+#
+## These files are binary and should be left untouched
+#
+
+# (binary is a macro for -text -diff)
+*.png binary
+*.jpg binary
+*.jpeg binary
+*.gif binary
+*.ico binary
+*.mov binary
+*.mp4 binary
+*.mp3 binary
+*.flv binary
+*.fla binary
+*.swf binary
+*.gz binary
+*.zip binary
+*.7z binary
+*.ttf binary
+*.eot binary
+*.woff binary
+*.pyc binary
+*.pdf binary

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,22 @@
+<!--
+Please make sure the checklist boxes are all checked before submitting the PR. The checklist
+is intended as a quick reference, for complete details please see our Contributor Guidelines:
+
+http://cordova.apache.org/contribute/contribute_guidelines.html
+
+Thanks!
+-->
+
+### Platforms affected
+
+
+### What does this PR do?
+
+
+### What testing has been done on this change?
+
+
+### Checklist
+- [ ] [Reported an issue](http://cordova.apache.org/contribute/issues.html) in the JIRA database
+- [ ] Commit message follows the format: "CB-3232: (android) Fix bug with resolving file paths", where CB-xxxx is the JIRA ID & "android" is the platform affected.
+- [ ] Added automated test coverage as appropriate for this change.

.gitignore

@@ -12,12 +12,4 @@ Thumbs.db
 *.swp
 *.user
 
-
-
-
-
-
-
-
-
- 
+/node_modules/**

.ratignore

@@ -0,0 +1 @@
+TEMPLATE.md

.travis.yml

@@ -1,13 +1,92 @@
-language: objective-c
-git:
-  depth: 2
-node_js:
-  - "0.10"
+sudo: false
+addons:
+  jwt:
+    secure: QivPLlqTVvOo3TJeHxuBOfxU6lho1I0IxQ3b68yntkEQQJko6kzleXHfgjf0a8aw8m38E3+fxaBWF1bGyucGwOLDWY8Ddt2P2xg44zdXH5EXHd9oIqAgngIdzLvUtH3Db2TbQEtIGOkrnNR2STovjqB7vHGLASQrgs4oL7r32/s=
+env:
+  global:
+  - SAUCE_USERNAME=snay
+  - TRAVIS_NODE_VERSION="4.2"
+matrix:
+  include:
+  - env: TEST_DIR=.
+    language: objective-c
+  - env: TEST_DIR=./tests/ios
+    language: objective-c
+  - env: PLATFORM=browser-chrome
+    os: linux
+    language: node_js
+    node_js: '4.2'
+  - env: PLATFORM=browser-firefox
+    os: linux
+    language: node_js
+    node_js: '4.2'
+  - env: PLATFORM=browser-safari
+    os: linux
+    language: node_js
+    node_js: '4.2'
+  - env: PLATFORM=browser-edge
+    os: linux
+    language: node_js
+    node_js: '4.2'
+  - env: PLATFORM=ios-9.3
+    os: osx
+    osx_image: xcode7.3
+    language: node_js
+    node_js: "4.2"
+  - env: PLATFORM=ios-10.0
+    os: osx
+    osx_image: xcode7.3
+    language: node_js
+    node_js: "4.2"
+  - env: PLATFORM=android-4.4
+    os: linux
+    language: android
+    jdk: oraclejdk8
+    android:
+      components:
+      - tools
+      - extra-android-m2repository
+  - env: PLATFORM=android-5.1
+    os: linux
+    language: android
+    jdk: oraclejdk8
+    android:
+      components:
+      - tools
+      - extra-android-m2repository
+  - env: PLATFORM=android-6.0
+    os: linux
+    language: android
+    jdk: oraclejdk8
+    android:
+      components:
+      - tools
+      - extra-android-m2repository
+  - env: PLATFORM=android-7.0
+    os: linux
+    language: android
+    jdk: oraclejdk8
+    android:
+      components:
+      - tools
+      - extra-android-m2repository
+before_install:
+- rm -rf ~/.nvm && git clone https://github.com/creationix/nvm.git ~/.nvm && (cd ~/.nvm && git checkout `git describe --abbrev=0 --tags`) && source ~/.nvm/nvm.sh && nvm install $TRAVIS_NODE_VERSION
+- node --version
+- if [[ "$PLATFORM" =~ android ]]; then gradle --version; fi
+- if [[ "$PLATFORM" =~ ios ]]; then npm install -g ios-deploy; fi
+- if [[ "$PLATFORM" =~ android ]]; then echo y | android update sdk -u --filter android-22,android-23,android-24,android-25,android-26;
+  fi
+- git clone https://github.com/apache/cordova-paramedic /tmp/paramedic && pushd /tmp/paramedic
+  && npm install && popd
+- npm install -g cordova
 install:
-  - echo -e "Host github.com\n\tStrictHostKeyChecking no\n" >> ~/.ssh/config 
-  - cd ..
-  - npm install -g cordova-paramedic
-  - npm install -g cordova
-  - npm install -g ios-sim
+- npm install
 script:
-  - cordova-paramedic --platform ios --plugin ${TRAVIS_BUILD_DIR}
+- if [[ "$TEST_DIR" != "" ]];
+  then cd $TEST_DIR && npm install && npm test;
+  else
+  node /tmp/paramedic/main.js --config pr/$PLATFORM --plugin $(pwd) --shouldUseSauce
+  --buildName travis-plugin-camera-$TRAVIS_JOB_NUMBER;
+  fi
+

CONTRIBUTING.md

@@ -27,7 +27,7 @@ There are multiple ways to contribute: report bugs, improve the docs, and
 contribute code.
 
 For instructions on this, start with the 
-[contribution overview](http://cordova.apache.org/#contribute).
+[contribution overview](http://cordova.apache.org/contribute/).
 
 The details are explained there, but the important items are:
  - Sign and submit an Apache ICLA (Contributor License Agreement).

README.md

@@ -1,3 +1,7 @@
+---
+title: Camera
+description: Take pictures with the device camera.
+---
 <!---
 # license: Licensed to the Apache Software Foundation (ASF) under one
 #         or more contributor license agreements.  See the NOTICE file
@@ -17,9 +21,11 @@
 #         under the License.
 -->
 
-# cordova-plugin-camera
+|AppVeyor|Travis CI|
+|:-:|:-:|
+|[![Build status](https://ci.appveyor.com/api/projects/status/github/apache/cordova-plugin-camera?branch=master)](https://ci.appveyor.com/project/ApacheSoftwareFoundation/cordova-plugin-camera)|[![Build Status](https://travis-ci.org/apache/cordova-plugin-camera.svg?branch=master)](https://travis-ci.org/apache/cordova-plugin-camera)|
 
-[![Build Status](https://travis-ci.org/apache/cordova-plugin-camera.svg)](https://travis-ci.org/apache/cordova-plugin-camera)
+# cordova-plugin-camera
 
 This plugin defines a global `navigator.camera` object, which provides an API for taking pictures and for choosing images from
 the system's image library.
@@ -31,60 +37,137 @@ Although the object is attached to the global scoped `navigator`, it is not avai
         console.log(navigator.camera);
     }
 
+
 ## Installation
 
+This requires cordova 5.0+
+
     cordova plugin add cordova-plugin-camera
+Older versions of cordova can still install via the __deprecated__ id
 
-## API
-- Camera
-    - navigator.camera.getPicture(success, fail, options)
-    - CameraOptions
-    - CameraPopoverHandle
-    - CameraPopoverOptions
-    - navigator.camera.cleanup
+    cordova plugin add org.apache.cordova.camera
+It is also possible to install via repo url directly ( unstable )
+
+    cordova plugin add https://github.com/apache/cordova-plugin-camera.git
+
+
+## How to Contribute
+
+Contributors are welcome! And we need your contributions to keep the project moving forward. You can [report bugs](https://issues.apache.org/jira/issues/?jql=project%20%3D%20CB%20AND%20status%20in%20(Open%2C%20%22In%20Progress%22%2C%20Reopened)%20AND%20resolution%20%3D%20Unresolved%20AND%20component%20%3D%20%22cordova-plugin-camera%22%20ORDER%20BY%20priority%20DESC%2C%20summary%20ASC%2C%20updatedDate%20DESC), improve the documentation, or [contribute code](https://github.com/apache/cordova-plugin-camera/pulls).
+
+There is a specific [contributor workflow](http://wiki.apache.org/cordova/ContributorWorkflow) we recommend. Start reading there. More information is available on [our wiki](http://wiki.apache.org/cordova).
+
+:warning: **Found an issue?** File it on [JIRA issue tracker](https://issues.apache.org/jira/issues/?jql=project%20%3D%20CB%20AND%20status%20in%20(Open%2C%20%22In%20Progress%22%2C%20Reopened)%20AND%20resolution%20%3D%20Unresolved%20AND%20component%20%3D%20%22cordova-plugin-camera%22%20ORDER%20BY%20priority%20DESC%2C%20summary%20ASC%2C%20updatedDate%20DESC).
+
+**Have a solution?** Send a [Pull Request](https://github.com/apache/cordova-plugin-camera/pulls).
+
+In order for your changes to be accepted, you need to sign and submit an Apache [ICLA](http://www.apache.org/licenses/#clas) (Individual Contributor License Agreement). Then your name will appear on the list of CLAs signed by [non-committers](https://people.apache.org/committer-index.html#unlistedclas) or [Cordova committers](http://people.apache.org/committers-by-project.html#cordova).
+
+**And don't forget to test and document your code.**
+
+
+## This documentation is generated by a tool
+
+:warning: Run `npm install` in the plugin repo to enable automatic docs generation if you plan to send a PR.  
+[jsdoc-to-markdown](https://www.npmjs.com/package/jsdoc-to-markdown) is used to generate the docs.  
+Documentation consists of template and API docs produced from the plugin JS code and should be regenerated before each commit (done automatically via [husky](https://github.com/typicode/husky), running `npm run gen-docs` script as a `precommit` hook - see `package.json` for details).
 
 
 
-## navigator.camera.getPicture
+### iOS Quirks
 
+Since iOS 10 it's mandatory to provide an usage description in the `info.plist` if trying to access privacy-sensitive data. When the system prompts the user to allow access, this usage description string will displayed as part of the permission dialog box, but if you didn't provide the usage description, the app will crash before showing the dialog. Also, Apple will reject apps that access private data but don't provide an usage description.
+
+This plugins requires the following usage descriptions:
+
+- `NSCameraUsageDescription` specifies the reason for your app to access the device's camera.
+- `NSPhotoLibraryUsageDescription` specifies the reason for your app to access the user's photo library.
+- `NSLocationWhenInUseUsageDescription` specifies the reason for your app to access the user's location information while your app is in use. (Set it if you have `CameraUsesGeolocation` preference set to `true`)
+- `NSPhotoLibraryAddUsageDescription` specifies the reason for your app to get write-only access to the user's photo library
+
+To add these entries into the `info.plist`, you can use the `edit-config` tag in the `config.xml` like this:
+
+```
+<edit-config target="NSCameraUsageDescription" file="*-Info.plist" mode="merge">
+    <string>need camera access to take pictures</string>
+</edit-config>
+```
+
+```
+<edit-config target="NSPhotoLibraryUsageDescription" file="*-Info.plist" mode="merge">
+    <string>need to photo library access to get pictures from there</string>
+</edit-config>
+```
+
+```
+<edit-config target="NSLocationWhenInUseUsageDescription" file="*-Info.plist" mode="merge">
+    <string>need location access to find things nearby</string>
+</edit-config>
+```
+
+```
+<edit-config target="NSPhotoLibraryAddUsageDescription" file="*-Info.plist" mode="merge">
+    <string>need to photo library access to save pictures there</string>
+</edit-config>
+```
+
+---
+
+# API Reference <a name="reference"></a>
+
+
+* [camera](#module_camera)
+    * [.getPicture(successCallback, errorCallback, options)](#module_camera.getPicture)
+    * [.cleanup()](#module_camera.cleanup)
+    * [.onError](#module_camera.onError) : <code>function</code>
+    * [.onSuccess](#module_camera.onSuccess) : <code>function</code>
+    * [.CameraOptions](#module_camera.CameraOptions) : <code>Object</code>
+
+
+* [Camera](#module_Camera)
+    * [.DestinationType](#module_Camera.DestinationType) : <code>enum</code>
+    * [.EncodingType](#module_Camera.EncodingType) : <code>enum</code>
+    * [.MediaType](#module_Camera.MediaType) : <code>enum</code>
+    * [.PictureSourceType](#module_Camera.PictureSourceType) : <code>enum</code>
+    * [.PopoverArrowDirection](#module_Camera.PopoverArrowDirection) : <code>enum</code>
+    * [.Direction](#module_Camera.Direction) : <code>enum</code>
+
+* [CameraPopoverHandle](#module_CameraPopoverHandle)
+* [CameraPopoverOptions](#module_CameraPopoverOptions)
+
+---
+
+<a name="module_camera"></a>
+
+## camera
+<a name="module_camera.getPicture"></a>
+
+### camera.getPicture(successCallback, errorCallback, options)
 Takes a photo using the camera, or retrieves a photo from the device's
 image gallery.  The image is passed to the success callback as a
-base64-encoded `String`, or as the URI for the image file.  The method
-itself returns a `CameraPopoverHandle` object that can be used to
-reposition the file selection popover.
-
-    navigator.camera.getPicture(cameraSuccess, cameraError, cameraOptions);
-
-#### Description
+Base64-encoded `String`, or as the URI for the image file.
 
 The `camera.getPicture` function opens the device's default camera
-application that allows users to snap pictures. This behavior occurs
-by default, when `Camera.sourceType` equals
-`Camera.PictureSourceType.CAMERA`.  Once the user snaps the photo, the
-camera application closes and the application is restored.
+application that allows users to snap pictures by default - this behavior occurs,
+when `Camera.sourceType` equals [`Camera.PictureSourceType.CAMERA`](#module_Camera.PictureSourceType).
+Once the user snaps the photo, the camera application closes and the application is restored.
 
 If `Camera.sourceType` is `Camera.PictureSourceType.PHOTOLIBRARY` or
 `Camera.PictureSourceType.SAVEDPHOTOALBUM`, then a dialog displays
-that allows users to select an existing image.  The
-`camera.getPicture` function returns a `CameraPopoverHandle` object,
-which can be used to reposition the image selection dialog, for
-example, when the device orientation changes.
+that allows users to select an existing image.
 
-The return value is sent to the `cameraSuccess` callback function, in
+The return value is sent to the [`cameraSuccess`](#module_camera.onSuccess) callback function, in
 one of the following formats, depending on the specified
 `cameraOptions`:
 
-- A `String` containing the base64-encoded photo image.
-
+- A `String` containing the Base64-encoded photo image.
 - A `String` representing the image file location on local storage (default).
 
 You can do whatever you want with the encoded image or URI, for
 example:
 
 - Render the image in an `<img>` tag, as in the example below
-
 - Save the data locally (`LocalStorage`, [Lawnchair](http://brianleroux.github.com/lawnchair/), etc.)
-
 - Post the data to a remote server
 
 __NOTE__: Photo resolution on newer devices is quite good. Photos
@@ -93,26 +176,257 @@ quality, even if a `quality` parameter is specified.  To avoid common
 memory problems, set `Camera.destinationType` to `FILE_URI` rather
 than `DATA_URL`.
 
-#### Supported Platforms
+__Supported Platforms__
 
-![](doc/img/android-success.png) ![](doc/img/blackberry-success.png) ![](doc/img/browser-success.png) ![](doc/img/firefox-success.png) ![](doc/img/fireos-success.png) ![](doc/img/ios-success.png) ![](doc/img/windows-success.png) ![](doc/img/wp8-success.png) ![](doc/img/ubuntu-success.png)
+- Android
+- BlackBerry
+- Browser
+- Firefox
+- FireOS
+- iOS
+- Windows
+- WP8
+- Ubuntu
 
-#### Example
+More examples [here](#camera-getPicture-examples). Quirks [here](#camera-getPicture-quirks).
 
-Take a photo and retrieve it as a base64-encoded image:
+**Kind**: static method of <code>[camera](#module_camera)</code>  
 
-    navigator.camera.getPicture(onSuccess, onFail, { quality: 50,
-        destinationType: Camera.DestinationType.DATA_URL
-    });
+| Param | Type | Description |
+| --- | --- | --- |
+| successCallback | <code>[onSuccess](#module_camera.onSuccess)</code> |  |
+| errorCallback | <code>[onError](#module_camera.onError)</code> |  |
+| options | <code>[CameraOptions](#module_camera.CameraOptions)</code> | CameraOptions |
 
-    function onSuccess(imageData) {
-        var image = document.getElementById('myImage');
-        image.src = "data:image/jpeg;base64," + imageData;
-    }
+**Example**  
+```js
+navigator.camera.getPicture(cameraSuccess, cameraError, cameraOptions);
+```
+<a name="module_camera.cleanup"></a>
 
-    function onFail(message) {
-        alert('Failed because: ' + message);
-    }
+### camera.cleanup()
+Removes intermediate image files that are kept in temporary storage
+after calling [`camera.getPicture`](#module_camera.getPicture). Applies only when the value of
+`Camera.sourceType` equals `Camera.PictureSourceType.CAMERA` and the
+`Camera.destinationType` equals `Camera.DestinationType.FILE_URI`.
+
+__Supported Platforms__
+
+- iOS
+
+**Kind**: static method of <code>[camera](#module_camera)</code>  
+**Example**  
+```js
+navigator.camera.cleanup(onSuccess, onFail);
+
+function onSuccess() {
+    console.log("Camera cleanup success.")
+}
+
+function onFail(message) {
+    alert('Failed because: ' + message);
+}
+```
+<a name="module_camera.onError"></a>
+
+### camera.onError : <code>function</code>
+Callback function that provides an error message.
+
+**Kind**: static typedef of <code>[camera](#module_camera)</code>  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| message | <code>string</code> | The message is provided by the device's native code. |
+
+<a name="module_camera.onSuccess"></a>
+
+### camera.onSuccess : <code>function</code>
+Callback function that provides the image data.
+
+**Kind**: static typedef of <code>[camera](#module_camera)</code>  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| imageData | <code>string</code> | Base64 encoding of the image data, _or_ the image file URI, depending on [`cameraOptions`](#module_camera.CameraOptions) in effect. |
+
+**Example**  
+```js
+// Show image
+//
+function cameraCallback(imageData) {
+   var image = document.getElementById('myImage');
+   image.src = "data:image/jpeg;base64," + imageData;
+}
+```
+<a name="module_camera.CameraOptions"></a>
+
+### camera.CameraOptions : <code>Object</code>
+Optional parameters to customize the camera settings.
+* [Quirks](#CameraOptions-quirks)
+
+**Kind**: static typedef of <code>[camera](#module_camera)</code>  
+**Properties**
+
+| Name | Type | Default | Description |
+| --- | --- | --- | --- |
+| quality | <code>number</code> | <code>50</code> | Quality of the saved image, expressed as a range of 0-100, where 100 is typically full resolution with no loss from file compression. (Note that information about the camera's resolution is unavailable.) |
+| destinationType | <code>[DestinationType](#module_Camera.DestinationType)</code> | <code>FILE_URI</code> | Choose the format of the return value. |
+| sourceType | <code>[PictureSourceType](#module_Camera.PictureSourceType)</code> | <code>CAMERA</code> | Set the source of the picture. |
+| allowEdit | <code>Boolean</code> | <code>true</code> | Allow simple editing of image before selection. |
+| encodingType | <code>[EncodingType](#module_Camera.EncodingType)</code> | <code>JPEG</code> | Choose the  returned image file's encoding. |
+| targetWidth | <code>number</code> |  | Width in pixels to scale image. Must be used with `targetHeight`. Aspect ratio remains constant. |
+| targetHeight | <code>number</code> |  | Height in pixels to scale image. Must be used with `targetWidth`. Aspect ratio remains constant. |
+| mediaType | <code>[MediaType](#module_Camera.MediaType)</code> | <code>PICTURE</code> | Set the type of media to select from.  Only works when `PictureSourceType` is `PHOTOLIBRARY` or `SAVEDPHOTOALBUM`. |
+| correctOrientation | <code>Boolean</code> |  | Rotate the image to correct for the orientation of the device during capture. |
+| saveToPhotoAlbum | <code>Boolean</code> |  | Save the image to the photo album on the device after capture. |
+| popoverOptions | <code>[CameraPopoverOptions](#module_CameraPopoverOptions)</code> |  | iOS-only options that specify popover location in iPad. |
+| cameraDirection | <code>[Direction](#module_Camera.Direction)</code> | <code>BACK</code> | Choose the camera to use (front- or back-facing). |
+
+---
+
+<a name="module_Camera"></a>
+
+## Camera
+<a name="module_Camera.DestinationType"></a>
+
+### Camera.DestinationType : <code>enum</code>
+Defines the output format of `Camera.getPicture` call.
+_Note:_ On iOS passing `DestinationType.NATIVE_URI` along with
+`PictureSourceType.PHOTOLIBRARY` or `PictureSourceType.SAVEDPHOTOALBUM` will
+disable any image modifications (resize, quality change, cropping, etc.) due
+to implementation specific.
+
+**Kind**: static enum property of <code>[Camera](#module_Camera)</code>  
+**Properties**
+
+| Name | Type | Default | Description |
+| --- | --- | --- | --- |
+| DATA_URL | <code>number</code> | <code>0</code> | Return base64 encoded string. DATA_URL can be very memory intensive and cause app crashes or out of memory errors. Use FILE_URI or NATIVE_URI if possible |
+| FILE_URI | <code>number</code> | <code>1</code> | Return file uri (content://media/external/images/media/2 for Android) |
+| NATIVE_URI | <code>number</code> | <code>2</code> | Return native uri (eg. asset-library://... for iOS) |
+
+<a name="module_Camera.EncodingType"></a>
+
+### Camera.EncodingType : <code>enum</code>
+**Kind**: static enum property of <code>[Camera](#module_Camera)</code>  
+**Properties**
+
+| Name | Type | Default | Description |
+| --- | --- | --- | --- |
+| JPEG | <code>number</code> | <code>0</code> | Return JPEG encoded image |
+| PNG | <code>number</code> | <code>1</code> | Return PNG encoded image |
+
+<a name="module_Camera.MediaType"></a>
+
+### Camera.MediaType : <code>enum</code>
+**Kind**: static enum property of <code>[Camera](#module_Camera)</code>  
+**Properties**
+
+| Name | Type | Default | Description |
+| --- | --- | --- | --- |
+| PICTURE | <code>number</code> | <code>0</code> | Allow selection of still pictures only. DEFAULT. Will return format specified via DestinationType |
+| VIDEO | <code>number</code> | <code>1</code> | Allow selection of video only, ONLY RETURNS URL |
+| ALLMEDIA | <code>number</code> | <code>2</code> | Allow selection from all media types |
+
+<a name="module_Camera.PictureSourceType"></a>
+
+### Camera.PictureSourceType : <code>enum</code>
+Defines the output format of `Camera.getPicture` call.
+_Note:_ On iOS passing `PictureSourceType.PHOTOLIBRARY` or `PictureSourceType.SAVEDPHOTOALBUM`
+along with `DestinationType.NATIVE_URI` will disable any image modifications (resize, quality
+change, cropping, etc.) due to implementation specific.
+
+**Kind**: static enum property of <code>[Camera](#module_Camera)</code>  
+**Properties**
+
+| Name | Type | Default | Description |
+| --- | --- | --- | --- |
+| PHOTOLIBRARY | <code>number</code> | <code>0</code> | Choose image from the device's photo library (same as SAVEDPHOTOALBUM for Android) |
+| CAMERA | <code>number</code> | <code>1</code> | Take picture from camera |
+| SAVEDPHOTOALBUM | <code>number</code> | <code>2</code> | Choose image only from the device's Camera Roll album (same as PHOTOLIBRARY for Android) |
+
+<a name="module_Camera.PopoverArrowDirection"></a>
+
+### Camera.PopoverArrowDirection : <code>enum</code>
+Matches iOS UIPopoverArrowDirection constants to specify arrow location on popover.
+
+**Kind**: static enum property of <code>[Camera](#module_Camera)</code>  
+**Properties**
+
+| Name | Type | Default |
+| --- | --- | --- |
+| ARROW_UP | <code>number</code> | <code>1</code> | 
+| ARROW_DOWN | <code>number</code> | <code>2</code> | 
+| ARROW_LEFT | <code>number</code> | <code>4</code> | 
+| ARROW_RIGHT | <code>number</code> | <code>8</code> | 
+| ARROW_ANY | <code>number</code> | <code>15</code> | 
+
+<a name="module_Camera.Direction"></a>
+
+### Camera.Direction : <code>enum</code>
+**Kind**: static enum property of <code>[Camera](#module_Camera)</code>  
+**Properties**
+
+| Name | Type | Default | Description |
+| --- | --- | --- | --- |
+| BACK | <code>number</code> | <code>0</code> | Use the back-facing camera |
+| FRONT | <code>number</code> | <code>1</code> | Use the front-facing camera |
+
+---
+
+<a name="module_CameraPopoverOptions"></a>
+
+## CameraPopoverOptions
+iOS-only parameters that specify the anchor element location and arrow
+direction of the popover when selecting images from an iPad's library
+or album.
+Note that the size of the popover may change to adjust to the
+direction of the arrow and orientation of the screen.  Make sure to
+account for orientation changes when specifying the anchor element
+location.
+
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [x] | <code>Number</code> | <code>0</code> | x pixel coordinate of screen element onto which to anchor the popover. |
+| [y] | <code>Number</code> | <code>32</code> | y pixel coordinate of screen element onto which to anchor the popover. |
+| [width] | <code>Number</code> | <code>320</code> | width, in pixels, of the screen element onto which to anchor the popover. |
+| [height] | <code>Number</code> | <code>480</code> | height, in pixels, of the screen element onto which to anchor the popover. |
+| [arrowDir] | <code>[PopoverArrowDirection](#module_Camera.PopoverArrowDirection)</code> | <code>ARROW_ANY</code> | Direction the arrow on the popover should point. |
+
+---
+
+<a name="module_CameraPopoverHandle"></a>
+
+## CameraPopoverHandle
+A handle to an image picker popover.
+
+__Supported Platforms__
+
+- iOS
+
+**Example**  
+```js
+navigator.camera.getPicture(onSuccess, onFail,
+{
+    destinationType: Camera.DestinationType.FILE_URI,
+    sourceType: Camera.PictureSourceType.PHOTOLIBRARY,
+    popoverOptions: new CameraPopoverOptions(300, 300, 100, 100, Camera.PopoverArrowDirection.ARROW_ANY)
+});
+
+// Reposition the popover if the orientation changes.
+window.onorientationchange = function() {
+    var cameraPopoverHandle = new CameraPopoverHandle();
+    var cameraPopoverOptions = new CameraPopoverOptions(0, 0, 100, 100, Camera.PopoverArrowDirection.ARROW_ANY);
+    cameraPopoverHandle.setPosition(cameraPopoverOptions);
+}
+```
+---
+
+
+## `camera.getPicture` Errata
+
+#### Example <a name="camera-getPicture-examples"></a>
 
 Take a photo and retrieve the image's file location:
 
@@ -128,31 +442,57 @@ Take a photo and retrieve the image's file location:
         alert('Failed because: ' + message);
     }
 
+Take a photo and retrieve it as a Base64-encoded image:
+
+    /**
+     * Warning: Using DATA_URL is not recommended! The DATA_URL destination
+     * type is very memory intensive, even with a low quality setting. Using it
+     * can result in out of memory errors and application crashes. Use FILE_URI
+     * or NATIVE_URI instead.
+     */
+    navigator.camera.getPicture(onSuccess, onFail, { quality: 25,
+        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);
+    }
+
 #### Preferences (iOS)
 
 -  __CameraUsesGeolocation__ (boolean, defaults to false). For capturing JPEGs, set to true to get geolocation data in the EXIF header. This will trigger a request for geolocation permissions if set to true.
 
         <preference name="CameraUsesGeolocation" value="false" />
 
-#### Amazon Fire OS Quirks
+#### Amazon Fire OS Quirks <a name="camera-getPicture-quirks"></a>
 
 Amazon Fire OS uses intents to launch the camera activity on the device to capture
 images, and on phones with low memory, the Cordova activity may be killed.  In this
-scenario, the image may not appear when the cordova activity is restored.
+scenario, the image may not appear when the Cordova activity is restored.
 
 #### Android Quirks
 
 Android uses intents to launch the camera activity on the device to capture
 images, and on phones with low memory, the Cordova activity may be killed.  In this
-scenario, the image may not appear when the Cordova activity is restored.
+scenario, the result from the plugin call will be delivered via the resume event.
+See [the Android Lifecycle guide][android_lifecycle]
+for more information. The `pendingResult.result` value will contain the value that
+would be passed to the callbacks (either the URI/URL or an error message). Check
+the `pendingResult.pluginStatus` to determine whether or not the call was
+successful.
 
 #### Browser Quirks
 
-Can only return photos as base64-encoded image.
+Can only return photos as Base64-encoded image.
 
 #### Firefox OS Quirks
 
-Camera plugin is currently implemented using [Web Activities](https://hacks.mozilla.org/2013/01/introducing-web-activities/). 
+Camera plugin is currently implemented using [Web Activities][web_activities].
 
 #### iOS Quirks
 
@@ -170,77 +510,24 @@ displays:
 Invoking the native camera application while the device is connected
 via Zune does not work, and triggers an error callback.
 
+#### Windows quirks
+
+On Windows Phone 8.1 using `SAVEDPHOTOALBUM` or `PHOTOLIBRARY` as a source type causes application to suspend until file picker returns the selected image and
+then restore with start page as defined in app's `config.xml`. In case when `camera.getPicture` was called from different page, this will lead to reloading
+start page from scratch and success and error callbacks will never be called.
+
+To avoid this we suggest using SPA pattern or call `camera.getPicture` only from your app's start page.
+
+More information about Windows Phone 8.1 picker APIs is here: [How to continue your Windows Phone app after calling a file picker](https://msdn.microsoft.com/en-us/library/windows/apps/dn720490.aspx)
+
 #### Tizen Quirks
 
 Tizen only supports a `destinationType` of
 `Camera.DestinationType.FILE_URI` and a `sourceType` of
 `Camera.PictureSourceType.PHOTOLIBRARY`.
 
-## CameraOptions
 
-Optional parameters to customize the camera settings.
-
-    { quality : 75,
-      destinationType : Camera.DestinationType.DATA_URL,
-      sourceType : Camera.PictureSourceType.CAMERA,
-      allowEdit : true,
-      encodingType: Camera.EncodingType.JPEG,
-      targetWidth: 100,
-      targetHeight: 100,
-      popoverOptions: CameraPopoverOptions,
-      saveToPhotoAlbum: false };
-
-- __quality__: Quality of the saved image, expressed as a range of 0-100, where 100 is typically full resolution with no loss from file compression. The default is 50. _(Number)_ (Note that information about the camera's resolution is unavailable.)
-
-- __destinationType__: Choose the format of the return value. The default is FILE_URI. Defined in `navigator.camera.DestinationType` _(Number)_
-
-        Camera.DestinationType = {
-            DATA_URL : 0,      // Return image as base64-encoded string
-            FILE_URI : 1,      // Return image file URI
-            NATIVE_URI : 2     // Return image native URI (e.g., assets-library:// on iOS or content:// on Android)
-        };
-
-- __sourceType__: Set the source of the picture. The default is CAMERA. Defined in `navigator.camera.PictureSourceType` _(Number)_
-
-        Camera.PictureSourceType = {
-            PHOTOLIBRARY : 0,
-            CAMERA : 1,
-            SAVEDPHOTOALBUM : 2
-        };
-
-- __allowEdit__: Allow simple editing of image before selection. _(Boolean)_
-
-- __encodingType__: Choose the  returned image file's encoding. Default is JPEG. Defined in `navigator.camera.EncodingType` _(Number)_
-
-        Camera.EncodingType = {
-            JPEG : 0,               // Return JPEG encoded image
-            PNG : 1                 // Return PNG encoded image
-        };
-
-- __targetWidth__: Width in pixels to scale image. Must be used with __targetHeight__.  Aspect ratio remains constant. _(Number)_
-
-- __targetHeight__: Height in pixels to scale image. Must be used with __targetWidth__. Aspect ratio remains constant. _(Number)_
-
-- __mediaType__: Set the type of media to select from.  Only works when `PictureSourceType` is `PHOTOLIBRARY` or `SAVEDPHOTOALBUM`. Defined in `nagivator.camera.MediaType` _(Number)_
-
-        Camera.MediaType = {
-            PICTURE: 0,    // allow selection of still pictures only. DEFAULT. Will return format specified via DestinationType
-            VIDEO: 1,      // allow selection of video only, WILL ALWAYS RETURN FILE_URI
-            ALLMEDIA : 2   // allow selection from all media types
-        };
-
-- __correctOrientation__: Rotate the image to correct for the orientation of the device during capture. _(Boolean)_
-
-- __saveToPhotoAlbum__: Save the image to the photo album on the device after capture. _(Boolean)_
-
-- __popoverOptions__: iOS-only options that specify popover location in iPad.  Defined in `CameraPopoverOptions`.
-
-- __cameraDirection__: Choose the camera to use (front- or back-facing). The default is BACK. Defined in `navigator.camera.Direction` _(Number)_
-
-        Camera.Direction = {
-            BACK : 0,      // Use the back-facing camera
-            FRONT : 1      // Use the front-facing camera
-        };
+## `CameraOptions` Errata <a name="CameraOptions-quirks"></a>
 
 #### Amazon Fire OS Quirks
 
@@ -254,11 +541,12 @@ Optional parameters to customize the camera settings.
 
 - Any `cameraDirection` value results in a back-facing photo.
 
-- Android also uses the Crop Activity for allowEdit, even though crop should work and actually pass the cropped image back to Cordova, the only one that works consistently is the one bundled 
-with the Google Plus Photos application.  Other crops may not work.
+- **`allowEdit` is unpredictable on Android and it should not be used!** The Android implementation of this plugin tries to find and use an application on the user's device to do image cropping. The plugin has no control over what application the user selects to perform the image cropping and it is very possible that the user could choose an incompatible option and cause the plugin to fail. This sometimes works because most devices come with an application that handles cropping in a way that is compatible with this plugin (Google Plus Photos), but it is unwise to rely on that being the case. If image editing is essential to your application, consider seeking a third party library or plugin that provides its own image editing utility for a more robust solution.
 
 - `Camera.PictureSourceType.PHOTOLIBRARY` and `Camera.PictureSourceType.SAVEDPHOTOALBUM` both display the same photo album.
 
+- Ignores the `encodingType` parameter if the image is unedited (i.e. `quality` is 100, `correctOrientation` is false, and no `targetHeight` or `targetWidth` are specified). The `CAMERA` source will always return the JPEG file given by the native camera and the `PHOTOLIBRARY` and `SAVEDPHOTOALBUM` sources will return the selected file in its existing encoding.
+
 #### BlackBerry 10 Quirks
 
 - Ignores the `quality` parameter.
@@ -293,10 +581,12 @@ with the Google Plus Photos application.  Other crops may not work.
 
 #### iOS Quirks
 
-- Set `quality` below 50 to avoid memory errors on some devices.
-
 - When using `destinationType.FILE_URI`, photos are saved in the application's temporary directory. The contents of the application's temporary directory is deleted when the application ends.
 
+- When using `destinationType.NATIVE_URI` and `sourceType.CAMERA`, photos are saved in the saved photo album regardless on the value of `saveToPhotoAlbum` parameter.
+
+- When using `destinationType.NATIVE_URI` and `sourceType.PHOTOLIBRARY` or `sourceType.SAVEDPHOTOALBUM`, all editing options are ignored and link is returned to original picture.
+
 #### Tizen Quirks
 
 - options not supported
@@ -311,137 +601,210 @@ with the Google Plus Photos application.  Other crops may not work.
 
 - Ignores the `cameraDirection` parameter.
 
-- Ignores the `saveToPhotoAlbum` parameter.  IMPORTANT: All images taken with the wp7/8 cordova camera API are always copied to the phone's camera roll.  Depending on the user's settings, this could also mean the image is auto-uploaded to their OneDrive.  This could potentially mean the image is available to a wider audience than your app intended.  If this a blocker for your application, you will need to implement the CameraCaptureTask as documented on msdn : [http://msdn.microsoft.com/en-us/library/windowsphone/develop/hh394006.aspx](http://msdn.microsoft.com/en-us/library/windowsphone/develop/hh394006.aspx)
-You may also comment or up-vote the related issue in the [issue tracker](https://issues.apache.org/jira/browse/CB-2083)
+- Ignores the `saveToPhotoAlbum` parameter.  IMPORTANT: All images taken with the WP8/8 Cordova camera API are always copied to the phone's camera roll.  Depending on the user's settings, this could also mean the image is auto-uploaded to their OneDrive.  This could potentially mean the image is available to a wider audience than your app intended. If this is a blocker for your application, you will need to implement the CameraCaptureTask as [documented on MSDN][msdn_wp8_docs]. You may also comment or up-vote the related issue in the [issue tracker][wp8_bug].
 
 - Ignores the `mediaType` property of `cameraOptions` as the Windows Phone SDK does not provide a way to choose videos from PHOTOLIBRARY.
 
+[android_lifecycle]: http://cordova.apache.org/docs/en/dev/guide/platforms/android/lifecycle.html
+[web_activities]: https://hacks.mozilla.org/2013/01/introducing-web-activities/
+[wp8_bug]: https://issues.apache.org/jira/browse/CB-2083
+[msdn_wp8_docs]: http://msdn.microsoft.com/en-us/library/windowsphone/develop/hh394006.aspx
 
-## CameraError
+## Sample: Take Pictures, Select Pictures from the Picture Library, and Get Thumbnails <a name="sample"></a>
 
-onError callback function that provides an error message.
+The Camera plugin allows you to do things like open the device's Camera app and take a picture, or open the file picker and select one. The code snippets in this section demonstrate different tasks including:
 
-    function(message) {
-        // Show a helpful message
+* Open the Camera app and [take a Picture](#takePicture)
+* Take a picture and [return thumbnails](#getThumbnails) (resized picture)
+* Take a picture and [generate a FileEntry object](#convert)
+* [Select a file](#selectFile) from the picture library
+* Select a JPEG image and [return thumbnails](#getFileThumbnails) (resized image)
+* Select an image and [generate a FileEntry object](#convert)
+
+## Take a Picture <a name="takePicture"></a>
+
+Before you can take a picture, you need to set some Camera plugin options to pass into the Camera plugin's `getPicture` function. Here is a common set of recommendations. In this example, you create the object that you will use for the Camera options, and set the `sourceType` dynamically to support both the Camera app and the file picker.
+
+```js
+function setOptions(srcType) {
+    var options = {
+        // Some common settings are 20, 50, and 100
+        quality: 50,
+        destinationType: Camera.DestinationType.FILE_URI,
+        // In this app, dynamically set the picture source, Camera or photo gallery
+        sourceType: srcType,
+        encodingType: Camera.EncodingType.JPEG,
+        mediaType: Camera.MediaType.PICTURE,
+        allowEdit: true,
+        correctOrientation: true  //Corrects Android orientation quirks
+    }
+    return options;
+}
+```
+
+Typically, you want to use a FILE_URI instead of a DATA_URL to avoid most memory issues. JPEG is the recommended encoding type for Android.
+
+You take a picture by passing in the options object to `getPicture`, which takes a CameraOptions object as the third argument. When you call `setOptions`, pass `Camera.PictureSourceType.CAMERA` as the picture source.
+
+```js
+function openCamera(selection) {
+
+    var srcType = Camera.PictureSourceType.CAMERA;
+    var options = setOptions(srcType);
+    var func = createNewFileEntry;
+
+    navigator.camera.getPicture(function cameraSuccess(imageUri) {
+
+        displayImage(imageUri);
+        // You may choose to copy the picture, save it somewhere, or upload.
+        func(imageUri);
+
+    }, function cameraError(error) {
+        console.debug("Unable to obtain picture: " + error, "app");
+
+    }, options);
+}
+```
+
+Once you take the picture, you can display it or do something else. In this example, call the app's `displayImage` function from the preceding code.
+
+```js
+function displayImage(imgUri) {
+
+    var elem = document.getElementById('imageFile');
+    elem.src = imgUri;
+}
+```
+
+To display the image on some platforms, you might need to include the main part of the URI in the Content-Security-Policy `<meta>` element in index.html. For example, on Windows 10, you can include `ms-appdata:` in your `<meta>` element. Here is an example.
+
+```html
+<meta http-equiv="Content-Security-Policy" content="default-src 'self' data: gap: ms-appdata: https://ssl.gstatic.com 'unsafe-eval'; style-src 'self' 'unsafe-inline'; media-src *">
+```
+
+## Take a Picture and Return Thumbnails (Resize the Picture) <a name="getThumbnails"></a>
+
+To get smaller images, you can return a resized image by passing both `targetHeight` and `targetWidth` values with your CameraOptions object. In this example, you resize the returned image to fit in a 100px by 100px box (the aspect ratio is maintained, so 100px is either the height or width, whichever is greater in the source).
+
+```js
+function openCamera(selection) {
+
+    var srcType = Camera.PictureSourceType.CAMERA;
+    var options = setOptions(srcType);
+    var func = createNewFileEntry;
+
+    if (selection == "camera-thmb") {
+        options.targetHeight = 100;
+        options.targetWidth = 100;
     }
 
-#### Description
+    navigator.camera.getPicture(function cameraSuccess(imageUri) {
 
-- __message__: The message is provided by the device's native code. _(String)_
+        // Do something
 
+    }, function cameraError(error) {
+        console.debug("Unable to obtain picture: " + error, "app");
 
-## cameraSuccess
+    }, options);
+}
+```
 
-onSuccess callback function that provides the image data.
+## Select a File from the Picture Library <a name="selectFile"></a>
 
-    function(imageData) {
-        // Do something with the image
+When selecting a file using the file picker, you also need to set the CameraOptions object. In this example, set the `sourceType` to `Camera.PictureSourceType.SAVEDPHOTOALBUM`. To open the file picker, call `getPicture` just as you did in the previous example, passing in the success and error callbacks along with CameraOptions object.
+
+```js
+function openFilePicker(selection) {
+
+    var srcType = Camera.PictureSourceType.SAVEDPHOTOALBUM;
+    var options = setOptions(srcType);
+    var func = createNewFileEntry;
+
+    navigator.camera.getPicture(function cameraSuccess(imageUri) {
+
+        // Do something
+
+    }, function cameraError(error) {
+        console.debug("Unable to obtain picture: " + error, "app");
+
+    }, options);
+}
+```
+
+## Select an Image and Return Thumbnails (resized images) <a name="getFileThumbnails"></a>
+
+Resizing a file selected with the file picker works just like resizing using the Camera app; set the `targetHeight` and `targetWidth` options.
+
+```js
+function openFilePicker(selection) {
+
+    var srcType = Camera.PictureSourceType.SAVEDPHOTOALBUM;
+    var options = setOptions(srcType);
+    var func = createNewFileEntry;
+
+    if (selection == "picker-thmb") {
+        // To downscale a selected image,
+        // Camera.EncodingType (e.g., JPEG) must match the selected image type.
+        options.targetHeight = 100;
+        options.targetWidth = 100;
     }
 
-#### Description
+    navigator.camera.getPicture(function cameraSuccess(imageUri) {
 
-- __imageData__: Base64 encoding of the image data, _or_ the image file URI, depending on `cameraOptions` in effect. _(String)_
+        // Do something with image
 
-#### Example
+    }, function cameraError(error) {
+        console.debug("Unable to obtain picture: " + error, "app");
 
-    // Show image
-    //
-    function cameraCallback(imageData) {
-        var image = document.getElementById('myImage');
-        image.src = "data:image/jpeg;base64," + imageData;
-    }
+    }, options);
+}
+```
 
+## Take a picture and get a FileEntry Object <a name="convert"></a>
 
-## CameraPopoverHandle
+If you want to do something like copy the image to another location, or upload it somewhere using the FileTransfer plugin, you need to get a FileEntry object for the returned picture. To do that, call `window.resolveLocalFileSystemURL` on the file URI returned by the Camera app. If you need to use a FileEntry object, set the `destinationType` to `Camera.DestinationType.FILE_URI` in your CameraOptions object (this is also the default value).
 
-A handle to the popover dialog created by `navigator.camera.getPicture`.
+>*Note* You need the [File plugin](https://www.npmjs.com/package/cordova-plugin-file) to call `window.resolveLocalFileSystemURL`.
 
-#### Description
+Here is the call to `window.resolveLocalFileSystemURL`. The image URI is passed to this function from the success callback of `getPicture`. The success handler of `resolveLocalFileSystemURL` receives the FileEntry object.
 
-- __setPosition__: Set the position of the popover. Takes the `CameraPopoverOptions` that specify the new position.
+```js
+function getFileEntry(imgUri) {
+    window.resolveLocalFileSystemURL(imgUri, function success(fileEntry) {
 
-#### Supported Platforms
+        // Do something with the FileEntry object, like write to it, upload it, etc.
+        // writeFile(fileEntry, imgUri);
+        console.log("got file: " + fileEntry.fullPath);
+        // displayFileData(fileEntry.nativeURL, "Native URL");
 
-![](doc/img/android-fail.png) ![](doc/img/blackberry-fail.png) ![](doc/img/browser-fail.png) ![](doc/img/firefox-fail.png) ![](doc/img/fireos-fail.png) ![](doc/img/ios-success.png) ![](doc/img/windows-fail.png) ![](doc/img/wp8-fail.png) ![](doc/img/ubuntu-fail.png)
+    }, function () {
+      // If don't get the FileEntry (which may happen when testing
+      // on some emulators), copy to a new FileEntry.
+        createNewFileEntry(imgUri);
+    });
+}
+```
 
-#### Example
+In the example shown in the preceding code, you call the app's `createNewFileEntry` function if you don't get a valid FileEntry object. The image URI returned from the Camera app should result in a valid FileEntry, but platform behavior on some emulators may be different for files returned from the file picker.
 
-     var cameraPopoverHandle = navigator.camera.getPicture(onSuccess, onFail,
-         { destinationType: Camera.DestinationType.FILE_URI,
-           sourceType: Camera.PictureSourceType.PHOTOLIBRARY,
-           popoverOptions: new CameraPopoverOptions(300, 300, 100, 100, Camera.PopoverArrowDirection.ARROW_ANY)
-         });
+>*Note* To see an example of writing to a FileEntry, see the [File plugin README](https://www.npmjs.com/package/cordova-plugin-file).
 
-     // Reposition the popover if the orientation changes.
-     window.onorientationchange = function() {
-         var cameraPopoverOptions = new CameraPopoverOptions(0, 0, 100, 100, Camera.PopoverArrowDirection.ARROW_ANY);
-         cameraPopoverHandle.setPosition(cameraPopoverOptions);
-     }
+The code shown here creates a file in your app's cache (in sandboxed storage) named `tempFile.jpeg`. With the new FileEntry object, you can copy the image to the file or do something else like upload it.
 
-## CameraPopoverOptions
+```js
+function createNewFileEntry(imgUri) {
+    window.resolveLocalFileSystemURL(cordova.file.cacheDirectory, function success(dirEntry) {
 
-iOS-only parameters that specify the anchor element location and arrow
-direction of the popover when selecting images from an iPad's library
-or album.
+        // JPEG file
+        dirEntry.getFile("tempFile.jpeg", { create: true, exclusive: false }, function (fileEntry) {
 
-    { x : 0,
-      y :  32,
-      width : 320,
-      height : 480,
-      arrowDir : Camera.PopoverArrowDirection.ARROW_ANY
-    };
+            // Do something with it, like write to it, upload it, etc.
+            // writeFile(fileEntry, imgUri);
+            console.log("got file: " + fileEntry.fullPath);
+            // displayFileData(fileEntry.fullPath, "File copied to");
 
-#### Description
+        }, onErrorCreateFile);
 
-- __x__: x pixel coordinate of screen element onto which to anchor the popover. _(Number)_
-
-- __y__: y pixel coordinate of screen element onto which to anchor the popover. _(Number)_
-
-- __width__: width, in pixels, of the screen element onto which to anchor the popover. _(Number)_
-
-- __height__: height, in pixels, of the screen element onto which to anchor the popover. _(Number)_
-
-- __arrowDir__: Direction the arrow on the popover should point.  Defined in `Camera.PopoverArrowDirection` _(Number)_
-
-            Camera.PopoverArrowDirection = {
-                ARROW_UP : 1,        // matches iOS UIPopoverArrowDirection constants
-                ARROW_DOWN : 2,
-                ARROW_LEFT : 4,
-                ARROW_RIGHT : 8,
-                ARROW_ANY : 15
-            };
-
-Note that the size of the popover may change to adjust to the
-direction of the arrow and orientation of the screen.  Make sure to
-account for orientation changes when specifying the anchor element
-location.
-
-## navigator.camera.cleanup
-
-Removes intermediate photos taken by the camera from temporary
-storage.
-
-    navigator.camera.cleanup( cameraSuccess, cameraError );
-
-#### Description
-
-Removes intermediate image files that are kept in temporary storage
-after calling `camera.getPicture`. Applies only when the value of
-`Camera.sourceType` equals `Camera.PictureSourceType.CAMERA` and the
-`Camera.destinationType` equals `Camera.DestinationType.FILE_URI`.
-
-#### Supported Platforms
-
-![](doc/img/android-fail.png) ![](doc/img/blackberry-fail.png) ![](doc/img/browser-fail.png) ![](doc/img/firefox-fail.png) ![](doc/img/fireos-fail.png) ![](doc/img/ios-success.png) ![](doc/img/windows-fail.png) ![](doc/img/wp8-fail.png) ![](doc/img/ubuntu-fail.png)
-
-#### Example
-
-    navigator.camera.cleanup(onSuccess, onFail);
-
-    function onSuccess() {
-        console.log("Camera cleanup success.")
-    }
-
-    function onFail(message) {
-        alert('Failed because: ' + message);
-    }
+    }, onErrorResolveUrl);
+}
+```

RELEASENOTES.md

@@ -1,224 +1,3 @@
-<!--
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-# 
-# http://www.apache.org/licenses/LICENSE-2.0
-# 
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-#  KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
--->
-# Release Notes
+### 4.0.1 (Dec 27, 2017)
+* CB-13701Fix to allow 4.0.0 version install
 
-### 0.2.1 (Sept 5, 2013)
-* [CB-4656] Don't add line-breaks to base64-encoded images (Fixes type=DataURI)
-* [CB-4432] copyright notice change
-
-### 0.2.3 (Sept 25, 2013)
-* CB-4889 bumping&resetting version
-* CB-4889 forgot index.html
-* CB-4889 renaming core inside cameraProxy
-* [Windows8] commandProxy has moved
-* [Windows8] commandProxy has moved
-* added Camera API for FirefoxOS
-* Rename CHANGELOG.md -> RELEASENOTES.md
-* [CB-4823] Fix XCode 5 camera plugin warnings
-* Fix compiler warnings
-* [CB-4765] Move ExifHelper.java into Camera Plugin
-* [CB-4764] Remove reference to DirectoryManager from CameraLauncher
-* [CB-4763] Use a copy of FileHelper.java within camera-plugin.
-* [CB-4752] Incremented plugin version on dev branch.
-* CB-4633: We really should close cursors.  It's just the right thing to do.
-* No longer causes a stack trace, but it doesn't cause the error to be called.
-* CB-4889 renaming org.apache.cordova.core.camera to org.apache.cordova.camera
-
- ### 0.2.4 (Oct 28, 2013)
-* CB-5128: added repo + issue tag to plugin.xml for camera plugin
-* CB-4958 - iOS - Camera plugin should not show the status bar
-* [CB-4919] updated plugin.xml for FxOS
-* [CB-4915] Incremented plugin version on dev branch.
-
-### 0.2.5 (Dec 4, 2013)
-* fix camera for firefox os
-* getPicture via web activities
-* [ubuntu] specify policy_group
-* add ubuntu platform
-* 1. User Agent detection now detects AmazonWebView. 2. Change to use amazon-fireos as the platform if user agent string contains 'cordova-amazon-fireos'
-* Added amazon-fireos platform.
-
-### 0.2.6 (Jan 02, 2014)
-* CB-5658 Add doc/index.md for Camera plugin
-* CB-2442 CB-2419 Use Windows.Storage.ApplicationData.current.localFolder, instead of writing to app package.
-* [BlackBerry10] Adding platform level permissions
-* CB-5599 Android: Catch and ignore OutOfMemoryError in getRotatedBitmap()
-
-### 0.2.7 (Feb 05, 2014)
-* CB-4919 firefox os quirks added and supported platforms list is updated
-* getPicture via web activities
-* Documented quirk for CB-5335 + CB-5206 for WP7+8
-* reference the correct firefoxos implementation
-* [BlackBerry10] Add permission to access_shared
-
-### 0.2.8 (Feb 26, 2014)
-* CB-1826 Catch OOM on gallery image resize
-
-### 0.2.9 (Apr 17, 2014)
-* CB-6460: Update license headers
-* CB-6422: [windows8] use cordova/exec/proxy
-* [WP8] When only targetWidth or targetHeight is provided, use it as the only bound
-* CB-4027, CB-5102, CB-2737, CB-2387: [WP] Fix camera issues, cropping, memory leaks
-* CB-6212: [iOS] fix warnings compiled under arm64 64-bit
-* [BlackBerry10] Add rim xml namespaces declaration
-* Add NOTICE file
-
-### 0.3.0 (Jun 05, 2014)
-* CB-2083 documented saveToPhotoAlbum quirk on WP8
-* CB-5895 documented saveToPhotoAlbum quirk on WP8
-* Remove deprecated symbols for iOS < 6
-* documentation translation: cordova-plugin-camera
-* Lisa testing pulling in plugins for plugin: cordova-plugin-camera
-* Lisa testing pulling in plugins for plugin: cordova-plugin-camera
-* Lisa testing pulling in plugins for plugin: cordova-plugin-camera
-* Lisa testing pulling in plugins for plugin: cordova-plugin-camera
-* ubuntu: use application directory for images
-* CB-6795 Add license
-* Little fix in code formatting
-* CB-6613 Use WinJS functionality to get base64-encoded content of image instead of File plugin functionality
-* CB-6612 camera.getPicture now always returns encoded JPEG image
-* Removed invalid note from CB-5398
-* CB-6576 - Returns a specific error message when app has no access to library.
-* CB-6491 add CONTRIBUTING.md
-* CB-6546 android: Fix a couple bugs with allowEdit pull request
-* CB-6546 android: Add support for allowEdit Camera option
-
-### 0.3.1 (Aug 06, 2014)
-* **FFOS** update CameraProxy.js
-* CB-7187 ios: Add explicit dependency on CoreLocation.framework
-* [BlackBerry10] Doc correction - sourceType is supported
-* CB-7071 android: Fix callback firing before CROP intent is sent when allowEdit=true
-* CB-6875 android: Handle exception when SDCard is not mounted
-* ios: Delete postImage (dead code)
-* Prevent NPE on processResiultFromGallery when intent comes null
-* Remove iOS doc reference to non-existing navigator.fileMgr API
-* Docs updated with some default values
-* Removes File plugin dependency from windows8 code.
-* Use WinJS functionality to resize image instead of File plugin functionality
-* CB-6127 Updated translations for docs
-
-### 0.3.2 (Sep 17, 2014)
-* CB-7551 [Camera][iOS 8] Scaled images show a white line
-* CB-7558 hasPendingOperation flag in Camera plugin's takePicture should be reversed to fix memory errors
-* CB-7557 Camera plugin tests is missing a File dependency
-* CB-7423 do cleanup after copyImage manual test
-* CB-7471 cordova-plugin-camera documentation translation: cordova-plugin-camera
-* CB-7413 Resolve 'ms-appdata' URIs with File plugin
-* Fixed minor bugs with the browser
-* CB-7433 Adds missing window reference to prevent manual tests failure on Android and iOS
-* CB-7249 cordova-plugin-camera documentation translation: cordova-plugin-camera
-* CB-4003 Add config option to not use location information in Camera plugin (and default to not use it)
-* CB-7461 Geolocation fails in Camera plugin in iOS 8
-* CB-7378 Use single Proxy for both windows8 and windows.
-* CB-7378 Adds support for windows platform
-* CB-7433 Fixes manual tests failure on windows
-* CB-6958 Get the correct default for "quality" in the test
-* add documentation for manual tests
-* CB-7249 cordova-plugin-camera documentation translation: cordova-plugin-camera
-* CB-4003 Add config option to not use location information in Camera plugin (and default to not use it)
-* CB-7461 Geolocation fails in Camera plugin in iOS 8
-* CB-7433 Fixes manual tests failure on windows
-* CB-7378 Use single Proxy for both windows8 and windows.
-* CB-7378 Adds support for windows platform
-* CB-6958 Get the correct default for "quality" in the test
-* add documentation for manual tests
-* Updated docs for browser
-* Added support for the browser
-* CB-7286 [BlackBerry10] Use getUserMedia if camera card is unavailable
-* CB-7180 Update Camera plugin to support generic plugin webView UIView (which can be either a UIWebView or WKWebView)
-* Renamed test dir, added nested plugin.xml
-* CB-6958 added manual tests
-* CB-6958 Port camera tests to plugin-test-framework
-
-### 0.3.3 (Oct 03, 2014)
-* CB-7600 Adds informative message to error callback in manual test.
-
-### 0.3.4 (Dec 02, 2014)
-* CB-7977 Mention `deviceready` in plugin docs
-* CB-7979 Each plugin doc should have a ## Installation section
-* Fix memory leak of image data in `imagePickerControllerReturnImageResult`
-* Pass uri to crop instead of pulling the low resolution image out of the intent return (close #43)
-* Add orientation support for PNG to Android (closes #45)
-* CB-7700 cordova-plugin-camera documentation translation: cordova-plugin-camera
-
-### 0.3.5 (Feb 04, 2015)
-* CB-8351 ios: Stop using now-deprecated [NSData base64EncodedString]
-* CB-8351 ios: Stop using now-deprecated integerValueForKey: class extension
-* CB-8351 ios: Use argumentForIndex rather than NSArray extension
-* CB-8032 ios: Add nativeURL external method support for CDVFileSystem->makeEntryForPath:isDirectory:
-* CB-7938 ios: Added XCTest unit tests project, with stubs (adapted from SplashScreen unit test setup)
-* CB-7937 ios: Re-factor iOS Camera plugin so that it is testable
-
-### 0.3.6 (Mar 10, 2015)
-* Fix localize key for Videos. This closes #58
-* CB-8235 android: Fix crash when selecting images from DropBox with spaces in path (close #65)
-* add try ... catch for getting image orientation
-* CB-8599 fix threading issue with cameraPicker (fixes #72)
-* CB-8559 Integrate TravisCI
-* CB-8438 cordova-plugin-camera documentation translation: cordova-plugin-camera
-* CB-8538 Added package.json file
-
-### 1.0.0 (Apr 15, 2015)
-* CB-8780 - Display popover using main thread. Fixes popover slowness (closes #81)
-* CB-8746 bumped version of file dependency
-* CB-8746 gave plugin major version bump
-* CB-8707 refactoring windows code to improve readability
-* CB-8706 use filePicker if saveToPhotoAlbum is true
-* CB-8706 remove unnecessary capabilities from xml
-* CB-8747 updated dependency, added peer dependency
-* CB-8683 updated blackberry specific references of org.apache.cordova.camera to cordova-plugin-camera
-* CB-8782: Updated the docs to talk about the allowEdit quirks, it's not 100% working, but better than it was
-* CB-8782: Fixed the flow so that we save the cropped image and use it, not the original non-cropped.  Crop only supports G+ Photos Crop, other crops may not work, depending on the OEM
-* CB-8740: Removing FileHelper call that was failing on Samsung Galaxy S3, now that we have a real path, we only need to update the MediaStore, not pull from it in this case
-* CB-8740: Partial fix for Save Image to Gallery error found in MobileSpec
-* CB-8683 changed plugin-id to pacakge-name
-* CB-8653 properly updated translated docs to use new id
-* CB-8653 updated translated docs to use new id
-* CB-8351 Fix custom implementation of integerValueForKey (close #79)
-* Fix cordova-paramedic path change, build with TRAVIS_BUILD_DIR, use npm to install paramedic
-* docs: added 'Windows' to supported platforms
-* CB-8653 Updated Readme
-* CB-8659: ios: 4.0.x Compatibility: Remove use of deprecated headers
-
-### 1.1.0 (May 06, 2015)
-* CB-8943 fix `PickAndContinue` issue on *Win10Phone*
-* CB-8253 Fix potential unreleased resources
-* CB-8909: Remove unused import from File
-* CB-8404 typo fix `cameraproxy.js`
-* CB-8404 Rotate camera feed with device orientation
-* CB-8054 Support taking pictures from file for *WP8*
-* CB-8405 Use `z-index` instead of `z-order`
-
-### 1.2.0 (Jun 17, 2015)
-* Closing stale pull request: close #84
-* Closing stale pull request: close #66
-* CB-9128 cordova-plugin-camera documentation translation: cordova-plugin-camera
-* Update docs. This closes #100
-* attempt to fix npm markdown issue
-* CB-8883 fix picture rotation issue
-* one more alias
-* Fixed some nit white-space issues, aliased a little more
-* major refactor : readability
-* Patch for CB-8498, this closes #64
-* CB-8879 fix stripe issue with correct aspect ratio
-* CB-8601 - iOS camera unit tests broken
-* CB-7667 iOS8: Handle case where camera is not authorized (closes #49)
-* add missing license header

appium-tests/android/android.spec.js

@@ -0,0 +1,751 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+
+// these tests are meant to be executed by Cordova ParaMedic Appium runner
+// you can find it here: https://github.com/apache/cordova-paramedic/
+// it is not necessary to do a full CI setup to run these tests
+// Run:
+//      node cordova-paramedic/main.js --platform android --plugin cordova-plugin-camera --skipMainTests --target <emulator name>
+// Please note only Android 5.1 and 4.4 are supported at this point.
+
+'use strict';
+
+var wdHelper = global.WD_HELPER;
+var screenshotHelper = global.SCREENSHOT_HELPER;
+var wd = wdHelper.getWD();
+var cameraConstants = require('../../www/CameraConstants');
+var cameraHelper = require('../helpers/cameraHelper');
+
+var MINUTE = 60 * 1000;
+var BACK_BUTTON = 4;
+var DEFAULT_SCREEN_WIDTH = 360;
+var DEFAULT_SCREEN_HEIGHT = 567;
+var DEFAULT_WEBVIEW_CONTEXT = 'WEBVIEW';
+var PROMISE_PREFIX = 'appium_camera_promise_';
+var CONTEXT_NATIVE_APP = 'NATIVE_APP';
+
+describe('Camera tests Android.', function () {
+    var driver;
+    // the name of webview context, it will be changed to match needed context if there are named ones:
+    var webviewContext = DEFAULT_WEBVIEW_CONTEXT;
+    // this indicates that the device library has the test picture:
+    var isTestPictureSaved = false;
+    // we need to know the screen width and height to properly click on an image in the gallery:
+    var screenWidth = DEFAULT_SCREEN_WIDTH;
+    var screenHeight = DEFAULT_SCREEN_HEIGHT;
+    // promise count to use in promise ID
+    var promiseCount = 0;
+    // determine if Appium session is created successfully
+    var appiumSessionStarted = false;
+    // determine if camera is present on the device/emulator
+    var cameraAvailable = false;
+    // determine if emulator is within a range of acceptable resolutions able to run these tests
+    var isResolutionBad = true;
+    // a path to the image we add to the gallery before test run
+    var fillerImagePath;
+    var isAndroid7 = getIsAndroid7();
+
+    function getIsAndroid7() {
+        if (global.USE_SAUCE) {
+            return global.SAUCE_CAPS && (parseFloat(global.SAUCE_CAPS.platformVersion) >= 7);
+        } else {
+            // this is most likely null, meaning we cannot determine if it is Android 7 or not
+            // paramedic needs to be modified to receive and pass the platform version when testing locally
+            return global.PLATFORM_VERSION && (parseFloat(global.PLATFORM_VERSION) >= 7);
+        }
+    }
+
+    function getNextPromiseId() {
+        promiseCount += 1;
+        return getCurrentPromiseId();
+    }
+
+    function getCurrentPromiseId() {
+        return PROMISE_PREFIX + promiseCount;
+    }
+
+    function gracefullyFail(error) {
+        fail(error);
+        return driver
+            .quit()
+            .then(function () {
+                return getDriver();
+            });
+    }
+
+    // combinines specified options in all possible variations
+    // you can add more options to test more scenarios
+    function generateOptions() {
+        var sourceTypes = [
+                cameraConstants.PictureSourceType.CAMERA,
+                cameraConstants.PictureSourceType.PHOTOLIBRARY
+            ];
+        var destinationTypes = cameraConstants.DestinationType;
+        var encodingTypes = cameraConstants.EncodingType;
+        var allowEditOptions = [ true, false ];
+        var correctOrientationOptions = [ true, false ];
+
+        return cameraHelper.generateSpecs(sourceTypes, destinationTypes, encodingTypes, allowEditOptions, correctOrientationOptions);
+    }
+
+    // invokes Camera.getPicture() with the specified options
+    // and goes through all UI interactions unless 'skipUiInteractions' is true
+    function getPicture(options, skipUiInteractions) {
+        var promiseId = getNextPromiseId();
+        if (!options) {
+            options = {};
+        }
+        // assign default values
+        if (!options.hasOwnProperty('allowEdit')) {
+            options.allowEdit = true;
+        }
+        if (!options.hasOwnProperty('destinationType')) {
+            options.destinationType = cameraConstants.DestinationType.FILE_URI;
+        }
+        if (!options.hasOwnProperty('sourceType')) {
+            options.destinationType = cameraConstants.PictureSourceType.CAMERA;
+        }
+
+        return driver
+            .context(webviewContext)
+            .execute(cameraHelper.getPicture, [options, promiseId])
+            .context(CONTEXT_NATIVE_APP)
+            .then(function () {
+                if (skipUiInteractions) {
+                    return;
+                }
+                // selecting a picture from gallery
+                if (options.hasOwnProperty('sourceType') &&
+                        (options.sourceType === cameraConstants.PictureSourceType.PHOTOLIBRARY ||
+                        options.sourceType === cameraConstants.PictureSourceType.SAVEDPHOTOALBUM)) {
+                    var tapTile = new wd.TouchAction();
+                    var swipeRight = new wd.TouchAction();
+                    tapTile
+                        .tap({
+                            x: Math.round(screenWidth / 4),
+                            y: Math.round(screenHeight / 4)
+                        });
+                    swipeRight
+                        .press({x: 10, y: Math.round(screenHeight / 4)})
+                        .wait(300)
+                        .moveTo({x: Math.round(screenWidth - (screenWidth / 8)), y: 0})
+                        .wait(1500)
+                        .release()
+                        .wait(1000);
+                    if (options.allowEdit) {
+                        return driver
+                            // always wait before performing touchAction
+                            .sleep(7000)
+                            .performTouchAction(tapTile);
+                    }
+                    return driver
+                        .waitForElementByAndroidUIAutomator('new UiSelector().text("Gallery");', 20000)
+                        .fail(function () {
+                            // If the Gallery button is not present, swipe right to reveal the Gallery button!
+                            return driver
+                                .performTouchAction(swipeRight)
+                                .waitForElementByAndroidUIAutomator('new UiSelector().text("Gallery");', 20000)
+                        })
+                        .click()
+                        // always wait before performing touchAction
+                        .sleep(7000)
+                        .performTouchAction(tapTile);
+                }
+                // taking a picture from camera
+                return driver
+                    .waitForElementByAndroidUIAutomator('new UiSelector().resourceIdMatches(".*shutter.*")', MINUTE / 2)
+                    .click()
+                    .waitForElementByAndroidUIAutomator('new UiSelector().resourceIdMatches(".*done.*")', MINUTE / 2)
+                    .click()
+                    .then(function () {
+                        if (isAndroid7 && options.allowEdit) {
+                            return driver
+                                .elementByAndroidUIAutomator('new UiSelector().text("Crop picture");', 20000)
+                                .click()
+                                .fail(function () {
+                                    // don't freak out just yet...
+                                    return driver;
+                                })
+                                .elementByAndroidUIAutomator('new UiSelector().text("JUST ONCE");', 20000)
+                                .click()
+                                .fail(function () {
+                                    // maybe someone's hit that "ALWAYS" button?
+                                    return driver;
+                                });
+                        }
+                        return driver;
+                    });
+            })
+            .then(function () {
+                if (skipUiInteractions) {
+                    return;
+                }
+                if (options.allowEdit) {
+                    var saveText = isAndroid7 ? 'SAVE' : 'Save';
+                    return driver
+                        .waitForElementByAndroidUIAutomator('new UiSelector().text("' + saveText + '")', MINUTE)
+                        .click();
+                }
+            })
+            .fail(function (failure) {
+                throw failure;
+            });
+    }
+
+    // checks if the picture was successfully taken
+    // if shouldLoad is falsy, ensures that the error callback was called
+    function checkPicture(shouldLoad, options) {
+        if (!options) {
+            options = {};
+        }
+        return driver
+            .context(webviewContext)
+            .setAsyncScriptTimeout(MINUTE / 2)
+            .executeAsync(cameraHelper.checkPicture, [getCurrentPromiseId(), options, isAndroid7])
+            .then(function (result) {
+                if (shouldLoad) {
+                    if (result !== 'OK') {
+                        fail(result);
+                    }
+                } else if (result.indexOf('ERROR') === -1) {
+                    throw 'Unexpected success callback with result: ' + result;
+                }
+            });
+    }
+
+    // deletes the latest image from the gallery
+    function deleteImage() {
+        var holdTile = new wd.TouchAction();
+        holdTile
+            .press({x: Math.round(screenWidth / 4), y: Math.round(screenHeight / 5)})
+            .wait(1000)
+            .release();
+        return driver
+            // always wait before performing touchAction
+            .sleep(7000)
+            .performTouchAction(holdTile)
+            .elementByAndroidUIAutomator('new UiSelector().text("Delete")')
+            .then(function (element) {
+                return element
+                    .click()
+                    .elementByAndroidUIAutomator('new UiSelector().text("OK")')
+                    .click();
+            }, function () {
+                // couldn't find Delete menu item. Possibly there is no image.
+                return driver;
+            });
+    }
+
+    function getDriver() {
+        driver = wdHelper.getDriver('Android');
+        return driver.getWebviewContext()
+            .then(function(context) {
+                webviewContext = context;
+                return driver.context(webviewContext);
+            })
+            .waitForDeviceReady()
+            .injectLibraries()
+            .then(function () {
+                var options = {
+                    quality: 50,
+                    allowEdit: false,
+                    sourceType: cameraConstants.PictureSourceType.SAVEDPHOTOALBUM,
+                    saveToPhotoAlbum: false,
+                    targetWidth: 210,
+                    targetHeight: 210
+                };
+                return driver
+                    .then(function () { return getPicture(options, true); })
+                    .context(CONTEXT_NATIVE_APP)
+                    // case insensitive select, will be handy with Android 7 support
+                    .elementByXPath('//android.widget.Button[translate(@text, "alow", "ALOW")="ALLOW"]')
+                    .click()
+                    .fail(function noAlert() { })
+                    .deviceKeyEvent(BACK_BUTTON)
+                    .sleep(2000)
+                    .elementById('action_bar_title')
+                    .then(function () {
+                        // success means we're still in native app
+                        return driver
+                            .deviceKeyEvent(BACK_BUTTON);
+                        }, function () {
+                            // error means we're already in webview
+                            return driver;
+                        });
+            })
+            .then(function () {
+                // doing it inside a function because otherwise 
+                // it would not hook up to the webviewContext var change
+                // in the first methods of this chain
+                return driver.context(webviewContext);
+            })
+            .deleteFillerImage(fillerImagePath)
+            .then(function () {
+                fillerImagePath = null;
+            })
+            .addFillerImage()
+            .then(function (result) {
+                if (result && result.indexOf('ERROR:') === 0) {
+                    throw new Error(result);
+                } else {
+                    fillerImagePath = result;
+                }
+            });
+    }
+
+    function recreateSession() {
+        return driver
+            .quit()
+            .finally(function () {
+                return getDriver();
+            });
+    }
+
+    function tryRunSpec(spec) {
+        return driver
+            .then(spec)
+            .fail(function () {
+                return recreateSession()
+                    .then(spec)
+                    .fail(function() {
+                        return recreateSession()
+                            .then(spec);
+                    });
+            })
+            .fail(gracefullyFail);
+    }
+
+    // produces a generic spec function which
+    // takes a picture with specified options
+    // and then verifies it
+    function generateSpec(options) {
+        return function () {
+            return driver
+                .then(function () {
+                    return getPicture(options);
+                })
+                .then(function () {
+                    return checkPicture(true, options);
+                });
+        };
+    }
+
+    function checkSession(done, skipResolutionCheck) {
+        if (!appiumSessionStarted) {
+            fail('Failed to start a session ' + (lastFailureReason ? lastFailureReason : ''));
+            done();
+        }
+        if (!skipResolutionCheck && isResolutionBad) {
+            fail('The resolution of this target device is not within the appropriate range of width: blah-blah and height: bleh-bleh. The target\'s current resolution is: ' + isResolutionBad);
+        }
+    }
+
+    function checkCamera(options, pending) {
+        if (!cameraAvailable) {
+            pending('Skipping because this test requires a functioning camera on the Android device/emulator, and this test suite\'s functional camera test failed on your target environment.');
+        } else if (isAndroid7 && options.allowEdit) {
+            // TODO: Check if it is fixed some day
+            pending('Skipping because can\'t test with allowEdit=true on Android 7: getting unexpected "Camera cancelled" message.');
+        } else if (isAndroid7 && (options.sourceType !== cameraConstants.PictureSourceType.CAMERA)) {
+            pending('Skipping because can\'t click on the gallery tile on Android 7.');
+        }
+    }
+
+    afterAll(function (done) {
+        checkSession(done);
+        driver
+            .quit()
+            .done(done);
+    }, MINUTE);
+
+    it('camera.ui.util configuring driver and starting a session', function (done) {
+        // retry up to 3 times
+        getDriver()
+            .fail(function () {
+                return getDriver()
+                    .fail(function () {
+                        return getDriver()
+                            .fail(fail);
+                    });
+            })
+            .then(function () {
+                appiumSessionStarted = true;
+            })
+            .done(done);
+    }, 30 * MINUTE);
+
+    it('camera.ui.util determine screen dimensions', function (done) {
+        checkSession(done, /*skipResolutionCheck?*/ true); // skip the resolution check here since we are about to find out in this spec!
+        driver
+            .context(CONTEXT_NATIVE_APP)
+            .getWindowSize()
+            .then(function (size) {
+                screenWidth = Number(size.width);
+                screenHeight = Number(size.height);
+                isResolutionBad = false;
+                /*
+                TODO: what are acceptable resolution values?
+                need to check what the emulators used in CI return.
+                and also what local device definitions work and dont
+                */
+            })
+            .done(done);
+    }, MINUTE);
+
+    it('camera.ui.util determine camera availability', function (done) {
+        checkSession(done);
+        var opts = {
+            sourceType: cameraConstants.PictureSourceType.CAMERA,
+            saveToPhotoAlbum: false
+        };
+
+        return driver
+            .then(function () {
+                return getPicture(opts);
+            })
+            .then(function () {
+                cameraAvailable = true;
+            }, function () {
+                return recreateSession();
+            })
+            .done(done);
+    }, 5 * MINUTE);
+
+    describe('Specs.', function () {
+        // getPicture() with saveToPhotoLibrary = true
+        it('camera.ui.spec.1 Saving a picture to the photo library', function (done) {
+            var opts = {
+                quality: 50,
+                allowEdit: false,
+                sourceType: cameraConstants.PictureSourceType.CAMERA,
+                saveToPhotoAlbum: true
+            };
+            checkSession(done);
+            checkCamera(opts, pending);
+
+            var spec = generateSpec(opts);
+            tryRunSpec(spec)
+                .then(function () {
+                    isTestPictureSaved = true;
+                })
+                .done(done);
+        }, 10 * MINUTE);
+
+        // getPicture() with mediaType: VIDEO, sourceType: PHOTOLIBRARY
+        it('camera.ui.spec.2 Selecting only videos', function (done) {
+            checkSession(done);
+            var spec = function () {
+                var options = { sourceType: cameraConstants.PictureSourceType.PHOTOLIBRARY,
+                                mediaType: cameraConstants.MediaType.VIDEO };
+                return driver
+                    .then(function () {
+                        return getPicture(options, true);
+                    })
+                    .context(CONTEXT_NATIVE_APP)
+                    .then(function () {
+                        // try to find "Gallery" menu item
+                        // if there's none, the gallery should be already opened
+                        return driver
+                            .waitForElementByAndroidUIAutomator('new UiSelector().text("Gallery")', 20000)
+                            .then(function (element) {
+                                return element.click();
+                            }, function () {
+                                return driver;
+                            });
+                    })
+                    .then(function () {
+                        // if the gallery is opened on the videos page,
+                        // there should be a "Choose video" or "Select video" caption
+                        var videoSelector = isAndroid7 ? 'new UiSelector().text("Select video")' : 'new UiSelector().text("Choose video")';
+                        return driver
+                            .elementByAndroidUIAutomator(videoSelector)
+                            .fail(function () {
+                                throw 'Couldn\'t find a "Choose/select video" element.';
+                            });
+                    })
+                    .deviceKeyEvent(BACK_BUTTON)
+                    .elementByAndroidUIAutomator('new UiSelector().text("Gallery")')
+                    .deviceKeyEvent(BACK_BUTTON)
+                    .finally(function () {
+                        return driver
+                            .elementById('action_bar_title')
+                            .then(function () {
+                                // success means we're still in native app
+                                return driver
+                                    .deviceKeyEvent(BACK_BUTTON)
+                                    // give native app some time to close
+                                    .sleep(2000)
+                                    // try again! because every ~30th build
+                                    // on Sauce Labs this backbutton doesn't work
+                                    .elementById('action_bar_title')
+                                    .then(function () {
+                                        // success means we're still in native app
+                                        return driver
+                                            .deviceKeyEvent(BACK_BUTTON);
+                                        }, function () {
+                                            // error means we're already in webview
+                                            return driver;
+                                        });
+                            }, function () {
+                                // error means we're already in webview
+                                return driver;
+                            });
+                    });
+            };
+            tryRunSpec(spec).done(done);
+        }, 10 * MINUTE);
+
+        // getPicture(), then dismiss
+        // wait for the error callback to be called
+        it('camera.ui.spec.3 Dismissing the camera', function (done) {
+            var options = {
+                quality: 50,
+                allowEdit: true,
+                sourceType: cameraConstants.PictureSourceType.CAMERA,
+                destinationType: cameraConstants.DestinationType.FILE_URI
+            };
+            checkSession(done);
+            checkCamera(options, pending);
+            var spec = function () {
+                return driver
+                    .then(function () {
+                        return getPicture(options, true);
+                    })
+                    .context(CONTEXT_NATIVE_APP)
+                    .waitForElementByAndroidUIAutomator('new UiSelector().resourceIdMatches(".*cancel.*")', MINUTE / 2)
+                    .click()
+                    .then(function () {
+                        return checkPicture(false);
+                    });
+            };
+
+            tryRunSpec(spec).done(done);
+        }, 10 * MINUTE);
+
+        // getPicture(), then take picture but dismiss the edit
+        // wait for the error callback to be called
+        it('camera.ui.spec.4 Dismissing the edit', function (done) {
+            var options = {
+                quality: 50,
+                allowEdit: true,
+                sourceType: cameraConstants.PictureSourceType.CAMERA,
+                destinationType: cameraConstants.DestinationType.FILE_URI
+            };
+            checkSession(done);
+            checkCamera(options, pending);
+            var spec = function () {
+                return driver
+                    .then(function () {
+                        return getPicture(options, true);
+                    })
+                    .waitForElementByAndroidUIAutomator('new UiSelector().resourceIdMatches(".*shutter.*")', MINUTE / 2)
+                    .click()
+                    .waitForElementByAndroidUIAutomator('new UiSelector().resourceIdMatches(".*done.*")', MINUTE / 2)
+                    .click()
+                    .then(function () {
+                        if (isAndroid7 && options.allowEdit) {
+                            return driver
+                                .waitForElementByAndroidUIAutomator('new UiSelector().text("Crop picture");', 20000)
+                                .click()
+                                .waitForElementByAndroidUIAutomator('new UiSelector().text("JUST ONCE");', 20000)
+                                .click()
+                                .deviceKeyEvent(BACK_BUTTON);
+                        }
+                        return driver
+                            .waitForElementByAndroidUIAutomator('new UiSelector().resourceIdMatches(".*discard.*")', MINUTE / 2)
+                            .click();
+                    })
+                    .then(function () {
+                        return checkPicture(false);
+                    });
+            };
+
+            tryRunSpec(spec).done(done);
+        }, 10 * MINUTE);
+
+        it('camera.ui.spec.5 Verifying target image size, sourceType=CAMERA', function (done) {
+            var opts = {
+                quality: 50,
+                allowEdit: false,
+                sourceType: cameraConstants.PictureSourceType.CAMERA,
+                saveToPhotoAlbum: false,
+                targetWidth: 210,
+                targetHeight: 210
+            };
+            checkSession(done);
+            checkCamera(opts, pending);
+            var spec = generateSpec(opts);
+
+            tryRunSpec(spec).done(done);
+        }, 10 * MINUTE);
+
+        it('camera.ui.spec.6 Verifying target image size, sourceType=PHOTOLIBRARY', function (done) {
+            var opts = {
+                quality: 50,
+                allowEdit: false,
+                sourceType: cameraConstants.PictureSourceType.PHOTOLIBRARY,
+                saveToPhotoAlbum: false,
+                targetWidth: 210,
+                targetHeight: 210
+            };
+            checkSession(done);
+            checkCamera(opts, pending);
+            var spec = generateSpec(opts);
+
+            tryRunSpec(spec).done(done);
+        }, 10 * MINUTE);
+
+        it('camera.ui.spec.7 Verifying target image size, sourceType=CAMERA, DestinationType=NATIVE_URI', function (done) {
+            var opts = {
+                quality: 50,
+                allowEdit: true,
+                sourceType: cameraConstants.PictureSourceType.CAMERA,
+                destinationType: cameraConstants.DestinationType.NATIVE_URI,
+                saveToPhotoAlbum: false,
+                targetWidth: 210,
+                targetHeight: 210
+            };
+            checkSession(done);
+            checkCamera(opts, pending);
+            var spec = generateSpec(opts);
+
+            tryRunSpec(spec).done(done);
+        }, 10 * MINUTE);
+
+        it('camera.ui.spec.8 Verifying target image size, sourceType=PHOTOLIBRARY, DestinationType=NATIVE_URI', function (done) {
+            var opts = {
+                quality: 50,
+                allowEdit: false,
+                sourceType: cameraConstants.PictureSourceType.PHOTOLIBRARY,
+                destinationType: cameraConstants.DestinationType.NATIVE_URI,
+                saveToPhotoAlbum: false,
+                targetWidth: 210,
+                targetHeight: 210
+            };
+            checkSession(done);
+            checkCamera(opts, pending);
+
+            var spec = generateSpec(opts);
+            tryRunSpec(spec).done(done);
+        }, 10 * MINUTE);
+
+        it('camera.ui.spec.9 Verifying target image size, sourceType=CAMERA, DestinationType=NATIVE_URI, quality=100', function (done) {
+            var opts = {
+                quality: 50,
+                allowEdit: true,
+                sourceType: cameraConstants.PictureSourceType.CAMERA,
+                destinationType: cameraConstants.DestinationType.NATIVE_URI,
+                saveToPhotoAlbum: false,
+                targetWidth: 305,
+                targetHeight: 305
+            };
+            checkSession(done);
+            checkCamera(opts, pending);
+            var spec = generateSpec(opts);
+
+            tryRunSpec(spec).done(done);
+        }, 10 * MINUTE);
+
+        it('camera.ui.spec.10 Verifying target image size, sourceType=PHOTOLIBRARY, DestinationType=NATIVE_URI, quality=100', function (done) {
+            var opts = {
+                quality: 100,
+                allowEdit: true,
+                sourceType: cameraConstants.PictureSourceType.PHOTOLIBRARY,
+                destinationType: cameraConstants.DestinationType.NATIVE_URI,
+                saveToPhotoAlbum: false,
+                targetWidth: 305,
+                targetHeight: 305
+            };
+            checkSession(done);
+            checkCamera(opts, pending);
+            var spec = generateSpec(opts);
+
+            tryRunSpec(spec).done(done);
+        }, 10 * MINUTE);
+
+        // combine various options for getPicture()
+        generateOptions().forEach(function (spec) {
+            it('camera.ui.spec.11.' + spec.id + ' Combining options. ' + spec.description, function (done) {
+                checkSession(done);
+                checkCamera(spec.options, pending);
+
+                var s = generateSpec(spec.options);
+                tryRunSpec(s).done(done);
+            }, 10 * MINUTE);
+        });
+
+        it('camera.ui.util Delete filler picture from device library', function (done) {
+            if (isAndroid7 || global.USE_SAUCE) {
+                pending();
+            }
+            driver
+                .context(webviewContext)
+                .deleteFillerImage(fillerImagePath)
+                .done(done);
+        }, MINUTE);
+
+        it('camera.ui.util Delete taken picture from device library', function (done) {
+            if (isAndroid7 || global.USE_SAUCE) {
+                pending();
+            }
+            checkSession(done);
+            if (!isTestPictureSaved) {
+                // couldn't save test picture earlier, so nothing to delete here
+                done();
+                return;
+            }
+            // delete exactly one latest picture
+            // this should be the picture we've taken in the first spec
+            driver
+                .context(CONTEXT_NATIVE_APP)
+                .deviceKeyEvent(BACK_BUTTON)
+                .sleep(1000)
+                .deviceKeyEvent(BACK_BUTTON)
+                .sleep(1000)
+                .deviceKeyEvent(BACK_BUTTON)
+                .elementById('Apps')
+                .click()
+                .then(function () {
+                    return driver
+                        .elementByXPath('//android.widget.Button[@text="OK"]')
+                        .click()
+                        .fail(function () {
+                            // no cling is all right
+                            // it is not a brand new emulator, then
+                        });
+                })
+                .elementByAndroidUIAutomator('new UiSelector().text("Gallery")')
+                .click()
+                .elementByAndroidUIAutomator('new UiSelector().textContains("Pictures")')
+                .click()
+                .then(deleteImage)
+                .deviceKeyEvent(BACK_BUTTON)
+                .sleep(1000)
+                .deviceKeyEvent(BACK_BUTTON)
+                .sleep(1000)
+                .deviceKeyEvent(BACK_BUTTON)
+                .fail(fail)
+                .finally(done);
+        }, 3 * MINUTE);
+    });
+
+});
+

appium-tests/helpers/cameraHelper.js

@@ -0,0 +1,311 @@
+/* global Q, resolveLocalFileSystemURL, Camera, cordova */
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+
+'use strict';
+
+var cameraConstants = require('../../www/CameraConstants');
+
+function findKeyByValue(set, value) {
+   for (var k in set) {
+      if (set.hasOwnProperty(k)) {
+         if (set[k] == value) {
+            return k;
+         }
+      }
+   }
+   return undefined;
+}
+
+function getDescription(spec) {
+    var desc = '';
+
+    desc += 'sourceType: ' + findKeyByValue(cameraConstants.PictureSourceType, spec.options.sourceType);
+    desc += ', destinationType: ' + findKeyByValue(cameraConstants.DestinationType, spec.options.destinationType);
+    desc += ', encodingType: ' + findKeyByValue(cameraConstants.EncodingType, spec.options.encodingType);
+    desc += ', allowEdit: ' + spec.options.allowEdit.toString();
+    desc += ', correctOrientation: ' + spec.options.correctOrientation.toString();
+
+    return desc;
+}
+
+module.exports.generateSpecs = function (sourceTypes, destinationTypes, encodingTypes, allowEditOptions, correctOrientationOptions) {
+    var destinationType,
+        sourceType,
+        encodingType,
+        allowEdit,
+        correctOrientation,
+        specs = [],
+        id = 1;
+    for (destinationType in destinationTypes) {
+        if (destinationTypes.hasOwnProperty(destinationType)) {
+            for (sourceType in sourceTypes) {
+                if (sourceTypes.hasOwnProperty(sourceType)) {
+                    for (encodingType in encodingTypes) {
+                        if (encodingTypes.hasOwnProperty(encodingType)) {
+                            for (allowEdit in allowEditOptions) {
+                                if (allowEditOptions.hasOwnProperty(allowEdit)) {
+                                    for (correctOrientation in correctOrientationOptions) {
+                                        // if taking picture from photolibrary, don't vary 'correctOrientation' option
+                                        if ((sourceTypes[sourceType] === cameraConstants.PictureSourceType.PHOTOLIBRARY ||
+                                            sourceTypes[sourceType] === cameraConstants.PictureSourceType.SAVEDPHOTOALBUM) &&
+                                            correctOrientation === true) { continue; }
+                                        var spec = {
+                                            'id': id++,
+                                            'options': {
+                                                'destinationType': destinationTypes[destinationType],
+                                                'sourceType': sourceTypes[sourceType],
+                                                'encodingType': encodingTypes[encodingType],
+                                                'allowEdit': allowEditOptions[allowEdit],
+                                                'saveToPhotoAlbum': false,
+                                                'correctOrientation': correctOrientationOptions[correctOrientation]
+                                            }
+                                        };
+                                        spec.description = getDescription(spec);
+                                        specs.push(spec);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return specs;
+};
+
+// calls getPicture() and saves the result in promise
+// note that this function is executed in the context of tested app
+// and not in the context of tests
+module.exports.getPicture = function (opts, pid) {
+    if (navigator._appiumPromises[pid - 1]) {
+        navigator._appiumPromises[pid - 1] = null;
+    }
+    navigator._appiumPromises[pid] = Q.defer();
+    navigator.camera.getPicture(function (result) {
+        navigator._appiumPromises[pid].resolve(result);
+    }, function (err) {
+        navigator._appiumPromises[pid].reject(err);
+    }, opts);
+};
+
+// verifies taken picture when the promise is resolved,
+// calls a callback with 'OK' if everything is good,
+// calls a callback with 'ERROR: <error message>' if something is wrong
+// note that this function is executed in the context of tested app
+// and not in the context of tests
+module.exports.checkPicture = function (pid, options, skipContentCheck, cb) {
+    var isIos = cordova.platformId === "ios";
+    var isAndroid = cordova.platformId === "android";
+    // skip image type check if it's unmodified on Android:
+    // https://github.com/apache/cordova-plugin-camera/#android-quirks-1
+    var skipFileTypeCheckAndroid = isAndroid && options.quality === 100 &&
+        !options.targetWidth && !options.targetHeight &&
+        !options.correctOrientation;
+
+    // Skip image type check if destination is NATIVE_URI and source - device's photoalbum
+    // https://github.com/apache/cordova-plugin-camera/#ios-quirks-1
+    var skipFileTypeCheckiOS = isIos && options.destinationType === Camera.DestinationType.NATIVE_URI &&
+        (options.sourceType === Camera.PictureSourceType.PHOTOLIBRARY ||
+         options.sourceType === Camera.PictureSourceType.SAVEDPHOTOALBUM);
+
+    var skipFileTypeCheck = skipFileTypeCheckAndroid || skipFileTypeCheckiOS;
+
+    var desiredType = 'JPEG';
+    var mimeType = 'image/jpeg';
+    if (options.encodingType === Camera.EncodingType.PNG) {
+        desiredType = 'PNG';
+        mimeType = 'image/png';
+    }
+
+    function errorCallback(msg) {
+        if (msg.hasOwnProperty('message')) {
+            msg = msg.message;
+        }
+        cb('ERROR: ' + msg);
+    }
+
+    // verifies the image we get from plugin
+    function verifyResult(result) {
+        if (result.length === 0) {
+            errorCallback('The result is empty.');
+            return;
+        } else if (isIos && options.destinationType === Camera.DestinationType.NATIVE_URI && result.indexOf('assets-library:') !== 0) {
+            errorCallback('Expected "' + result.substring(0, 150) + '"to start with "assets-library:"');
+            return;
+        } else if (isIos && options.destinationType === Camera.DestinationType.FILE_URI && result.indexOf('file:') !== 0) {
+            errorCallback('Expected "' + result.substring(0, 150) + '"to start with "file:"');
+            return;
+        }
+
+        try {
+            window.atob(result);
+            // if we got here it is a base64 string (DATA_URL)
+            result = "data:" + mimeType + ";base64," + result;
+        } catch (e) {
+            // not DATA_URL
+            if (options.destinationType === Camera.DestinationType.DATA_URL) {
+                errorCallback('Expected ' + result.substring(0, 150) + 'not to be DATA_URL');
+                return;
+            }
+        }
+
+        try {
+            if (result.indexOf('file:') === 0 ||
+                result.indexOf('content:') === 0 ||
+                result.indexOf('assets-library:') === 0) {
+
+                if (!window.resolveLocalFileSystemURL) {
+                    errorCallback('Cannot read file. Please install cordova-plugin-file to fix this.');
+                    return;
+                }
+                if (skipContentCheck) {
+                    cb('OK');
+                    return;
+                }
+                resolveLocalFileSystemURL(result, function (entry) {
+                    if (skipFileTypeCheck) {
+                        displayFile(entry);
+                    } else {
+                        verifyFile(entry);
+                    }
+                }, function (err) {
+                    errorCallback(err);
+                });
+            } else {
+                displayImage(result);
+            }
+        } catch (e) {
+            errorCallback(e);
+        }
+    }
+
+    // verifies that the file type matches the requested type
+    function verifyFile(entry) {
+        try {
+            var reader = new FileReader();
+            reader.onloadend = function(e) {
+                var arr = (new Uint8Array(e.target.result)).subarray(0, 4);
+                var header = '';
+                for(var i = 0; i < arr.length; i++) {
+                    header += arr[i].toString(16);
+                }
+                var actualType = 'unknown';
+
+                switch (header) {
+                    case "89504e47":
+                        actualType = 'PNG';
+                        break;
+                    case 'ffd8ffe0':
+                    case 'ffd8ffe1':
+                    case 'ffd8ffe2':
+                        actualType = 'JPEG';
+                        break;
+                }
+
+                if (actualType === desiredType) {
+                    displayFile(entry);
+                } else {
+                    errorCallback('File type mismatch. Expected ' + desiredType + ', got ' + actualType);
+                }
+            };
+            reader.onerror = function (e) {
+                errorCallback(e);
+            };
+            entry.file(function (file) {
+                reader.readAsArrayBuffer(file);
+            }, function (e) {
+                errorCallback(e);
+            });
+        } catch (e) {
+            errorCallback(e);
+        }
+    }
+
+    // reads the file, then displays the image
+    function displayFile(entry) {
+        function onFileReceived(file) {
+            var reader = new FileReader();
+            reader.onerror = function (e) {
+                errorCallback(e);
+            };
+            reader.onloadend = function (evt) {
+                displayImage(evt.target.result);
+            };
+            reader.readAsDataURL(file);
+        }
+
+        entry.file(onFileReceived, function (e) {
+            errorCallback(e);
+        });
+    }
+
+    function displayImage(image) {
+        try {
+            var imgEl = document.getElementById('camera_test_image');
+            if (!imgEl) {
+                imgEl = document.createElement('img');
+                imgEl.id = 'camera_test_image';
+                document.body.appendChild(imgEl);
+            }
+            var timedOut = false;
+            var loadTimeout = setTimeout(function () {
+                timedOut = true;
+                imgEl.src = '';
+                errorCallback('The image did not load: ' + image.substring(0, 150));
+            }, 10000);
+            var done = function (status) {
+                if (!timedOut) {
+                    clearTimeout(loadTimeout);
+                    imgEl.src = '';
+                    cb(status);
+                }
+            };
+            imgEl.onload = function () {
+                try {
+                    // aspect ratio is preserved so only one dimension should match
+                    if ((typeof options.targetWidth === 'number' && imgEl.naturalWidth !== options.targetWidth) &&
+                        (typeof options.targetHeight === 'number' && imgEl.naturalHeight !== options.targetHeight))
+                    {
+                        done('ERROR: Wrong image size: ' + imgEl.naturalWidth + 'x' + imgEl.naturalHeight +
+                            '. Requested size: ' + options.targetWidth + 'x' + options.targetHeight);
+                    } else {
+                        done('OK');
+                    }
+                } catch (e) {
+                    errorCallback(e);
+                }
+            };
+            imgEl.src = image;
+        } catch (e) {
+            errorCallback(e);
+        }
+    }
+
+    navigator._appiumPromises[pid].promise
+        .then(function (result) {
+            verifyResult(result);
+        })
+        .fail(function (e) {
+            errorCallback(e);
+        });
+};

appium-tests/ios/ios.spec.js

@@ -0,0 +1,512 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+
+// these tests are meant to be executed by Cordova Paramedic test runner
+// you can find it here: https://github.com/apache/cordova-paramedic/
+// it is not necessary to do a full CI setup to run these tests
+// just run "node cordova-paramedic/main.js --platform ios --plugin cordova-plugin-camera"
+
+'use strict';
+
+var wdHelper = global.WD_HELPER;
+var screenshotHelper = global.SCREENSHOT_HELPER;
+var isDevice = global.DEVICE;
+var cameraConstants = require('../../www/CameraConstants');
+var cameraHelper = require('../helpers/cameraHelper');
+
+var MINUTE = 60 * 1000;
+var DEFAULT_WEBVIEW_CONTEXT = 'WEBVIEW_1';
+var PROMISE_PREFIX = 'appium_camera_promise_';
+var CONTEXT_NATIVE_APP = 'NATIVE_APP';
+
+describe('Camera tests iOS.', function () {
+    var driver;
+    var webviewContext = DEFAULT_WEBVIEW_CONTEXT;
+    // promise count to use in promise ID
+    var promiseCount = 0;
+    // going to set this to false if session is created successfully
+    var failedToStart = true;
+    // points out which UI automation to use
+    var isXCUI = false;
+    // spec counter to restart the session
+    var specsRun = 0;
+
+    function getNextPromiseId() {
+        promiseCount += 1;
+        return getCurrentPromiseId();
+    }
+
+    function getCurrentPromiseId() {
+        return PROMISE_PREFIX + promiseCount;
+    }
+
+    function gracefullyFail(error) {
+        fail(error);
+        return driver
+            .quit()
+            .then(function () {
+                return getDriver();
+            });
+    }
+
+    // generates test specs by combining all the specified options
+    // you can add more options to test more scenarios
+    function generateOptions() {
+        var sourceTypes = cameraConstants.PictureSourceType;
+        var destinationTypes = cameraConstants.DestinationType;
+        var encodingTypes = cameraConstants.EncodingType;
+        var allowEditOptions = [ true, false ];
+        var correctOrientationOptions = [ true, false ];
+
+        return cameraHelper.generateSpecs(sourceTypes, destinationTypes, encodingTypes, allowEditOptions, correctOrientationOptions);
+    }
+
+    function usePicture(allowEdit) {
+        return driver
+            .sleep(10)
+            .then(function () {
+                if (isXCUI) {
+                    return driver.waitForElementByAccessibilityId('Choose', MINUTE / 3).click();
+                } else {
+                    if (allowEdit) {
+                        return wdHelper.tapElementByXPath('//UIAButton[@label="Choose"]', driver);
+                    }
+                    return driver.elementByXPath('//*[@label="Use"]').click();
+                }
+            });
+    }
+
+    function clickPhoto() {
+        if (isXCUI) {
+            // iOS >=10
+            return driver
+                .context(CONTEXT_NATIVE_APP)
+                .elementsByXPath('//XCUIElementTypeCell')
+                .then(function(photos) {
+                    if (photos.length == 0) {
+                        return driver
+                            .sleep(0) // driver.source is not a function o.O
+                            .source()
+                            .then(function (src) {
+                                console.log(src);
+                                gracefullyFail('Couldn\'t find an image to click');
+                            });
+                    }
+                    // intentionally clicking the second photo here
+                    // the first one is not clickable for some reason
+                    return photos[1].click();
+                });
+        }
+        // iOS <10
+        return driver
+            .elementByXPath('//UIACollectionCell')
+            .click();
+    }
+
+    function getPicture(options, cancelCamera, skipUiInteractions) {
+        var promiseId = getNextPromiseId();
+        if (!options) {
+            options = {};
+        }
+        // assign defaults
+        if (!options.hasOwnProperty('allowEdit')) {
+            options.allowEdit = true;
+        }
+        if (!options.hasOwnProperty('destinationType')) {
+            options.destinationType = cameraConstants.DestinationType.FILE_URI;
+        }
+        if (!options.hasOwnProperty('sourceType')) {
+            options.destinationType = cameraConstants.PictureSourceType.CAMERA;
+        }
+
+        return driver
+            .context(webviewContext)
+            .execute(cameraHelper.getPicture, [options, promiseId])
+            .context(CONTEXT_NATIVE_APP)
+            .then(function () {
+                if (skipUiInteractions) {
+                    return;
+                }
+                if (options.hasOwnProperty('sourceType') && options.sourceType === cameraConstants.PictureSourceType.PHOTOLIBRARY) {
+                    return driver
+                        .waitForElementByAccessibilityId('Camera Roll', MINUTE / 2)
+                        .click()
+                        .then(function () {
+                            return clickPhoto();
+                        })
+                        .then(function () {
+                            if (!options.allowEdit) {
+                                return driver;
+                            }
+                            return usePicture(options.allowEdit);
+                        });
+                }
+                if (options.hasOwnProperty('sourceType') && options.sourceType === cameraConstants.PictureSourceType.SAVEDPHOTOALBUM) {
+                    return clickPhoto()
+                        .then(function () {
+                            if (!options.allowEdit) {
+                                return driver;
+                            }
+                            return usePicture(options.allowEdit);
+                        });
+                }
+                if (cancelCamera) {
+                    return driver
+                        .waitForElementByAccessibilityId('Cancel', MINUTE / 2)
+                        .click();
+                }
+                return driver
+                    .waitForElementByAccessibilityId('Take Picture', MINUTE / 2)
+                    .click()
+                    .waitForElementByAccessibilityId('Use Photo', MINUTE / 2)
+                    .click();
+            })
+            .fail(fail);
+    }
+
+    // checks if the picture was successfully taken
+    // if shouldLoad is falsy, ensures that the error callback was called
+    function checkPicture(shouldLoad, options) {
+        if (!options) {
+            options = {};
+        }
+        return driver
+            .context(webviewContext)
+            .setAsyncScriptTimeout(MINUTE / 2)
+            .executeAsync(cameraHelper.checkPicture, [getCurrentPromiseId(), options, false])
+            .then(function (result) {
+                if (shouldLoad) {
+                    if (result !== 'OK') {
+                        fail(result);
+                    }
+                } else if (result.indexOf('ERROR') === -1) {
+                    throw 'Unexpected success callback with result: ' + result;
+                }
+            });
+    }
+
+    // takes a picture with the specified options
+    // and then verifies it
+    function runSpec(options, done, pending) {
+        if (options.sourceType === cameraConstants.PictureSourceType.CAMERA && !isDevice) {
+            pending('Camera is not available on iOS simulator');
+        }
+        checkSession(done);
+        specsRun += 1;
+        return driver
+            .then(function () {
+                return getPicture(options);
+            })
+            .then(function () {
+                return checkPicture(true, options);
+            })
+            .fail(gracefullyFail);
+    }
+
+    function getDriver() {
+        failedToStart = true;
+        driver = wdHelper.getDriver('iOS');
+        return wdHelper.getWebviewContext(driver)
+            .then(function(context) {
+                webviewContext = context;
+                return driver.context(webviewContext);
+            })
+            .then(function () {
+                return wdHelper.waitForDeviceReady(driver);
+            })
+            .then(function () {
+                return wdHelper.injectLibraries(driver);
+            })
+            .sessionCapabilities()
+            .then(function (caps) {
+                var platformVersion = parseFloat(caps.platformVersion);
+                isXCUI = platformVersion >= 10.0;
+            })
+            .then(function () {
+                var options = {
+                    quality: 50,
+                    allowEdit: false,
+                    sourceType: cameraConstants.PictureSourceType.SAVEDPHOTOALBUM,
+                    saveToPhotoAlbum: false,
+                    targetWidth: 210,
+                    targetHeight: 210
+                };
+                return driver
+                    .then(function () { return getPicture(options, false, true); })
+                    .context(CONTEXT_NATIVE_APP)
+                    .acceptAlert()
+                    .then(function alertDismissed() {
+                        // TODO: once we move to only XCUITest-based (which is force on you in either iOS 10+ or Xcode 8+)
+                        // UI tests, we will have to:
+                        // a) remove use of autoAcceptAlerts appium capability since it no longer functions in XCUITest
+                        // b) can remove this entire then() clause, as we do not need to explicitly handle the acceptAlert
+                        //    failure callback, since we will be guaranteed to hit the permission dialog on startup.
+                    }, function noAlert() {
+                        // in case the contacts permission alert never showed up: no problem, don't freak out.
+                        // This can happen if:
+                        // a) The application-under-test already had photos permissions granted to it
+                        // b) Appium's autoAcceptAlerts capability is provided (and functioning)
+                    })
+                    .elementByAccessibilityId('Cancel', 10000)
+                    .click();
+            })
+            .then(function () {
+                failedToStart = false;
+            });
+    }
+
+    function checkSession(done) {
+        if (failedToStart) {
+            fail('Failed to start a session');
+            done();
+        }
+    }
+
+    it('camera.ui.util configure driver and start a session', function (done) {
+        // retry up to 3 times
+        getDriver()
+            .fail(function () {
+                return getDriver()
+                    .fail(function () {
+                        return getDriver()
+                            .fail(fail);
+                    });
+            })
+            .fail(fail)
+            .done(done);
+    }, 30 * MINUTE);
+
+    describe('Specs.', function () {
+        afterEach(function (done) {
+            if (specsRun >= 19) {
+                specsRun = 0;
+                // we need to restart the session regularly because for some reason
+                // when running against iOS 10 simulator on SauceLabs, 
+                // Appium cannot handle more than ~20 specs at one session
+                // the error would be as follows:
+                // "Could not proxy command to remote server. Original error: Error: connect ECONNREFUSED 127.0.0.1:8100"
+                checkSession(done);
+                return driver
+                    .quit()
+                    .then(function () {
+                        return getDriver()
+                            .fail(function () {
+                                return getDriver()
+                                    .fail(function () {
+                                        return getDriver()
+                                            .fail(fail);
+                                    });
+                            });
+                    })
+                    .done(done);
+            } else {
+                done();
+            }
+        }, 30 * MINUTE);
+
+        // getPicture() with mediaType: VIDEO, sourceType: PHOTOLIBRARY
+        it('camera.ui.spec.1 Selecting only videos', function (done) {
+            checkSession(done);
+            specsRun += 1;
+            var options = { sourceType: cameraConstants.PictureSourceType.PHOTOLIBRARY,
+                            mediaType: cameraConstants.MediaType.VIDEO };
+            driver
+                // skip ui unteractions
+                .then(function () { return getPicture(options, false, true); })
+                .waitForElementByXPath('//*[contains(@label,"Videos")]', MINUTE / 2)
+                .elementByAccessibilityId('Cancel')
+                .click()
+                .fail(gracefullyFail)
+                .done(done);
+        }, 7 * MINUTE);
+
+        // getPicture(), then dismiss
+        // wait for the error callback to be called
+        it('camera.ui.spec.2 Dismissing the camera', function (done) {
+            checkSession(done);
+            if (!isDevice) {
+                pending('Camera is not available on iOS simulator');
+            }
+            specsRun += 1;
+            var options = { sourceType: cameraConstants.PictureSourceType.CAMERA,
+                            saveToPhotoAlbum: false };
+            driver
+                .then(function () {
+                    return getPicture(options, true);
+                })
+                .then(function () {
+                    return checkPicture(false);
+                })
+                .fail(gracefullyFail)
+                .done(done);
+        }, 7 * MINUTE);
+
+        it('camera.ui.spec.3 Verifying target image size, sourceType=CAMERA', function (done) {
+            var options = {
+                quality: 50,
+                allowEdit: false,
+                sourceType: cameraConstants.PictureSourceType.CAMERA,
+                saveToPhotoAlbum: false,
+                targetWidth: 210,
+                targetHeight: 210
+            };
+
+            runSpec(options, done, pending).done(done);
+        }, 7 * MINUTE);
+
+        it('camera.ui.spec.4 Verifying target image size, sourceType=SAVEDPHOTOALBUM', function (done) {
+            var options = {
+                quality: 50,
+                allowEdit: false,
+                sourceType: cameraConstants.PictureSourceType.SAVEDPHOTOALBUM,
+                saveToPhotoAlbum: false,
+                targetWidth: 210,
+                targetHeight: 210
+            };
+
+            runSpec(options, done, pending).done(done);
+        }, 7 * MINUTE);
+
+        it('camera.ui.spec.5 Verifying target image size, sourceType=PHOTOLIBRARY', function (done) {
+            var options = {
+                quality: 50,
+                allowEdit: false,
+                sourceType: cameraConstants.PictureSourceType.PHOTOLIBRARY,
+                saveToPhotoAlbum: false,
+                targetWidth: 210,
+                targetHeight: 210
+            };
+
+            runSpec(options, done, pending).done(done);
+        }, 7 * MINUTE);
+
+        it('camera.ui.spec.6 Verifying target image size, sourceType=CAMERA, destinationType=FILE_URL', function (done) {
+            // remove this line if you don't mind the tests leaving a photo saved on device
+            pending('Cannot prevent iOS from saving the picture to photo library');
+
+            var options = {
+                quality: 50,
+                allowEdit: false,
+                sourceType: cameraConstants.PictureSourceType.CAMERA,
+                destinationType: cameraConstants.DestinationType.FILE_URL,
+                saveToPhotoAlbum: false,
+                targetWidth: 210,
+                targetHeight: 210
+            };
+
+            runSpec(options, done, pending).done(done);
+        }, 7 * MINUTE);
+
+        it('camera.ui.spec.7 Verifying target image size, sourceType=SAVEDPHOTOALBUM, destinationType=FILE_URL', function (done) {
+            var options = {
+                quality: 50,
+                allowEdit: false,
+                sourceType: cameraConstants.PictureSourceType.SAVEDPHOTOALBUM,
+                destinationType: cameraConstants.DestinationType.FILE_URL,
+                saveToPhotoAlbum: false,
+                targetWidth: 210,
+                targetHeight: 210
+            };
+
+            runSpec(options, done, pending).done(done);
+        }, 7 * MINUTE);
+
+        it('camera.ui.spec.8 Verifying target image size, sourceType=PHOTOLIBRARY, destinationType=FILE_URL', function (done) {
+            var options = {
+                quality: 50,
+                allowEdit: false,
+                sourceType: cameraConstants.PictureSourceType.PHOTOLIBRARY,
+                destinationType: cameraConstants.DestinationType.FILE_URL,
+                saveToPhotoAlbum: false,
+                targetWidth: 210,
+                targetHeight: 210
+            };
+
+            runSpec(options, done, pending).done(done);
+        }, 7 * MINUTE);
+
+        it('camera.ui.spec.9 Verifying target image size, sourceType=CAMERA, destinationType=FILE_URL, quality=100', function (done) {
+            // remove this line if you don't mind the tests leaving a photo saved on device
+            pending('Cannot prevent iOS from saving the picture to photo library');
+
+            var options = {
+                quality: 100,
+                allowEdit: false,
+                sourceType: cameraConstants.PictureSourceType.CAMERA,
+                destinationType: cameraConstants.DestinationType.FILE_URL,
+                saveToPhotoAlbum: false,
+                targetWidth: 305,
+                targetHeight: 305
+            };
+            runSpec(options, done, pending).done(done);
+        }, 7 * MINUTE);
+
+        it('camera.ui.spec.10 Verifying target image size, sourceType=SAVEDPHOTOALBUM, destinationType=FILE_URL, quality=100', function (done) {
+            var options = {
+                quality: 100,
+                allowEdit: false,
+                sourceType: cameraConstants.PictureSourceType.SAVEDPHOTOALBUM,
+                destinationType: cameraConstants.DestinationType.FILE_URL,
+                saveToPhotoAlbum: false,
+                targetWidth: 305,
+                targetHeight: 305
+            };
+
+            runSpec(options, done, pending).done(done);
+        }, 7 * MINUTE);
+
+        it('camera.ui.spec.11 Verifying target image size, sourceType=PHOTOLIBRARY, destinationType=FILE_URL, quality=100', function (done) {
+            var options = {
+                quality: 100,
+                allowEdit: false,
+                sourceType: cameraConstants.PictureSourceType.PHOTOLIBRARY,
+                destinationType: cameraConstants.DestinationType.FILE_URL,
+                saveToPhotoAlbum: false,
+                targetWidth: 305,
+                targetHeight: 305
+            };
+
+            runSpec(options, done, pending).done(done);
+        }, 7 * MINUTE);
+
+        // combine various options for getPicture()
+        generateOptions().forEach(function (spec) {
+            it('camera.ui.spec.12.' + spec.id + ' Combining options. ' + spec.description, function (done) {
+                // remove this check if you don't mind the tests leaving a photo saved on device
+                if (spec.options.sourceType === cameraConstants.PictureSourceType.CAMERA &&
+                    spec.options.destinationType === cameraConstants.DestinationType.NATIVE_URI) {
+                    pending('Skipping: cannot prevent iOS from saving the picture to photo library and cannot delete it. ' +
+                        'For more info, see iOS quirks here: https://github.com/apache/cordova-plugin-camera#ios-quirks-1');
+                }
+
+                runSpec(spec.options, done, pending).done(done);
+            }, 7 * MINUTE);
+        });
+
+    });
+
+    it('camera.ui.util Destroy the session', function (done) {
+        checkSession(done);
+        driver
+            .quit()
+            .done(done);
+    }, 5 * MINUTE);
+});

jsdoc2md/TEMPLATE.md

@@ -0,0 +1,460 @@
+---
+title: Camera
+description: Take pictures with the device camera.
+---
+{{>cdv-license~}}
+
+|AppVeyor|Travis CI|
+|:-:|:-:|
+|[![Build status](https://ci.appveyor.com/api/projects/status/github/apache/cordova-plugin-camera?branch=master)](https://ci.appveyor.com/project/ApacheSoftwareFoundation/cordova-plugin-camera)|[![Build Status](https://travis-ci.org/apache/cordova-plugin-camera.svg?branch=master)](https://travis-ci.org/apache/cordova-plugin-camera)|
+
+# cordova-plugin-camera
+
+This plugin defines a global `navigator.camera` object, which provides an API for taking pictures and for choosing images from
+the system's image library.
+
+{{>cdv-header device-ready-warning-obj='navigator.camera' npmName='cordova-plugin-camera' cprName='org.apache.cordova.camera' pluginName='cordova-plugin-camera' repoUrl='https://github.com/apache/cordova-plugin-camera' }}
+
+
+### iOS Quirks
+
+Since iOS 10 it's mandatory to provide an usage description in the `info.plist` if trying to access privacy-sensitive data. When the system prompts the user to allow access, this usage description string will displayed as part of the permission dialog box, but if you didn't provide the usage description, the app will crash before showing the dialog. Also, Apple will reject apps that access private data but don't provide an usage description.
+
+This plugins requires the following usage descriptions:
+
+- `NSCameraUsageDescription` specifies the reason for your app to access the device's camera.
+- `NSPhotoLibraryUsageDescription` specifies the reason for your app to access the user's photo library.
+- `NSLocationWhenInUseUsageDescription` specifies the reason for your app to access the user's location information while your app is in use. (Set it if you have `CameraUsesGeolocation` preference set to `true`)
+- `NSPhotoLibraryAddUsageDescription` specifies the reason for your app to get write-only access to the user's photo library
+
+To add these entries into the `info.plist`, you can use the `edit-config` tag in the `config.xml` like this:
+
+```
+<edit-config target="NSCameraUsageDescription" file="*-Info.plist" mode="merge">
+    <string>need camera access to take pictures</string>
+</edit-config>
+```
+
+```
+<edit-config target="NSPhotoLibraryUsageDescription" file="*-Info.plist" mode="merge">
+    <string>need to photo library access to get pictures from there</string>
+</edit-config>
+```
+
+```
+<edit-config target="NSLocationWhenInUseUsageDescription" file="*-Info.plist" mode="merge">
+    <string>need location access to find things nearby</string>
+</edit-config>
+```
+
+```
+<edit-config target="NSPhotoLibraryAddUsageDescription" file="*-Info.plist" mode="merge">
+    <string>need to photo library access to save pictures there</string>
+</edit-config>
+```
+
+---
+
+# API Reference <a name="reference"></a>
+
+{{#orphans~}}
+{{>member-index}}
+{{/orphans}}
+* [CameraPopoverHandle](#module_CameraPopoverHandle)
+* [CameraPopoverOptions](#module_CameraPopoverOptions)
+
+---
+
+{{#modules~}}
+{{>header~}}
+{{>body~}}
+{{>members~}}
+
+---
+
+{{/modules}}
+
+## `camera.getPicture` Errata
+
+#### Example <a name="camera-getPicture-examples"></a>
+
+Take a photo and retrieve the image's file location:
+
+    navigator.camera.getPicture(onSuccess, onFail, { quality: 50,
+        destinationType: Camera.DestinationType.FILE_URI });
+
+    function onSuccess(imageURI) {
+        var image = document.getElementById('myImage');
+        image.src = imageURI;
+    }
+
+    function onFail(message) {
+        alert('Failed because: ' + message);
+    }
+
+Take a photo and retrieve it as a Base64-encoded image:
+
+    /**
+     * Warning: Using DATA_URL is not recommended! The DATA_URL destination
+     * type is very memory intensive, even with a low quality setting. Using it
+     * can result in out of memory errors and application crashes. Use FILE_URI
+     * or NATIVE_URI instead.
+     */
+    navigator.camera.getPicture(onSuccess, onFail, { quality: 25,
+        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);
+    }
+
+#### Preferences (iOS)
+
+-  __CameraUsesGeolocation__ (boolean, defaults to false). For capturing JPEGs, set to true to get geolocation data in the EXIF header. This will trigger a request for geolocation permissions if set to true.
+
+        <preference name="CameraUsesGeolocation" value="false" />
+
+#### Amazon Fire OS Quirks <a name="camera-getPicture-quirks"></a>
+
+Amazon Fire OS uses intents to launch the camera activity on the device to capture
+images, and on phones with low memory, the Cordova activity may be killed.  In this
+scenario, the image may not appear when the Cordova activity is restored.
+
+#### Android Quirks
+
+Android uses intents to launch the camera activity on the device to capture
+images, and on phones with low memory, the Cordova activity may be killed.  In this
+scenario, the result from the plugin call will be delivered via the resume event.
+See [the Android Lifecycle guide][android_lifecycle]
+for more information. The `pendingResult.result` value will contain the value that
+would be passed to the callbacks (either the URI/URL or an error message). Check
+the `pendingResult.pluginStatus` to determine whether or not the call was
+successful.
+
+#### Browser Quirks
+
+Can only return photos as Base64-encoded image.
+
+#### Firefox OS Quirks
+
+Camera plugin is currently implemented using [Web Activities][web_activities].
+
+#### iOS Quirks
+
+Including a JavaScript `alert()` in either of the callback functions
+can cause problems.  Wrap the alert within a `setTimeout()` to allow
+the iOS image picker or popover to fully close before the alert
+displays:
+
+    setTimeout(function() {
+        // do your thing here!
+    }, 0);
+
+#### Windows Phone 7 Quirks
+
+Invoking the native camera application while the device is connected
+via Zune does not work, and triggers an error callback.
+
+#### Windows quirks
+
+On Windows Phone 8.1 using `SAVEDPHOTOALBUM` or `PHOTOLIBRARY` as a source type causes application to suspend until file picker returns the selected image and
+then restore with start page as defined in app's `config.xml`. In case when `camera.getPicture` was called from different page, this will lead to reloading
+start page from scratch and success and error callbacks will never be called.
+
+To avoid this we suggest using SPA pattern or call `camera.getPicture` only from your app's start page.
+
+More information about Windows Phone 8.1 picker APIs is here: [How to continue your Windows Phone app after calling a file picker](https://msdn.microsoft.com/en-us/library/windows/apps/dn720490.aspx)
+
+#### Tizen Quirks
+
+Tizen only supports a `destinationType` of
+`Camera.DestinationType.FILE_URI` and a `sourceType` of
+`Camera.PictureSourceType.PHOTOLIBRARY`.
+
+
+## `CameraOptions` Errata <a name="CameraOptions-quirks"></a>
+
+#### Amazon Fire OS Quirks
+
+- Any `cameraDirection` value results in a back-facing photo.
+
+- Ignores the `allowEdit` parameter.
+
+- `Camera.PictureSourceType.PHOTOLIBRARY` and `Camera.PictureSourceType.SAVEDPHOTOALBUM` both display the same photo album.
+
+#### Android Quirks
+
+- Any `cameraDirection` value results in a back-facing photo.
+
+- **`allowEdit` is unpredictable on Android and it should not be used!** The Android implementation of this plugin tries to find and use an application on the user's device to do image cropping. The plugin has no control over what application the user selects to perform the image cropping and it is very possible that the user could choose an incompatible option and cause the plugin to fail. This sometimes works because most devices come with an application that handles cropping in a way that is compatible with this plugin (Google Plus Photos), but it is unwise to rely on that being the case. If image editing is essential to your application, consider seeking a third party library or plugin that provides its own image editing utility for a more robust solution.
+
+- `Camera.PictureSourceType.PHOTOLIBRARY` and `Camera.PictureSourceType.SAVEDPHOTOALBUM` both display the same photo album.
+
+- Ignores the `encodingType` parameter if the image is unedited (i.e. `quality` is 100, `correctOrientation` is false, and no `targetHeight` or `targetWidth` are specified). The `CAMERA` source will always return the JPEG file given by the native camera and the `PHOTOLIBRARY` and `SAVEDPHOTOALBUM` sources will return the selected file in its existing encoding.
+
+#### BlackBerry 10 Quirks
+
+- Ignores the `quality` parameter.
+
+- Ignores the `allowEdit` parameter.
+
+- `Camera.MediaType` is not supported.
+
+- Ignores the `correctOrientation` parameter.
+
+- Ignores the `cameraDirection` parameter.
+
+#### Firefox OS Quirks
+
+- Ignores the `quality` parameter.
+
+- `Camera.DestinationType` is ignored and equals `1` (image file URI)
+
+- Ignores the `allowEdit` parameter.
+
+- Ignores the `PictureSourceType` parameter (user chooses it in a dialog window)
+
+- Ignores the `encodingType`
+
+- Ignores the `targetWidth` and `targetHeight`
+
+- `Camera.MediaType` is not supported.
+
+- Ignores the `correctOrientation` parameter.
+
+- Ignores the `cameraDirection` parameter.
+
+#### iOS Quirks
+
+- When using `destinationType.FILE_URI`, photos are saved in the application's temporary directory. The contents of the application's temporary directory is deleted when the application ends.
+
+- When using `destinationType.NATIVE_URI` and `sourceType.CAMERA`, photos are saved in the saved photo album regardless on the value of `saveToPhotoAlbum` parameter.
+
+- When using `destinationType.NATIVE_URI` and `sourceType.PHOTOLIBRARY` or `sourceType.SAVEDPHOTOALBUM`, all editing options are ignored and link is returned to original picture.
+
+#### Tizen Quirks
+
+- options not supported
+
+- always returns a FILE URI
+
+#### Windows Phone 7 and 8 Quirks
+
+- Ignores the `allowEdit` parameter.
+
+- Ignores the `correctOrientation` parameter.
+
+- Ignores the `cameraDirection` parameter.
+
+- Ignores the `saveToPhotoAlbum` parameter.  IMPORTANT: All images taken with the WP8/8 Cordova camera API are always copied to the phone's camera roll.  Depending on the user's settings, this could also mean the image is auto-uploaded to their OneDrive.  This could potentially mean the image is available to a wider audience than your app intended. If this is a blocker for your application, you will need to implement the CameraCaptureTask as [documented on MSDN][msdn_wp8_docs]. You may also comment or up-vote the related issue in the [issue tracker][wp8_bug].
+
+- Ignores the `mediaType` property of `cameraOptions` as the Windows Phone SDK does not provide a way to choose videos from PHOTOLIBRARY.
+
+[android_lifecycle]: http://cordova.apache.org/docs/en/dev/guide/platforms/android/lifecycle.html
+[web_activities]: https://hacks.mozilla.org/2013/01/introducing-web-activities/
+[wp8_bug]: https://issues.apache.org/jira/browse/CB-2083
+[msdn_wp8_docs]: http://msdn.microsoft.com/en-us/library/windowsphone/develop/hh394006.aspx
+
+## Sample: Take Pictures, Select Pictures from the Picture Library, and Get Thumbnails <a name="sample"></a>
+
+The Camera plugin allows you to do things like open the device's Camera app and take a picture, or open the file picker and select one. The code snippets in this section demonstrate different tasks including:
+
+* Open the Camera app and [take a Picture](#takePicture)
+* Take a picture and [return thumbnails](#getThumbnails) (resized picture)
+* Take a picture and [generate a FileEntry object](#convert)
+* [Select a file](#selectFile) from the picture library
+* Select a JPEG image and [return thumbnails](#getFileThumbnails) (resized image)
+* Select an image and [generate a FileEntry object](#convert)
+
+## Take a Picture <a name="takePicture"></a>
+
+Before you can take a picture, you need to set some Camera plugin options to pass into the Camera plugin's `getPicture` function. Here is a common set of recommendations. In this example, you create the object that you will use for the Camera options, and set the `sourceType` dynamically to support both the Camera app and the file picker.
+
+```js
+function setOptions(srcType) {
+    var options = {
+        // Some common settings are 20, 50, and 100
+        quality: 50,
+        destinationType: Camera.DestinationType.FILE_URI,
+        // In this app, dynamically set the picture source, Camera or photo gallery
+        sourceType: srcType,
+        encodingType: Camera.EncodingType.JPEG,
+        mediaType: Camera.MediaType.PICTURE,
+        allowEdit: true,
+        correctOrientation: true  //Corrects Android orientation quirks
+    }
+    return options;
+}
+```
+
+Typically, you want to use a FILE_URI instead of a DATA_URL to avoid most memory issues. JPEG is the recommended encoding type for Android.
+
+You take a picture by passing in the options object to `getPicture`, which takes a CameraOptions object as the third argument. When you call `setOptions`, pass `Camera.PictureSourceType.CAMERA` as the picture source.
+
+```js
+function openCamera(selection) {
+
+    var srcType = Camera.PictureSourceType.CAMERA;
+    var options = setOptions(srcType);
+    var func = createNewFileEntry;
+
+    navigator.camera.getPicture(function cameraSuccess(imageUri) {
+
+        displayImage(imageUri);
+        // You may choose to copy the picture, save it somewhere, or upload.
+        func(imageUri);
+
+    }, function cameraError(error) {
+        console.debug("Unable to obtain picture: " + error, "app");
+
+    }, options);
+}
+```
+
+Once you take the picture, you can display it or do something else. In this example, call the app's `displayImage` function from the preceding code.
+
+```js
+function displayImage(imgUri) {
+
+    var elem = document.getElementById('imageFile');
+    elem.src = imgUri;
+}
+```
+
+To display the image on some platforms, you might need to include the main part of the URI in the Content-Security-Policy `<meta>` element in index.html. For example, on Windows 10, you can include `ms-appdata:` in your `<meta>` element. Here is an example.
+
+```html
+<meta http-equiv="Content-Security-Policy" content="default-src 'self' data: gap: ms-appdata: https://ssl.gstatic.com 'unsafe-eval'; style-src 'self' 'unsafe-inline'; media-src *">
+```
+
+## Take a Picture and Return Thumbnails (Resize the Picture) <a name="getThumbnails"></a>
+
+To get smaller images, you can return a resized image by passing both `targetHeight` and `targetWidth` values with your CameraOptions object. In this example, you resize the returned image to fit in a 100px by 100px box (the aspect ratio is maintained, so 100px is either the height or width, whichever is greater in the source).
+
+```js
+function openCamera(selection) {
+
+    var srcType = Camera.PictureSourceType.CAMERA;
+    var options = setOptions(srcType);
+    var func = createNewFileEntry;
+
+    if (selection == "camera-thmb") {
+        options.targetHeight = 100;
+        options.targetWidth = 100;
+    }
+
+    navigator.camera.getPicture(function cameraSuccess(imageUri) {
+
+        // Do something
+
+    }, function cameraError(error) {
+        console.debug("Unable to obtain picture: " + error, "app");
+
+    }, options);
+}
+```
+
+## Select a File from the Picture Library <a name="selectFile"></a>
+
+When selecting a file using the file picker, you also need to set the CameraOptions object. In this example, set the `sourceType` to `Camera.PictureSourceType.SAVEDPHOTOALBUM`. To open the file picker, call `getPicture` just as you did in the previous example, passing in the success and error callbacks along with CameraOptions object.
+
+```js
+function openFilePicker(selection) {
+
+    var srcType = Camera.PictureSourceType.SAVEDPHOTOALBUM;
+    var options = setOptions(srcType);
+    var func = createNewFileEntry;
+
+    navigator.camera.getPicture(function cameraSuccess(imageUri) {
+
+        // Do something
+
+    }, function cameraError(error) {
+        console.debug("Unable to obtain picture: " + error, "app");
+
+    }, options);
+}
+```
+
+## Select an Image and Return Thumbnails (resized images) <a name="getFileThumbnails"></a>
+
+Resizing a file selected with the file picker works just like resizing using the Camera app; set the `targetHeight` and `targetWidth` options.
+
+```js
+function openFilePicker(selection) {
+
+    var srcType = Camera.PictureSourceType.SAVEDPHOTOALBUM;
+    var options = setOptions(srcType);
+    var func = createNewFileEntry;
+
+    if (selection == "picker-thmb") {
+        // To downscale a selected image,
+        // Camera.EncodingType (e.g., JPEG) must match the selected image type.
+        options.targetHeight = 100;
+        options.targetWidth = 100;
+    }
+
+    navigator.camera.getPicture(function cameraSuccess(imageUri) {
+
+        // Do something with image
+
+    }, function cameraError(error) {
+        console.debug("Unable to obtain picture: " + error, "app");
+
+    }, options);
+}
+```
+
+## Take a picture and get a FileEntry Object <a name="convert"></a>
+
+If you want to do something like copy the image to another location, or upload it somewhere using the FileTransfer plugin, you need to get a FileEntry object for the returned picture. To do that, call `window.resolveLocalFileSystemURL` on the file URI returned by the Camera app. If you need to use a FileEntry object, set the `destinationType` to `Camera.DestinationType.FILE_URI` in your CameraOptions object (this is also the default value).
+
+>*Note* You need the [File plugin](https://www.npmjs.com/package/cordova-plugin-file) to call `window.resolveLocalFileSystemURL`.
+
+Here is the call to `window.resolveLocalFileSystemURL`. The image URI is passed to this function from the success callback of `getPicture`. The success handler of `resolveLocalFileSystemURL` receives the FileEntry object.
+
+```js
+function getFileEntry(imgUri) {
+    window.resolveLocalFileSystemURL(imgUri, function success(fileEntry) {
+
+        // Do something with the FileEntry object, like write to it, upload it, etc.
+        // writeFile(fileEntry, imgUri);
+        console.log("got file: " + fileEntry.fullPath);
+        // displayFileData(fileEntry.nativeURL, "Native URL");
+
+    }, function () {
+      // If don't get the FileEntry (which may happen when testing
+      // on some emulators), copy to a new FileEntry.
+        createNewFileEntry(imgUri);
+    });
+}
+```
+
+In the example shown in the preceding code, you call the app's `createNewFileEntry` function if you don't get a valid FileEntry object. The image URI returned from the Camera app should result in a valid FileEntry, but platform behavior on some emulators may be different for files returned from the file picker.
+
+>*Note* To see an example of writing to a FileEntry, see the [File plugin README](https://www.npmjs.com/package/cordova-plugin-file).
+
+The code shown here creates a file in your app's cache (in sandboxed storage) named `tempFile.jpeg`. With the new FileEntry object, you can copy the image to the file or do something else like upload it.
+
+```js
+function createNewFileEntry(imgUri) {
+    window.resolveLocalFileSystemURL(cordova.file.cacheDirectory, function success(dirEntry) {
+
+        // JPEG file
+        dirEntry.getFile("tempFile.jpeg", { create: true, exclusive: false }, function (fileEntry) {
+
+            // Do something with it, like write to it, upload it, etc.
+            // writeFile(fileEntry, imgUri);
+            console.log("got file: " + fileEntry.fullPath);
+            // displayFileData(fileEntry.fullPath, "File copied to");
+
+        }, onErrorCreateFile);
+
+    }, onErrorResolveUrl);
+}
+```

package.json

@@ -1,46 +1,63 @@
 {
   "name": "cordova-plugin-camera",
-  "version": "1.2.0",
+  "version": "4.0.1",
   "description": "Cordova Camera Plugin",
+  "types": "./types/index.d.ts",
   "cordova": {
     "id": "cordova-plugin-camera",
     "platforms": [
-      "firefoxos",
       "android",
-      "amazon-fireos",
-      "ubuntu",
       "ios",
-      "blackberry10",
-      "wp7",
-      "wp8",
-      "windows8",
       "browser",
-      "windows"
+      "windows",
+      "osx"
     ]
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/apache/cordova-plugin-camera"
   },
+  "bugs": {
+    "url": "https://issues.apache.org/jira/browse/CB"
+  },
   "keywords": [
     "cordova",
     "camera",
     "ecosystem:cordova",
-    "cordova-firefoxos",
     "cordova-android",
-    "cordova-amazon-fireos",
-    "cordova-ubuntu",
     "cordova-ios",
-    "cordova-blackberry10",
-    "cordova-wp7",
-    "cordova-wp8",
-    "cordova-windows8",
     "cordova-browser",
-    "cordova-windows"
+    "cordova-windows",
+    "cordova-osx"
   ],
-  "peerDependencies": {
-    "cordova-plugin-file": ">=2.0.0"
+  "scripts": {
+    "precommit": "npm run gen-docs && git add README.md",
+    "gen-docs": "jsdoc2md --template \"jsdoc2md/TEMPLATE.md\" \"www/**/*.js\" --plugin \"dmd-plugin-cordova-plugin\" > README.md",
+    "test": "npm run eslint",
+    "eslint": "node node_modules/eslint/bin/eslint www && node node_modules/eslint/bin/eslint src && node node_modules/eslint/bin/eslint tests"
   },
   "author": "Apache Software Foundation",
-  "license": "Apache 2.0"
+  "license": "Apache-2.0",
+  "engines": {
+    "cordovaDependencies": {
+      "3.0.0": {
+        "cordova-android": ">=6.3.0"
+      },
+      "5.0.0": {
+        "cordova": ">100"
+      }
+    }
+  },
+  "devDependencies": {
+    "dmd-plugin-cordova-plugin": "^0.1.0",
+    "eslint": "^4.3.0",
+    "eslint-config-semistandard": "^11.0.0",
+    "eslint-config-standard": "^10.2.1",
+    "eslint-plugin-import": "^2.3.0",
+    "eslint-plugin-node": "^5.0.0",
+    "eslint-plugin-promise": "^3.5.0",
+    "eslint-plugin-standard": "^3.0.1",
+    "husky": "^0.10.1",
+    "jsdoc-to-markdown": "^1.2.0"
+  }
 }

plugin.xml

@@ -22,7 +22,7 @@
     xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:rim="http://www.blackberry.com/ns/widgets"
     id="cordova-plugin-camera"
-    version="1.2.0">
+    version="4.0.1">
     <name>Camera</name>
     <description>Cordova Camera Plugin</description>
     <license>Apache 2.0</license>
@@ -30,6 +30,10 @@
     <repo>https://git-wip-us.apache.org/repos/asf/cordova-plugin-camera.git</repo>
     <issue>https://issues.apache.org/jira/browse/CB/component/12320645</issue>
 
+    <engines>
+        <engine name="cordova-android" version=">=6.3.0" />
+    </engines>
+
     <js-module src="www/CameraConstants.js" name="Camera">
         <clobbers target="Camera" />
     </js-module>
@@ -44,19 +48,6 @@
         <clobbers target="navigator.camera" />
     </js-module>
 
-    <!-- firefoxos -->
-    <platform name="firefoxos">
-        <config-file target="config.xml" parent="/*">
-            <feature name="Camera">
-                <param name="firefoxos-package" value="Camera" />
-            </feature>
-        </config-file>                                         
-        
-        <js-module src="src/firefoxos/CameraProxy.js" name="CameraProxy">
-          <runs />
-        </js-module>
-    </platform>  
-
     <!-- android -->
     <platform name="android">
         <config-file target="res/xml/config.xml" parent="/*">
@@ -67,58 +58,31 @@
         <config-file target="AndroidManifest.xml" parent="/*">
             <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
         </config-file>
-
-        <source-file src="src/android/CameraLauncher.java" target-dir="src/org/apache/cordova/camera" />
-        <source-file src="src/android/FileHelper.java" target-dir="src/org/apache/cordova/camera" />
-        <source-file src="src/android/ExifHelper.java" target-dir="src/org/apache/cordova/camera" />
-
-        <js-module src="www/CameraPopoverHandle.js" name="CameraPopoverHandle">
-            <clobbers target="CameraPopoverHandle" />
-        </js-module>
-
-     </platform>
-
-    <!-- amazon-fireos -->
-    <platform name="amazon-fireos">
-        <config-file target="res/xml/config.xml" parent="/*">
-            <feature name="Camera">
-                <param name="android-package" value="org.apache.cordova.camera.CameraLauncher"/>
-            </feature>
-        </config-file>
-        <config-file target="AndroidManifest.xml" parent="/*">
-            <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+        <config-file target="AndroidManifest.xml" parent="application">
+          <provider
+              android:name="android.support.v4.content.FileProvider"
+              android:authorities="${applicationId}.provider"
+              android:exported="false"
+              android:grantUriPermissions="true" >
+              <meta-data
+                  android:name="android.support.FILE_PROVIDER_PATHS"
+                  android:resource="@xml/provider_paths"/>
+          </provider>
         </config-file>
 
         <source-file src="src/android/CameraLauncher.java" target-dir="src/org/apache/cordova/camera" />
+        <source-file src="src/android/CordovaUri.java" target-dir="src/org/apache/cordova/camera" />
         <source-file src="src/android/FileHelper.java" target-dir="src/org/apache/cordova/camera" />
         <source-file src="src/android/ExifHelper.java" target-dir="src/org/apache/cordova/camera" />
+        <source-file src="src/android/xml/provider_paths.xml" target-dir="res/xml" />
 
         <js-module src="www/CameraPopoverHandle.js" name="CameraPopoverHandle">
             <clobbers target="CameraPopoverHandle" />
-        </js-module>
+          </js-module>
 
-     </platform>
-     
-     <!-- ubuntu -->
-     <platform name="ubuntu">
-         <config-file target="config.xml" parent="/*">
-             <feature name="Camera">
-                 <param policy_group="camera" policy_version="1" />
-             </feature>
-         </config-file>
-         <js-module src="www/CameraPopoverHandle.js" name="CameraPopoverHandle">
-            <clobbers target="CameraPopoverHandle" />
-         </js-module>
-         <header-file src="src/ubuntu/camera.h" />
-         <source-file src="src/ubuntu/camera.cpp" />
+        <framework src="com.android.support:support-v4:24.1.1+" />
 
-         <resource-file src="src/ubuntu/back.png" />
-         <resource-file src="src/ubuntu/CaptureWidget.qml" />
-         <resource-file src="src/ubuntu/shoot.png" />
-         <resource-file src="src/ubuntu/toolbar-left.png" />
-         <resource-file src="src/ubuntu/toolbar-middle.png" />
-         <resource-file src="src/ubuntu/toolbar-right.png" />
-     </platform>
+      </platform>
 
      <!-- ios -->
      <platform name="ios">
@@ -147,86 +111,9 @@
          <framework src="MobileCoreServices.framework" />
          <framework src="CoreGraphics.framework" />
          <framework src="AVFoundation.framework" />
-         
-         <config-file target="*-Info.plist" parent="NSLocationWhenInUseUsageDescription">
-             <string></string>
-         </config-file>
-                  
+
      </platform>
 
-    <!-- blackberry10 -->
-    <platform name="blackberry10">
-        <source-file src="src/blackberry10/index.js" target-dir="Camera" />
-        <config-file target="www/config.xml" parent="/widget">
-            <feature name="Camera" value="Camera"/>
-        </config-file>
-        <config-file target="www/config.xml" parent="/widget/rim:permissions">
-          <rim:permit>access_shared</rim:permit>
-          <rim:permit>use_camera</rim:permit>
-        </config-file>
-        <js-module src="www/CameraPopoverHandle.js" name="CameraPopoverHandle">
-            <clobbers target="CameraPopoverHandle" />
-        </js-module>
-        <asset src="www/blackberry10/assets" target="chrome" />
-    </platform>
-
-     <!-- wp7 -->
-    <platform name="wp7">
-        <config-file target="config.xml" parent="/*">
-            <feature name="Camera">
-                <param name="wp-package" value="Camera"/>
-            </feature>
-        </config-file>
-
-        <config-file target="Properties/WMAppManifest.xml" parent="/Deployment/App/Capabilities">
-            <Capability Name="ID_CAP_ISV_CAMERA" />
-            <Capability Name="ID_CAP_MEDIALIB" />
-        </config-file>
-
-        <source-file src="src/wp/Camera.cs" />
-
-
-        <js-module src="www/CameraPopoverHandle.js" name="CameraPopoverHandle">
-            <clobbers target="CameraPopoverHandle" />
-        </js-module>
-    </platform>
-
-    <!-- wp8 -->
-    <platform name="wp8">
-        <config-file target="config.xml" parent="/*">
-            <feature name="Camera">
-                <param name="wp-package" value="Camera"/>
-            </feature>
-        </config-file>
-
-        <config-file target="Properties/WMAppManifest.xml" parent="/Deployment/App/Capabilities">
-            <Capability Name="ID_CAP_ISV_CAMERA" />
-            <Capability Name="ID_CAP_MEDIALIB_PHOTO"/>
-        </config-file>
-
-        <source-file src="src/wp/Camera.cs" />
-
-        <js-module src="www/CameraPopoverHandle.js" name="CameraPopoverHandle">
-            <clobbers target="CameraPopoverHandle" />
-        </js-module>
-    </platform>
-
-    <!-- windows8 -->
-    <platform name="windows8">
-
-        <config-file target="package.appxmanifest" parent="/Package/Capabilities">
-            <Capability Name="picturesLibrary" />
-            <DeviceCapability Name="webcam" />
-        </config-file>
-        <js-module src="www/CameraPopoverHandle.js" name="CameraPopoverHandle">
-            <clobbers target="CameraPopoverHandle" />
-        </js-module>
-        <js-module src="src/windows/CameraProxy.js" name="CameraProxy">
-            <merges target="" />
-        </js-module>
-
-    </platform>
-
     <!-- browser -->
     <platform name="browser">
         <config-file target="config.xml" parent="/*">
@@ -249,10 +136,27 @@
             <clobbers target="CameraPopoverHandle" />
         </js-module>
         <js-module src="src/windows/CameraProxy.js" name="CameraProxy">
-            <merges target="" />
+            <runs />
         </js-module>
     </platform>
 
+    <!-- osx -->
+    <platform name="osx">
+        <config-file target="config.xml" parent="/*">
+            <feature name="Camera">
+                <param name="osx-package" value="CDVCamera"/>
+            </feature>
+        </config-file>
 
-
+        <js-module src="www/CameraPopoverHandle.js" name="CameraPopoverHandle">
+            <clobbers target="CameraPopoverHandle" />
+        </js-module>
+        
+        <header-file src="src/osx/CDVCamera.h" />
+        <source-file src="src/osx/CDVCamera.m" />
+                
+        <framework src="Quartz.framework" />
+        <framework src="AppKit.framework" />
+    </platform>
+    
 </plugin>

src/android/CordovaUri.java

@@ -0,0 +1,104 @@
+/*
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+*/
+
+package org.apache.cordova.camera;
+
+import android.net.Uri;
+import android.os.Build;
+import android.os.Environment;
+import android.support.v4.content.FileProvider;
+
+import java.io.File;
+
+/*
+ * This class exists because Andorid FilesProvider doesn't work on Android 4.4.4 and below and throws
+ * weird errors.  I'm not sure why writing to shared cache directories is somehow verboten, but it is
+ * and this error is irritating for a Compatibility library to have.
+ *
+ */
+
+public class CordovaUri {
+
+    private Uri androidUri;
+    private String fileName;
+    private Uri fileUri;
+
+    /*
+     * We always expect a FileProvider string to be passed in for the file that we create
+     *
+     */
+    CordovaUri (Uri inputUri)
+    {
+        //Determine whether the file is a content or file URI
+        if(inputUri.getScheme().equals("content"))
+        {
+            androidUri = inputUri;
+            fileName = getFileNameFromUri(androidUri);
+            fileUri = Uri.parse("file://" + fileName);
+        }
+        else
+        {
+            fileUri = inputUri;
+            fileName = FileHelper.stripFileProtocol(inputUri.toString());
+        }
+    }
+
+    public Uri getFileUri()
+    {
+        return fileUri;
+    }
+
+    public String getFilePath()
+    {
+        return fileName;
+    }
+
+    /*
+     * This only gets called by takePicture
+     */
+
+    public Uri getCorrectUri()
+    {
+        if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
+            return androidUri;
+        else
+            return fileUri;
+    }
+
+ /*
+  * This is dirty, but it does the job.
+  *
+  * Since the FilesProvider doesn't really provide you a way of getting a URL from the file,
+  * and since we actually need the Camera to create the file for us most of the time, we don't
+  * actually write the file, just generate the location based on a timestamp, we need to get it
+  * back from the Intent.
+  *
+  * However, the FilesProvider preserves the path, so we can at least write to it from here, since
+  * we own the context in this case.
+ */
+
+    private String getFileNameFromUri(Uri uri) {
+        String fullUri = uri.toString();
+        String partial_path = fullUri.split("external_files")[1];
+        File external_storage = Environment.getExternalStorageDirectory();
+        String path = external_storage.getAbsolutePath() + partial_path;
+        return path;
+
+    }
+}

src/android/FileHelper.java

@@ -17,11 +17,13 @@
 package org.apache.cordova.camera;
 
 import android.annotation.SuppressLint;
+import android.content.ContentUris;
 import android.content.Context;
 import android.content.CursorLoader;
 import android.database.Cursor;
 import android.net.Uri;
 import android.os.Build;
+import android.os.Environment;
 import android.provider.DocumentsContract;
 import android.provider.MediaStore;
 import android.webkit.MimeTypeMap;
@@ -53,13 +55,9 @@ public class FileHelper {
         if (Build.VERSION.SDK_INT < 11)
             realPath = FileHelper.getRealPathFromURI_BelowAPI11(cordova.getActivity(), uri);
 
-        // SDK >= 11 && SDK < 19
-        else if (Build.VERSION.SDK_INT < 19)
-            realPath = FileHelper.getRealPathFromURI_API11to18(cordova.getActivity(), uri);
-
-        // SDK > 19 (Android 4.4)
+        // SDK >= 11
         else
-            realPath = FileHelper.getRealPathFromURI_API19(cordova.getActivity(), uri);
+            realPath = FileHelper.getRealPathFromURI_API11_And_Above(cordova.getActivity(), uri);
 
         return realPath;
     }
@@ -77,53 +75,71 @@ public class FileHelper {
     }
 
     @SuppressLint("NewApi")
-    public static String getRealPathFromURI_API19(Context context, Uri uri) {
-        String filePath = "";
-        try {
-            String wholeID = DocumentsContract.getDocumentId(uri);
+    public static String getRealPathFromURI_API11_And_Above(final Context context, final Uri uri) {
 
-            // Split at colon, use second item in the array
-            String id = wholeID.indexOf(":") > -1 ? wholeID.split(":")[1] : wholeID.indexOf(";") > -1 ? wholeID
-                    .split(";")[1] : wholeID;
+        final boolean isKitKat = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT;
+        // DocumentProvider
+        if (isKitKat && DocumentsContract.isDocumentUri(context, uri)) {
 
-            String[] column = { MediaStore.Images.Media.DATA };
+            // ExternalStorageProvider
+            if (isExternalStorageDocument(uri)) {
+                final String docId = DocumentsContract.getDocumentId(uri);
+                final String[] split = docId.split(":");
+                final String type = split[0];
 
-            // where id is equal to
-            String sel = MediaStore.Images.Media._ID + "=?";
+                if ("primary".equalsIgnoreCase(type)) {
+                    return Environment.getExternalStorageDirectory() + "/" + split[1];
+                }
 
-            Cursor cursor = context.getContentResolver().query(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, column,
-                    sel, new String[] { id }, null);
-
-            int columnIndex = cursor.getColumnIndex(column[0]);
-
-            if (cursor.moveToFirst()) {
-                filePath = cursor.getString(columnIndex);
+                // TODO handle non-primary volumes
             }
-            cursor.close();
-        } catch (Exception e) {
-            filePath = "";
-        }
-        return filePath;
-    }
+            // DownloadsProvider
+            else if (isDownloadsDocument(uri)) {
 
-    @SuppressLint("NewApi")
-    public static String getRealPathFromURI_API11to18(Context context, Uri contentUri) {
-        String[] proj = { MediaStore.Images.Media.DATA };
-        String result = null;
+                final String id = DocumentsContract.getDocumentId(uri);
+                final Uri contentUri = ContentUris.withAppendedId(
+                        Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
 
-        try {
-            CursorLoader cursorLoader = new CursorLoader(context, contentUri, proj, null, null, null);
-            Cursor cursor = cursorLoader.loadInBackground();
-
-            if (cursor != null) {
-                int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
-                cursor.moveToFirst();
-                result = cursor.getString(column_index);
+                return getDataColumn(context, contentUri, null, null);
+            }
+            // MediaProvider
+            else if (isMediaDocument(uri)) {
+                final String docId = DocumentsContract.getDocumentId(uri);
+                final String[] split = docId.split(":");
+                final String type = split[0];
+
+                Uri contentUri = null;
+                if ("image".equals(type)) {
+                    contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
+                } else if ("video".equals(type)) {
+                    contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
+                } else if ("audio".equals(type)) {
+                    contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
+                }
+
+                final String selection = "_id=?";
+                final String[] selectionArgs = new String[] {
+                        split[1]
+                };
+
+                return getDataColumn(context, contentUri, selection, selectionArgs);
             }
-        } catch (Exception e) {
-            result = null;
         }
-        return result;
+        // MediaStore (and general)
+        else if ("content".equalsIgnoreCase(uri.getScheme())) {
+
+            // Return the remote address
+            if (isGooglePhotosUri(uri))
+                return uri.getLastPathSegment();
+
+            return getDataColumn(context, uri, null, null);
+        }
+        // File
+        else if ("file".equalsIgnoreCase(uri.getScheme())) {
+            return uri.getPath();
+        }
+
+        return null;
     }
 
     public static String getRealPathFromURI_BelowAPI11(Context context, Uri contentUri) {
@@ -228,4 +244,76 @@ public class FileHelper {
 
         return mimeType;
     }
+
+    /**
+     * Get the value of the data column for this Uri. This is useful for
+     * MediaStore Uris, and other file-based ContentProviders.
+     *
+     * @param context The context.
+     * @param uri The Uri to query.
+     * @param selection (Optional) Filter used in the query.
+     * @param selectionArgs (Optional) Selection arguments used in the query.
+     * @return The value of the _data column, which is typically a file path.
+     * @author paulburke
+     */
+    public static String getDataColumn(Context context, Uri uri, String selection,
+                                       String[] selectionArgs) {
+
+        Cursor cursor = null;
+        final String column = "_data";
+        final String[] projection = {
+                column
+        };
+
+        try {
+            cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs,
+                    null);
+            if (cursor != null && cursor.moveToFirst()) {
+
+                final int column_index = cursor.getColumnIndexOrThrow(column);
+                return cursor.getString(column_index);
+            }
+        } catch (Exception e) {
+            return null;
+        } finally {
+            if (cursor != null)
+                cursor.close();
+        }
+        return null;
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is ExternalStorageProvider.
+     * @author paulburke
+     */
+    public static boolean isExternalStorageDocument(Uri uri) {
+        return "com.android.externalstorage.documents".equals(uri.getAuthority());
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is DownloadsProvider.
+     * @author paulburke
+     */
+    public static boolean isDownloadsDocument(Uri uri) {
+        return "com.android.providers.downloads.documents".equals(uri.getAuthority());
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is MediaProvider.
+     * @author paulburke
+     */
+    public static boolean isMediaDocument(Uri uri) {
+        return "com.android.providers.media.documents".equals(uri.getAuthority());
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is Google Photos.
+     */
+    public static boolean isGooglePhotosUri(Uri uri) {
+        return "com.google.android.apps.photos.content".equals(uri.getAuthority());
+    }
 }

src/android/xml/provider_paths.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+
+<paths xmlns:android="http://schemas.android.com/apk/res/android">
+    <external-path name="external_files" path="."/>
+</paths>

src/blackberry10/index.js

@@ -1,224 +0,0 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
-*/
-var PictureSourceType = {
-        PHOTOLIBRARY : 0,    // Choose image from picture library (same as SAVEDPHOTOALBUM for Android)
-        CAMERA : 1,          // Take picture from camera
-        SAVEDPHOTOALBUM : 2  // Choose image from picture library (same as PHOTOLIBRARY for Android)
-    },
-    DestinationType = {
-        DATA_URL: 0,         // Return base64 encoded string
-        FILE_URI: 1,         // Return file uri (content://media/external/images/media/2 for Android)
-        NATIVE_URI: 2        // Return native uri (eg. asset-library://... for iOS)
-    },
-    savePath = window.qnx.webplatform.getApplication().getEnv("HOME").replace('/data', '') + '/shared/camera/',
-    invokeAvailable = true;
-
-//check for camera card - it isn't currently availble in work perimeter
-window.qnx.webplatform.getApplication().invocation.queryTargets(
-    {
-        type: 'image/jpeg',
-        action: 'bb.action.CAPTURE',
-        target_type: 'CARD'
-    },
-    function (error, targets) {
-        invokeAvailable = !error && targets && targets instanceof Array &&
-            targets.filter(function (t) { return t.default === 'sys.camera.card' }).length > 0;
-    }
-);
-
-//open a webview with getUserMedia camera card implementation when camera card not available
-function showCameraDialog (done, cancel, fail) {
-    var wv = qnx.webplatform.createWebView(function () {
-        wv.url = 'local:///chrome/camera.html';
-        wv.allowQnxObject = true;
-        wv.allowRpc = true;
-        wv.zOrder = 1;
-        wv.setGeometry(0, 0, screen.width, screen.height);
-        wv.backgroundColor = 0x00000000;
-        wv.active = true;
-        wv.visible = true;
-        wv.on('UserMediaRequest', function (evt, args) {
-            wv.allowUserMedia(JSON.parse(args).id, 'CAMERA_UNIT_REAR');
-        });
-        wv.on('JavaScriptCallback', function (evt, data) {
-            var args = JSON.parse(data).args;
-            if (args[0] === 'cordova-plugin-camera') {
-                if (args[1] === 'cancel') {
-                    cancel('User canceled');
-                } else if (args[1] === 'error') {
-                    fail(args[2]);
-                } else {
-                    saveImage(args[1], done, fail);
-                }
-                wv.un('JavaScriptCallback', arguments.callee);
-                wv.visible = false;
-                wv.destroy();
-                qnx.webplatform.getApplication().unlockRotation();
-            }
-        });
-        wv.on('Destroyed', function () {
-            wv.delete();
-        });
-        qnx.webplatform.getApplication().lockRotation();
-        qnx.webplatform.getController().dispatchEvent('webview.initialized', [wv]);
-    });
-}
-
-//create unique name for saved file (same pattern as BB10 camera app)
-function imgName() {
-    var date = new Date(),
-        pad = function (n) { return n < 10 ? '0' + n : n };
-    return 'IMG_' + date.getFullYear() + pad(date.getMonth() + 1) + pad(date.getDate()) + '_' +
-            pad(date.getHours()) + pad(date.getMinutes()) + pad(date.getSeconds()) + '.png';
-}
-
-//convert dataURI to Blob
-function dataURItoBlob(dataURI) {
-    var byteString = atob(dataURI.split(',')[1]),
-        mimeString = dataURI.split(',')[0].split(':')[1].split(';')[0],
-        arrayBuffer = new ArrayBuffer(byteString.length),
-        ia = new Uint8Array(arrayBuffer),
-        i;
-    for (i = 0; i < byteString.length; i++) {
-        ia[i] = byteString.charCodeAt(i);
-    }
-    return new Blob([new DataView(arrayBuffer)], { type: mimeString });
-}
-
-//save dataURI to file system and call success with path
-function saveImage(data, success, fail) {
-    var name = savePath + imgName();
-    require('lib/webview').setSandbox(false);
-    window.webkitRequestFileSystem(window.PERSISTENT, 0, function (fs) {
-        fs.root.getFile(name, { create: true }, function (entry) {
-            entry.createWriter(function (writer) {
-                writer.onwriteend = function () {
-                    success(name);
-                };
-                writer.onerror = fail;
-                writer.write(dataURItoBlob(data));
-            });
-        }, fail);
-    }, fail);
-}
-
-function encodeBase64(filePath, callback) {
-    var sandbox = window.qnx.webplatform.getController().setFileSystemSandbox, // save original sandbox value
-        errorHandler = function (err) {
-            var msg = "An error occured: ";
-
-            switch (err.code) {
-            case FileError.NOT_FOUND_ERR:
-                msg += "File or directory not found";
-                break;
-
-            case FileError.NOT_READABLE_ERR:
-                msg += "File or directory not readable";
-                break;
-
-            case FileError.PATH_EXISTS_ERR:
-                msg += "File or directory already exists";
-                break;
-
-            case FileError.TYPE_MISMATCH_ERR:
-                msg += "Invalid file type";
-                break;
-
-            default:
-                msg += "Unknown Error";
-                break;
-            };
-
-            // set it back to original value
-            window.qnx.webplatform.getController().setFileSystemSandbox = sandbox;
-            callback(msg);
-        },
-        gotFile = function (fileEntry) {
-            fileEntry.file(function (file) {
-                var reader = new FileReader();
-
-                reader.onloadend = function (e) {
-                    // set it back to original value
-                    window.qnx.webplatform.getController().setFileSystemSandbox = sandbox;
-                    callback(this.result);
-                };
-
-                reader.readAsDataURL(file);
-            }, errorHandler);
-        },
-        onInitFs = function (fs) {
-            window.qnx.webplatform.getController().setFileSystemSandbox = false;
-            fs.root.getFile(filePath, {create: false}, gotFile, errorHandler);
-        };
-
-    window.webkitRequestFileSystem(window.TEMPORARY, 10 * 1024 * 1024, onInitFs, errorHandler); // set size to 10MB max
-}
-
-module.exports = {
-    takePicture: function (success, fail, args, env) {
-        var destinationType = JSON.parse(decodeURIComponent(args[1])),
-            sourceType = JSON.parse(decodeURIComponent(args[2])),
-            result = new PluginResult(args, env),
-            done = function (data) {
-                if (destinationType === DestinationType.FILE_URI) {
-                    data = "file://" + data;
-                    result.callbackOk(data, false);
-                } else {
-                    encodeBase64(data, function (data) {
-                        if (/^data:/.test(data)) {
-                            data = data.slice(data.indexOf(",") + 1);
-                            result.callbackOk(data, false);
-                        } else {
-                            result.callbackError(data, false);
-                        }
-                    });
-                }
-            },
-            cancel = function (reason) {
-                result.callbackError(reason, false);
-            },
-            invoked = function (error) {
-                if (error) {
-                    result.callbackError(error, false);
-                }
-            };
-
-        switch(sourceType) {
-        case PictureSourceType.CAMERA:
-            if (invokeAvailable) {
-                window.qnx.webplatform.getApplication().cards.camera.open("photo", done, cancel, invoked);
-            } else {
-                showCameraDialog(done, cancel, fail);
-            }
-            break;
-
-        case PictureSourceType.PHOTOLIBRARY:
-        case PictureSourceType.SAVEDPHOTOALBUM:
-            window.qnx.webplatform.getApplication().cards.filePicker.open({
-                mode: "Picker",
-                type: ["picture"]
-            }, done, cancel, invoked);
-            break;
-        }
-
-        result.noResult(true);
-    }
-};

src/browser/CameraProxy.js

@@ -19,25 +19,28 @@
  *
  */
 
-function takePicture(success, error, opts) {
+var HIGHEST_POSSIBLE_Z_INDEX = 2147483647;
+
+function takePicture (success, error, opts) {
     if (opts && opts[2] === 1) {
-        capture(success, error);
+        capture(success, error, opts);
     } else {
         var input = document.createElement('input');
+        input.style.position = 'relative';
+        input.style.zIndex = HIGHEST_POSSIBLE_Z_INDEX;
+        input.className = 'cordova-camera-select';
         input.type = 'file';
         input.name = 'files[]';
 
-        input.onchange = function(inputEvent) {
-            var canvas = document.createElement('canvas');
-
-            var reader = new FileReader();
-            reader.onload = function(readerEvent) {
+        input.onchange = function (inputEvent) {
+            var reader = new FileReader(); /* eslint no-undef : 0 */
+            reader.onload = function (readerEvent) {
                 input.parentNode.removeChild(input);
 
                 var imageData = readerEvent.target.result;
 
                 return success(imageData.substr(imageData.indexOf(',') + 1));
-            }
+            };
 
             reader.readAsDataURL(inputEvent.target.files[0]);
         };
@@ -46,46 +49,64 @@ function takePicture(success, error, opts) {
     }
 }
 
-function capture(success, errorCallback) {
+function capture (success, errorCallback, opts) {
     var localMediaStream;
+    var targetWidth = opts[3];
+    var targetHeight = opts[4];
+
+    targetWidth = targetWidth === -1 ? 320 : targetWidth;
+    targetHeight = targetHeight === -1 ? 240 : targetHeight;
 
     var video = document.createElement('video');
     var button = document.createElement('button');
+    var parent = document.createElement('div');
+    parent.style.position = 'relative';
+    parent.style.zIndex = HIGHEST_POSSIBLE_Z_INDEX;
+    parent.className = 'cordova-camera-capture';
+    parent.appendChild(video);
+    parent.appendChild(button);
 
-    video.width = 320;
-    video.height = 240;
+    video.width = targetWidth;
+    video.height = targetHeight;
     button.innerHTML = 'Capture!';
 
-    button.onclick = function() {
+    button.onclick = function () {
         // create a canvas and capture a frame from video stream
         var canvas = document.createElement('canvas');
-        canvas.getContext('2d').drawImage(video, 0, 0, 320, 240);
-        
+        canvas.width = targetWidth;
+        canvas.height = targetHeight;
+        canvas.getContext('2d').drawImage(video, 0, 0, targetWidth, targetHeight);
+
         // convert image stored in canvas to base64 encoded image
-        var imageData = canvas.toDataURL('img/png');
+        var imageData = canvas.toDataURL('image/png');
         imageData = imageData.replace('data:image/png;base64,', '');
 
-        // stop video stream, remove video and button
-        localMediaStream.stop();
-        video.parentNode.removeChild(video);
-        button.parentNode.removeChild(button);
+        // stop video stream, remove video and button.
+        // Note that MediaStream.stop() is deprecated as of Chrome 47.
+        if (localMediaStream.stop) {
+            localMediaStream.stop();
+        } else {
+            localMediaStream.getTracks().forEach(function (track) {
+                track.stop();
+            });
+        }
+        parent.parentNode.removeChild(parent);
 
         return success(imageData);
-    }
+    };
 
     navigator.getUserMedia = navigator.getUserMedia ||
                              navigator.webkitGetUserMedia ||
                              navigator.mozGetUserMedia ||
                              navigator.msGetUserMedia;
 
-    var successCallback = function(stream) {
+    var successCallback = function (stream) {
         localMediaStream = stream;
         video.src = window.URL.createObjectURL(localMediaStream);
         video.play();
 
-        document.body.appendChild(video);
-        document.body.appendChild(button);
-    }
+        document.body.appendChild(parent);
+    };
 
     if (navigator.getUserMedia) {
         navigator.getUserMedia({video: true, audio: true}, successCallback, errorCallback);
@@ -96,7 +117,7 @@ function capture(success, errorCallback) {
 
 module.exports = {
     takePicture: takePicture,
-    cleanup: function(){}
+    cleanup: function () {}
 };
 
-require("cordova/exec/proxy").add("Camera",module.exports);
+require('cordova/exec/proxy').add('Camera', module.exports);

src/firefoxos/CameraProxy.js

@@ -1,51 +0,0 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
- */
-
-function takePicture(success, error, opts) {
-    var pick = new MozActivity({
-        name: "pick",
-        data: {
-            type: ["image/*"]
-        }
-    });
-
-    pick.onerror = error || function() {};
-
-    pick.onsuccess = function() {
-        // image is returned as Blob in this.result.blob
-        // we need to call success with url or base64 encoded image
-        if (opts && opts.destinationType == 0) {
-            // TODO: base64
-            return;
-        }
-        if (!opts || !opts.destinationType || opts.destinationType > 0) {
-            // url
-            return success(window.URL.createObjectURL(this.result.blob));
-        }
-    };
-}
-
-module.exports = {
-    takePicture: takePicture,
-    cleanup: function(){}
-};
-
-require("cordova/exec/proxy").add("Camera", module.exports);

src/ios/CDVCamera.m

@@ -20,7 +20,6 @@
 #import "CDVCamera.h"
 #import "CDVJpegHeaderWriter.h"
 #import "UIImage+CropScaleOrientation.h"
-#import <Cordova/NSData+Base64.h>
 #import <ImageIO/CGImageProperties.h>
 #import <AssetsLibrary/ALAssetRepresentation.h>
 #import <AssetsLibrary/AssetsLibrary.h>
@@ -31,6 +30,10 @@
 #import <MobileCoreServices/UTCoreTypes.h>
 #import <objc/message.h>
 
+#ifndef __CORDOVA_4_0_0
+    #import <Cordova/NSData+Base64.h>
+#endif
+
 #define CDV_PHOTO_PREFIX @"cdv_photo_"
 
 static NSSet* org_apache_cordova_validArrowDirections;
@@ -38,9 +41,20 @@ static NSSet* org_apache_cordova_validArrowDirections;
 static NSString* toBase64(NSData* data) {
     SEL s1 = NSSelectorFromString(@"cdv_base64EncodedString");
     SEL s2 = NSSelectorFromString(@"base64EncodedString");
-    SEL realSel = [data respondsToSelector:s1] ? s1 : s2;
-    NSString* (*func)(id, SEL) = (void *)[data methodForSelector:realSel];
-    return func(data, realSel);
+    SEL s3 = NSSelectorFromString(@"base64EncodedStringWithOptions:");
+
+    if ([data respondsToSelector:s1]) {
+        NSString* (*func)(id, SEL) = (void *)[data methodForSelector:s1];
+        return func(data, s1);
+    } else if ([data respondsToSelector:s2]) {
+        NSString* (*func)(id, SEL) = (void *)[data methodForSelector:s2];
+        return func(data, s2);
+    } else if ([data respondsToSelector:s3]) {
+        NSString* (*func)(id, SEL, NSUInteger) = (void *)[data methodForSelector:s3];
+        return func(data, s3, 0);
+    } else {
+        return nil;
+    }
 }
 
 @implementation CDVPictureOptions
@@ -52,7 +66,7 @@ static NSString* toBase64(NSData* data) {
     pictureOptions.quality = [command argumentAtIndex:0 withDefault:@(50)];
     pictureOptions.destinationType = [[command argumentAtIndex:1 withDefault:@(DestinationTypeFileUri)] unsignedIntegerValue];
     pictureOptions.sourceType = [[command argumentAtIndex:2 withDefault:@(UIImagePickerControllerSourceTypeCamera)] unsignedIntegerValue];
-    
+
     NSNumber* targetWidth = [command argumentAtIndex:3 withDefault:nil];
     NSNumber* targetHeight = [command argumentAtIndex:4 withDefault:nil];
     pictureOptions.targetSize = CGSizeMake(0, 0);
@@ -67,10 +81,10 @@ static NSString* toBase64(NSData* data) {
     pictureOptions.saveToPhotoAlbum = [[command argumentAtIndex:9 withDefault:@(NO)] boolValue];
     pictureOptions.popoverOptions = [command argumentAtIndex:10 withDefault:nil];
     pictureOptions.cameraDirection = [[command argumentAtIndex:11 withDefault:@(UIImagePickerControllerCameraDeviceRear)] unsignedIntegerValue];
-    
+
     pictureOptions.popoverSupported = NO;
     pictureOptions.usesGeolocation = NO;
-    
+
     return pictureOptions;
 }
 
@@ -95,7 +109,7 @@ static NSString* toBase64(NSData* data) {
 - (NSURL*) urlTransformer:(NSURL*)url
 {
     NSURL* urlToTransform = url;
-    
+
     // for backwards compatibility - we check if this property is there
     SEL sel = NSSelectorFromString(@"urlTransformer");
     if ([self.commandDelegate respondsToSelector:sel]) {
@@ -106,7 +120,7 @@ static NSString* toBase64(NSData* data) {
             urlToTransform = urlTransformer(url);
         }
     }
-    
+
     return urlToTransform;
 }
 
@@ -125,16 +139,16 @@ static NSString* toBase64(NSData* data) {
 - (void)takePicture:(CDVInvokedUrlCommand*)command
 {
     self.hasPendingOperation = YES;
-    
+
     __weak CDVCamera* weakSelf = self;
 
     [self.commandDelegate runInBackground:^{
-        
+
         CDVPictureOptions* pictureOptions = [CDVPictureOptions createFromTakePictureArguments:command];
         pictureOptions.popoverSupported = [weakSelf popoverSupported];
         pictureOptions.usesGeolocation = [weakSelf usesGeolocation];
         pictureOptions.cropToSize = NO;
-        
+
         BOOL hasCamera = [UIImagePickerController isSourceTypeAvailable:pictureOptions.sourceType];
         if (!hasCamera) {
             NSLog(@"Camera.getPicture: source type %lu not available.", (unsigned long)pictureOptions.sourceType);
@@ -149,16 +163,19 @@ static NSString* toBase64(NSData* data) {
             if (authStatus == AVAuthorizationStatusDenied ||
                 authStatus == AVAuthorizationStatusRestricted) {
                 // If iOS 8+, offer a link to the Settings app
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wtautological-pointer-compare"
                 NSString* settingsButton = (&UIApplicationOpenSettingsURLString != NULL)
                     ? NSLocalizedString(@"Settings", nil)
                     : nil;
+#pragma clang diagnostic pop
 
                 // Denied; show an alert
                 dispatch_async(dispatch_get_main_queue(), ^{
                     [[[UIAlertView alloc] initWithTitle:[[NSBundle mainBundle]
                                                          objectForInfoDictionaryKey:@"CFBundleDisplayName"]
                                                 message:NSLocalizedString(@"Access to the camera has been prohibited; please enable it in the Settings app to continue.", nil)
-                                               delegate:self
+                                               delegate:weakSelf
                                       cancelButtonTitle:NSLocalizedString(@"OK", nil)
                                       otherButtonTitles:settingsButton, nil] show];
                 });
@@ -167,12 +184,12 @@ static NSString* toBase64(NSData* data) {
 
         CDVCameraPicker* cameraPicker = [CDVCameraPicker createFromPictureOptions:pictureOptions];
         weakSelf.pickerController = cameraPicker;
-        
+
         cameraPicker.delegate = weakSelf;
         cameraPicker.callbackId = command.callbackId;
         // we need to capture this state for memory warnings that dealloc this object
         cameraPicker.webView = weakSelf.webView;
-        
+
         // Perform UI operations on the main thread
         dispatch_async(dispatch_get_main_queue(), ^{
             // If a popover is already open, close it; we only want one at a time.
@@ -202,7 +219,12 @@ static NSString* toBase64(NSData* data) {
 {
     // If Settings button (on iOS 8), open the settings app
     if (buttonIndex == 1) {
-        [[UIApplication sharedApplication] openURL:[NSURL URLWithString:UIApplicationOpenSettingsURLString]];
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wtautological-pointer-compare"
+        if (&UIApplicationOpenSettingsURLString != NULL) {
+            [[UIApplication sharedApplication] openURL:[NSURL URLWithString:UIApplicationOpenSettingsURLString]];
+        }
+#pragma clang diagnostic pop
     }
 
     // Dismiss the view
@@ -218,9 +240,13 @@ static NSString* toBase64(NSData* data) {
 
 - (void)repositionPopover:(CDVInvokedUrlCommand*)command
 {
-    NSDictionary* options = [command argumentAtIndex:0 withDefault:nil];
+    if (([[self pickerController] pickerPopoverController] != nil) && [[[self pickerController] pickerPopoverController] isPopoverVisible]) {
 
-    [self displayPopover:options];
+        [[[self pickerController] pickerPopoverController] dismissPopoverAnimated:NO];
+
+        NSDictionary* options = [command argumentAtIndex:0 withDefault:nil];
+        [self displayPopover:options];
+    }
 }
 
 - (NSInteger)integerValueForKey:(NSDictionary*)dict key:(NSString*)key defaultValue:(NSInteger)defaultValue
@@ -265,7 +291,7 @@ static NSString* toBase64(NSData* data) {
 {
     if([navigationController isKindOfClass:[UIImagePickerController class]]){
         UIImagePickerController* cameraPicker = (UIImagePickerController*)navigationController;
-        
+
         if(![cameraPicker.mediaTypes containsObject:(NSString*)kUTTypeImage]){
             [viewController.navigationItem setTitle:NSLocalizedString(@"Videos", nil)];
         }
@@ -325,35 +351,35 @@ static NSString* toBase64(NSData* data) {
 - (NSData*)processImage:(UIImage*)image info:(NSDictionary*)info options:(CDVPictureOptions*)options
 {
     NSData* data = nil;
-    
+
     switch (options.encodingType) {
         case EncodingTypePNG:
             data = UIImagePNGRepresentation(image);
             break;
         case EncodingTypeJPEG:
         {
-            if ((options.allowsEditing == NO) && (options.targetSize.width <= 0) && (options.targetSize.height <= 0) && (options.correctOrientation == NO)){
+            if ((options.allowsEditing == NO) && (options.targetSize.width <= 0) && (options.targetSize.height <= 0) && (options.correctOrientation == NO) && (([options.quality integerValue] == 100) || (options.sourceType != UIImagePickerControllerSourceTypeCamera))){
                 // use image unedited as requested , don't resize
                 data = UIImageJPEGRepresentation(image, 1.0);
             } else {
-                if (options.usesGeolocation) {
-                    NSDictionary* controllerMetadata = [info objectForKey:@"UIImagePickerControllerMediaMetadata"];
-                    if (controllerMetadata) {
-                        self.data = data;
-                        self.metadata = [[NSMutableDictionary alloc] init];
-                        
-                        NSMutableDictionary* EXIFDictionary = [[controllerMetadata objectForKey:(NSString*)kCGImagePropertyExifDictionary]mutableCopy];
-                        if (EXIFDictionary)	{
-                            [self.metadata setObject:EXIFDictionary forKey:(NSString*)kCGImagePropertyExifDictionary];
-                        }
-                        
-                        if (IsAtLeastiOSVersion(@"8.0")) {
-                            [[self locationManager] performSelector:NSSelectorFromString(@"requestWhenInUseAuthorization") withObject:nil afterDelay:0];
-                        }
-                        [[self locationManager] startUpdatingLocation];
+                data = UIImageJPEGRepresentation(image, [options.quality floatValue] / 100.0f);
+            }
+
+            if (options.usesGeolocation) {
+                NSDictionary* controllerMetadata = [info objectForKey:@"UIImagePickerControllerMediaMetadata"];
+                if (controllerMetadata) {
+                    self.data = data;
+                    self.metadata = [[NSMutableDictionary alloc] init];
+
+                    NSMutableDictionary* EXIFDictionary = [[controllerMetadata objectForKey:(NSString*)kCGImagePropertyExifDictionary]mutableCopy];
+                    if (EXIFDictionary)	{
+                        [self.metadata setObject:EXIFDictionary forKey:(NSString*)kCGImagePropertyExifDictionary];
                     }
-                } else {
-                    data = UIImageJPEGRepresentation(image, [options.quality floatValue] / 100.0f);
+
+                    if (IsAtLeastiOSVersion(@"8.0")) {
+                        [[self locationManager] performSelector:NSSelectorFromString(@"requestWhenInUseAuthorization") withObject:nil afterDelay:0];
+                    }
+                    [[self locationManager] startUpdatingLocation];
                 }
             }
         }
@@ -361,7 +387,7 @@ static NSString* toBase64(NSData* data) {
         default:
             break;
     };
-    
+
     return data;
 }
 
@@ -370,13 +396,13 @@ static NSString* toBase64(NSData* data) {
     NSString* docsPath = [NSTemporaryDirectory()stringByStandardizingPath];
     NSFileManager* fileMgr = [[NSFileManager alloc] init]; // recommended by Apple (vs [NSFileManager defaultManager]) to be threadsafe
     NSString* filePath;
-    
+
     // generate unique file name
     int i = 1;
     do {
         filePath = [NSString stringWithFormat:@"%@/%@%03d.%@", docsPath, CDV_PHOTO_PREFIX, i++, extension];
     } while ([fileMgr fileExistsAtPath:filePath]);
-    
+
     return filePath;
 }
 
@@ -389,13 +415,13 @@ static NSString* toBase64(NSData* data) {
     } else {
         image = [info objectForKey:UIImagePickerControllerOriginalImage];
     }
-    
+
     if (options.correctOrientation) {
         image = [image imageCorrectedForCaptureOrientation];
     }
-    
+
     UIImage* scaledImage = nil;
-    
+
     if ((options.targetSize.width > 0) && (options.targetSize.height > 0)) {
         // if cropToSize, resize image and crop to target size, otherwise resize to fit target without cropping
         if (options.cropToSize) {
@@ -404,11 +430,11 @@ static NSString* toBase64(NSData* data) {
             scaledImage = [image imageByScalingNotCroppingForSize:options.targetSize];
         }
     }
-    
+
     return (scaledImage == nil ? image : scaledImage);
 }
 
-- (CDVPluginResult*)resultForImage:(CDVPictureOptions*)options info:(NSDictionary*)info
+- (void)resultForImage:(CDVPictureOptions*)options info:(NSDictionary*)info completion:(void (^)(CDVPluginResult* res))completion
 {
     CDVPluginResult* result = nil;
     BOOL saveToPhotoAlbum = options.saveToPhotoAlbum;
@@ -417,10 +443,28 @@ static NSString* toBase64(NSData* data) {
     switch (options.destinationType) {
         case DestinationTypeNativeUri:
         {
-            NSURL* url = (NSURL*)[info objectForKey:UIImagePickerControllerReferenceURL];
-            NSString* nativeUri = [[self urlTransformer:url] absoluteString];
-            result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:nativeUri];
+            NSURL* url = [info objectForKey:UIImagePickerControllerReferenceURL];
             saveToPhotoAlbum = NO;
+            // If, for example, we use sourceType = Camera, URL might be nil because image is stored in memory.
+            // In this case we must save image to device before obtaining an URI.
+            if (url == nil) {
+                image = [self retrieveImage:info options:options];
+                ALAssetsLibrary* library = [ALAssetsLibrary new];
+                [library writeImageToSavedPhotosAlbum:image.CGImage orientation:(ALAssetOrientation)(image.imageOrientation) completionBlock:^(NSURL *assetURL, NSError *error) {
+                    CDVPluginResult* resultToReturn = nil;
+                    if (error) {
+                        resultToReturn = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsString:[error localizedDescription]];
+                    } else {
+                        NSString* nativeUri = [[self urlTransformer:assetURL] absoluteString];
+                        resultToReturn = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:nativeUri];
+                    }
+                    completion(resultToReturn);
+                }];
+                return;
+            } else {
+                NSString* nativeUri = [[self urlTransformer:url] absoluteString];
+                result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:nativeUri];
+            }
         }
             break;
         case DestinationTypeFileUri:
@@ -428,11 +472,11 @@ static NSString* toBase64(NSData* data) {
             image = [self retrieveImage:info options:options];
             NSData* data = [self processImage:image info:info options:options];
             if (data) {
-                
+
                 NSString* extension = options.encodingType == EncodingTypePNG? @"png" : @"jpg";
                 NSString* filePath = [self tempFilePath:extension];
                 NSError* err = nil;
-                
+
                 // save file
                 if (![data writeToFile:filePath options:NSAtomicWrite error:&err]) {
                     result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsString:[err localizedDescription]];
@@ -446,7 +490,6 @@ static NSString* toBase64(NSData* data) {
         {
             image = [self retrieveImage:info options:options];
             NSData* data = [self processImage:image info:info options:options];
-            
             if (data)  {
                 result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:toBase64(data)];
             }
@@ -455,13 +498,13 @@ static NSString* toBase64(NSData* data) {
         default:
             break;
     };
-    
+
     if (saveToPhotoAlbum && image) {
         ALAssetsLibrary* library = [ALAssetsLibrary new];
         [library writeImageToSavedPhotosAlbum:image.CGImage orientation:(ALAssetOrientation)(image.imageOrientation) completionBlock:nil];
     }
-    
-    return result;
+
+    completion(result);
 }
 
 - (CDVPluginResult*)resultForVideo:(NSDictionary*)info
@@ -474,25 +517,28 @@ static NSString* toBase64(NSData* data) {
 {
     __weak CDVCameraPicker* cameraPicker = (CDVCameraPicker*)picker;
     __weak CDVCamera* weakSelf = self;
-    
+
     dispatch_block_t invoke = ^(void) {
         __block CDVPluginResult* result = nil;
-        
+
         NSString* mediaType = [info objectForKey:UIImagePickerControllerMediaType];
         if ([mediaType isEqualToString:(NSString*)kUTTypeImage]) {
-            result = [self resultForImage:cameraPicker.pictureOptions info:info];
+            [weakSelf resultForImage:cameraPicker.pictureOptions info:info completion:^(CDVPluginResult* res) {
+                if (![self usesGeolocation] || picker.sourceType != UIImagePickerControllerSourceTypeCamera) {
+                    [weakSelf.commandDelegate sendPluginResult:res callbackId:cameraPicker.callbackId];
+                    weakSelf.hasPendingOperation = NO;
+                    weakSelf.pickerController = nil;
+                }
+            }];
         }
         else {
-            result = [self resultForVideo:info];
-        }
-        
-        if (result) {
+            result = [weakSelf resultForVideo:info];
             [weakSelf.commandDelegate sendPluginResult:result callbackId:cameraPicker.callbackId];
             weakSelf.hasPendingOperation = NO;
             weakSelf.pickerController = nil;
         }
     };
-    
+
     if (cameraPicker.pictureOptions.popoverSupported && (cameraPicker.pickerPopoverController != nil)) {
         [cameraPicker.pickerPopoverController dismissPopoverAnimated:YES];
         cameraPicker.pickerPopoverController.delegate = nil;
@@ -515,17 +561,20 @@ static NSString* toBase64(NSData* data) {
 {
     __weak CDVCameraPicker* cameraPicker = (CDVCameraPicker*)picker;
     __weak CDVCamera* weakSelf = self;
-    
+
     dispatch_block_t invoke = ^ (void) {
         CDVPluginResult* result;
-        if ([ALAssetsLibrary authorizationStatus] == ALAuthorizationStatusAuthorized) {
-            result = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:@"no image selected"];
-        } else {
+        if (picker.sourceType == UIImagePickerControllerSourceTypeCamera && [AVCaptureDevice authorizationStatusForMediaType:AVMediaTypeVideo] != ALAuthorizationStatusAuthorized) {
+            result = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:@"has no access to camera"];
+        } else if (picker.sourceType != UIImagePickerControllerSourceTypeCamera && [ALAssetsLibrary authorizationStatus] != ALAuthorizationStatusAuthorized) {
             result = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:@"has no access to assets"];
+        } else {
+            result = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:@"No Image Selected"];
         }
-        
+
+
         [weakSelf.commandDelegate sendPluginResult:result callbackId:cameraPicker.callbackId];
-        
+
         weakSelf.hasPendingOperation = NO;
         weakSelf.pickerController = nil;
     };
@@ -538,11 +587,11 @@ static NSString* toBase64(NSData* data) {
 	if (locationManager != nil) {
 		return locationManager;
 	}
-    
+
 	locationManager = [[CLLocationManager alloc] init];
 	[locationManager setDesiredAccuracy:kCLLocationAccuracyNearestTenMeters];
 	[locationManager setDelegate:self];
-    
+
 	return locationManager;
 }
 
@@ -551,15 +600,15 @@ static NSString* toBase64(NSData* data) {
     if (locationManager == nil) {
         return;
     }
-    
+
     [self.locationManager stopUpdatingLocation];
     self.locationManager = nil;
-    
+
     NSMutableDictionary *GPSDictionary = [[NSMutableDictionary dictionary] init];
-    
+
     CLLocationDegrees latitude  = newLocation.coordinate.latitude;
     CLLocationDegrees longitude = newLocation.coordinate.longitude;
-    
+
     // latitude
     if (latitude < 0.0) {
         latitude = latitude * -1.0f;
@@ -568,7 +617,7 @@ static NSString* toBase64(NSData* data) {
         [GPSDictionary setObject:@"N" forKey:(NSString*)kCGImagePropertyGPSLatitudeRef];
     }
     [GPSDictionary setObject:[NSNumber numberWithFloat:latitude] forKey:(NSString*)kCGImagePropertyGPSLatitude];
-    
+
     // longitude
     if (longitude < 0.0) {
         longitude = longitude * -1.0f;
@@ -578,7 +627,7 @@ static NSString* toBase64(NSData* data) {
         [GPSDictionary setObject:@"E" forKey:(NSString*)kCGImagePropertyGPSLongitudeRef];
     }
     [GPSDictionary setObject:[NSNumber numberWithFloat:longitude] forKey:(NSString*)kCGImagePropertyGPSLongitude];
-    
+
     // altitude
     CGFloat altitude = newLocation.altitude;
     if (!isnan(altitude)){
@@ -590,7 +639,7 @@ static NSString* toBase64(NSData* data) {
         }
         [GPSDictionary setObject:[NSNumber numberWithFloat:altitude] forKey:(NSString *)kCGImagePropertyGPSAltitude];
     }
-    
+
     // Time and date
     NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
     [formatter setDateFormat:@"HH:mm:ss.SSSSSS"];
@@ -598,7 +647,7 @@ static NSString* toBase64(NSData* data) {
     [GPSDictionary setObject:[formatter stringFromDate:newLocation.timestamp] forKey:(NSString *)kCGImagePropertyGPSTimeStamp];
     [formatter setDateFormat:@"yyyy:MM:dd"];
     [GPSDictionary setObject:[formatter stringFromDate:newLocation.timestamp] forKey:(NSString *)kCGImagePropertyGPSDateStamp];
-    
+
     [self.metadata setObject:GPSDictionary forKey:(NSString *)kCGImagePropertyGPSDictionary];
     [self imagePickerControllerReturnImageResult];
 }
@@ -611,7 +660,7 @@ static NSString* toBase64(NSData* data) {
 
     [self.locationManager stopUpdatingLocation];
     self.locationManager = nil;
-    
+
     [self imagePickerControllerReturnImageResult];
 }
 
@@ -619,26 +668,26 @@ static NSString* toBase64(NSData* data) {
 {
     CDVPictureOptions* options = self.pickerController.pictureOptions;
     CDVPluginResult* result = nil;
-    
+
     if (self.metadata) {
         CGImageSourceRef sourceImage = CGImageSourceCreateWithData((__bridge CFDataRef)self.data, NULL);
         CFStringRef sourceType = CGImageSourceGetType(sourceImage);
-        
+
         CGImageDestinationRef destinationImage = CGImageDestinationCreateWithData((__bridge CFMutableDataRef)self.data, sourceType, 1, NULL);
         CGImageDestinationAddImageFromSource(destinationImage, sourceImage, 0, (__bridge CFDictionaryRef)self.metadata);
         CGImageDestinationFinalize(destinationImage);
-        
+
         CFRelease(sourceImage);
         CFRelease(destinationImage);
     }
-    
+
     switch (options.destinationType) {
         case DestinationTypeFileUri:
         {
             NSError* err = nil;
             NSString* extension = self.pickerController.pictureOptions.encodingType == EncodingTypePNG ? @"png":@"jpg";
             NSString* filePath = [self tempFilePath:extension];
-            
+
             // save file
             if (![self.data writeToFile:filePath options:NSAtomicWrite error:&err]) {
                 result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsString:[err localizedDescription]];
@@ -657,16 +706,16 @@ static NSString* toBase64(NSData* data) {
         default:
             break;
     };
-    
+
     if (result) {
         [self.commandDelegate sendPluginResult:result callbackId:self.pickerController.callbackId];
     }
-    
+
     self.hasPendingOperation = NO;
     self.pickerController = nil;
     self.data = nil;
     self.metadata = nil;
-    
+
     if (options.saveToPhotoAlbum) {
         ALAssetsLibrary *library = [ALAssetsLibrary new];
         [library writeImageDataToSavedPhotosAlbum:self.data metadata:self.metadata completionBlock:nil];
@@ -686,14 +735,14 @@ static NSString* toBase64(NSData* data) {
 {
     return nil;
 }
-    
+
 - (void)viewWillAppear:(BOOL)animated
 {
     SEL sel = NSSelectorFromString(@"setNeedsStatusBarAppearanceUpdate");
     if ([self respondsToSelector:sel]) {
         [self performSelector:sel withObject:nil afterDelay:0];
     }
-    
+
     [super viewWillAppear:animated];
 }
 
@@ -703,7 +752,7 @@ static NSString* toBase64(NSData* data) {
     cameraPicker.pictureOptions = pictureOptions;
     cameraPicker.sourceType = pictureOptions.sourceType;
     cameraPicker.allowsEditing = pictureOptions.allowsEditing;
-    
+
     if (cameraPicker.sourceType == UIImagePickerControllerSourceTypeCamera) {
         // We only allow taking pictures (no video) in this API.
         cameraPicker.mediaTypes = @[(NSString*)kUTTypeImage];
@@ -715,7 +764,7 @@ static NSString* toBase64(NSData* data) {
         NSArray* mediaArray = @[(NSString*)(pictureOptions.mediaType == MediaTypeVideo ? kUTTypeMovie : kUTTypeImage)];
         cameraPicker.mediaTypes = mediaArray;
     }
-    
+
     return cameraPicker;
 }
 

src/osx/CDVCamera.h

@@ -0,0 +1,81 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied.  See the License for the
+ specific language governing permissions and limitations
+ under the License.
+ */
+#import <Quartz/Quartz.h>
+#import <AppKit/AppKit.h>
+#import <Cordova/CDVPlugin.h>
+
+
+
+enum CDVDestinationType {
+    DestinationTypeDataUrl = 0,
+    DestinationTypeFileUri,
+    DestinationTypeNativeUri
+};
+typedef NSUInteger CDVDestinationType;
+
+enum CDVSourceType {
+    SourceTypePhotoLibrary = 0,
+    SourceTypeCamera,
+    SourceTypePhotoAlbum
+};
+typedef NSUInteger CDVSourceType;
+
+enum CDVEncodingType {
+    EncodingTypeJPEG = 0,
+    EncodingTypePNG
+};
+typedef NSUInteger CDVEncodingType;
+
+enum CDVMediaType {
+    MediaTypePicture = 0,
+    MediaTypeVideo,
+    MediaTypeAll
+};
+typedef NSUInteger CDVMediaType;
+
+
+// ======================================================================= //
+
+
+@interface CDVPictureOptions : NSObject
+
+@property (strong) NSNumber *quality;
+@property (assign) CDVDestinationType destinationType;
+@property (assign) CDVSourceType sourceType;
+@property (assign) CGSize targetSize;
+@property (assign) CDVEncodingType encodingType;
+@property (assign) CDVMediaType mediaType;
+@property (assign) BOOL allowsEditing;
+@property (assign) BOOL correctOrientation;
+@property (assign) BOOL saveToPhotoAlbum;
+
++ (instancetype) createFromTakePictureArguments:(CDVInvokedUrlCommand *)command;
+
+@end
+
+
+// ======================================================================= //
+
+
+@interface CDVCamera : CDVPlugin
+
+- (void)takePicture:(CDVInvokedUrlCommand *)command;
+- (void)cleanup:(CDVInvokedUrlCommand *)command;
+
+@end

src/osx/CDVCamera.m

@@ -0,0 +1,258 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied.  See the License for the
+ specific language governing permissions and limitations
+ under the License.
+ */
+#import "CDVCamera.h"
+
+
+@implementation CDVPictureOptions
+
++ (instancetype) createFromTakePictureArguments:(CDVInvokedUrlCommand*)command {
+    CDVPictureOptions *pictureOptions = [[CDVPictureOptions alloc] init];
+
+    pictureOptions.quality = [command argumentAtIndex:0 withDefault:@(50)];
+    pictureOptions.destinationType = [[command argumentAtIndex:1 withDefault:@(DestinationTypeFileUri)] unsignedIntegerValue];
+    pictureOptions.sourceType = [[command argumentAtIndex:2 withDefault:@(SourceTypeCamera)] unsignedIntegerValue];
+
+    NSNumber *targetWidth = [command argumentAtIndex:3 withDefault:nil];
+    NSNumber *targetHeight = [command argumentAtIndex:4 withDefault:nil];
+    pictureOptions.targetSize = CGSizeMake(0, 0);
+    if ((targetWidth != nil) && (targetHeight != nil)) {
+        pictureOptions.targetSize = CGSizeMake([targetWidth floatValue], [targetHeight floatValue]);
+    }
+
+    pictureOptions.encodingType = [[command argumentAtIndex:5 withDefault:@(EncodingTypeJPEG)] unsignedIntegerValue];
+    pictureOptions.mediaType = [[command argumentAtIndex:6 withDefault:@(MediaTypePicture)] unsignedIntegerValue];
+    pictureOptions.allowsEditing = [[command argumentAtIndex:7 withDefault:@(NO)] boolValue];
+    pictureOptions.correctOrientation = [[command argumentAtIndex:8 withDefault:@(NO)] boolValue];
+    pictureOptions.saveToPhotoAlbum = [[command argumentAtIndex:9 withDefault:@(NO)] boolValue];
+
+    return pictureOptions;
+}
+
+@end
+
+
+// ======================================================================= //
+
+
+@implementation CDVCamera
+
+/*!
+ Static array that stores the temporary created files allowing to delete them when calling navigator.camera.cleanup(...)
+ */
+static NSMutableArray *cleanUpFiles;
+
++ (void)initialize {
+    cleanUpFiles = [NSMutableArray array];
+}
+
+- (void)takePicture:(CDVInvokedUrlCommand *)command {
+    CDVPictureOptions *pictureOptions = [CDVPictureOptions createFromTakePictureArguments:command];
+    if (pictureOptions.sourceType == SourceTypeCamera) {
+        [self takePictureFromCamera:command withOptions:pictureOptions];
+    } else {
+        [self takePictureFromFile:command withOptions:pictureOptions];
+    }
+}
+
+- (void)cleanup:(CDVInvokedUrlCommand*)command {
+    [self.commandDelegate runInBackground:^{
+        if (cleanUpFiles.count > 0) {
+            for (int i=0; i<cleanUpFiles.count; i++) {
+                NSString *path = [cleanUpFiles objectAtIndex:i];
+                [[NSFileManager defaultManager] removeItemAtPath:path error:nil];
+            }
+
+            [cleanUpFiles removeAllObjects];
+
+            CDVPluginResult *result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK];
+            [self.commandDelegate sendPluginResult:result callbackId:command.callbackId];
+        }
+    }];
+}
+
+
+#pragma mark - Camera
+
+/*!
+ Takes a picture from the iSight camera using the default OS dialog.
+ @see https://developer.apple.com/documentation/quartz/ikpicturetaker
+ */
+- (void)takePictureFromCamera:(CDVInvokedUrlCommand *)command withOptions:(CDVPictureOptions *)pictureOptions {
+    IKPictureTaker *pictureTaker = [IKPictureTaker pictureTaker];
+    [pictureTaker setValue:[NSNumber numberWithBool:YES] forKey:IKPictureTakerAllowsVideoCaptureKey];
+    [pictureTaker setValue:[NSNumber numberWithBool:NO]  forKey:IKPictureTakerAllowsFileChoosingKey];
+    [pictureTaker setValue:[NSNumber numberWithBool:pictureOptions.allowsEditing] forKey:IKPictureTakerShowEffectsKey];
+    [pictureTaker setValue:[NSNumber numberWithBool:pictureOptions.allowsEditing] forKey:IKPictureTakerAllowsEditingKey];
+
+    NSDictionary *contextInfo = @{ @"command": command, @"pictureOptions" : pictureOptions};
+    [pictureTaker beginPictureTakerSheetForWindow:self.viewController.contentView.window withDelegate:self didEndSelector:@selector(pictureTakerDidEnd:returnCode:contextInfo:) contextInfo:(void *)CFBridgingRetain(contextInfo)];
+
+}
+
+- (void)pictureTakerDidEnd:(IKPictureTaker *)pictureTaker returnCode:(NSInteger)returnCode contextInfo:(void  *)contextInfo {
+    if (returnCode == NSOKButton) {
+        NSDictionary *contextInfoDictionary = (NSDictionary *)CFBridgingRelease(contextInfo);
+        CDVInvokedUrlCommand *command = [contextInfoDictionary valueForKey:@"command"];
+        CDVPictureOptions *pictureOptions = [contextInfoDictionary valueForKey:@"pictureOptions"];
+
+        [self returnImage:pictureTaker.outputImage command:command options:pictureOptions];
+    }
+}
+
+
+#pragma mark - File
+
+/*!
+ Allows to select an image or video using the system native dialog.
+ */
+- (void)takePictureFromFile:(CDVInvokedUrlCommand *)command withOptions:(CDVPictureOptions *)pictureOptions {
+    NSOpenPanel *openPanel = [NSOpenPanel openPanel];
+    openPanel.canChooseFiles = YES;
+    openPanel.canChooseDirectories = NO;
+    openPanel.canCreateDirectories = YES;
+    openPanel.allowsMultipleSelection = NO;
+
+    NSMutableArray *allowedTypes = [NSMutableArray array];
+    if (pictureOptions.mediaType == MediaTypePicture || pictureOptions.mediaType == MediaTypeAll) {
+        [allowedTypes addObjectsFromArray:[NSImage imageTypes]];
+    }
+    if (pictureOptions.mediaType == MediaTypeVideo || pictureOptions.mediaType == MediaTypeAll) {
+        [allowedTypes addObjectsFromArray:@[(NSString *)kUTTypeMovie]];
+    }
+    [openPanel setAllowedFileTypes:allowedTypes];
+
+    [openPanel beginSheetModalForWindow:self.viewController.contentView.window completionHandler:^(NSInteger result) {
+        if (result == NSOKButton) {
+            NSURL *fileURL = [openPanel.URLs objectAtIndex:0];
+
+            if ([self fileIsImage:fileURL]) {
+                NSImage *image = [[NSImage alloc] initWithContentsOfFile:fileURL.path];
+                [self returnImage:image command:command options:pictureOptions];
+            } else {
+                if (pictureOptions.destinationType == DestinationTypeDataUrl) {
+                    CDVPluginResult *result = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:@"Camera.DestinationType.DATA_URL is only available with image files"];
+                    [self.commandDelegate sendPluginResult:result callbackId:command.callbackId];
+                } else {
+                    [self returnUri:fileURL.path command:command options:pictureOptions];
+                }
+            }
+        }
+    }];
+}
+
+
+#pragma mark - Common
+
+/*!
+ Returns to JavaScript a URI.
+ Called when Camera.DestinationType.FILE_URI or Camera.DestinationType.NATIVE_URI.
+ */
+- (void)returnUri:(NSString *)path command:(CDVInvokedUrlCommand *)command options:(CDVPictureOptions *)pictureOptions {
+    NSString *protocol = (pictureOptions.destinationType == DestinationTypeFileUri) ? @"file://" : @"";
+    NSString *uri = [NSString stringWithFormat:@"%@%@", protocol, path];
+
+    CDVPluginResult *result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:uri];
+    [self.commandDelegate sendPluginResult:result callbackId:command.callbackId];
+}
+
+/*!
+ Returns to JavaScript a base64 encoded image.
+ Called when Camera.DestinationType.DATA_URL.
+ */
+- (void)returnImage:(NSImage *)image command:(CDVInvokedUrlCommand *)command options:(CDVPictureOptions *)pictureOptions {
+    [self.commandDelegate runInBackground:^{
+        NSData *processedImageData = [self processImage:image options:pictureOptions];
+
+        if (pictureOptions.destinationType == DestinationTypeDataUrl) {
+            CDVPluginResult *result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:[processedImageData base64EncodedStringWithOptions:NSDataBase64EncodingEndLineWithLineFeed]];
+            [self.commandDelegate sendPluginResult:result callbackId:command.callbackId];
+        } else {
+            NSString *tempFilePath = [self uniqueImageName:pictureOptions];
+            [processedImageData writeToFile:tempFilePath atomically:YES];
+            [cleanUpFiles addObject:tempFilePath];
+            [self returnUri:tempFilePath command:command options:pictureOptions];
+        }
+    }];
+
+}
+
+/*!
+ Top level method to apply the size and quality required changes to an image.
+ */
+- (NSData *)processImage:(NSImage *)image options:(CDVPictureOptions *)pictureOptions {
+    NSImage *sourceImage = image;
+    if (pictureOptions.targetSize.width > 0 && pictureOptions.targetSize.height > 0) {
+        sourceImage = [self resizeImage:sourceImage toSize:pictureOptions.targetSize];
+    }
+
+    CGImageRef cgRef = [sourceImage CGImageForProposedRect:NULL context:nil hints:nil];
+    NSBitmapImageRep *imageRepresentation = [[NSBitmapImageRep alloc] initWithCGImage:cgRef];
+
+    NSData *data = (pictureOptions.encodingType == EncodingTypeJPEG)
+    ? [imageRepresentation representationUsingType:NSJPEGFileType properties:@{NSImageCompressionFactor: [NSNumber numberWithFloat:pictureOptions.quality.floatValue/100.f]}]
+    : [imageRepresentation representationUsingType:NSPNGFileType  properties:@{NSImageCompressionFactor: @1.0}];
+
+    return data;
+}
+
+/*!
+ Auxiliar method to resize an image.
+ */
+- (NSImage *)resizeImage:(NSImage *)image toSize:(CGSize)newSize {
+    CGFloat aspectWidth  = newSize.width  / image.size.width;
+    CGFloat aspectHeight = newSize.height / image.size.height;
+    CGFloat aspectRatio  = MIN(aspectWidth, aspectHeight);
+
+    CGSize scaledSize = NSMakeSize(image.size.width*aspectRatio, image.size.height*aspectRatio);
+
+    NSImage *smallImage = [[NSImage alloc] initWithSize: scaledSize];
+    [smallImage lockFocus];
+    [image setSize: scaledSize];
+    [[NSGraphicsContext currentContext] setImageInterpolation:NSImageInterpolationHigh];
+    [image drawAtPoint:NSZeroPoint fromRect:CGRectMake(0, 0, scaledSize.width, scaledSize.height) operation:NSCompositeCopy fraction:1.0];
+    [smallImage unlockFocus];
+    return smallImage;
+}
+
+/*!
+ Auxiliar method to know if a given file is an image or not.
+ */
+- (BOOL)fileIsImage:(NSURL *)fileURL {
+    NSString *type;
+    BOOL isImage = NO;
+
+    if ([fileURL getResourceValue:&type forKey:NSURLTypeIdentifierKey error:nil]) {
+        isImage = [[NSImage imageTypes] containsObject:type];
+    }
+
+    return isImage;
+}
+
+/*!
+ Auxiliar method that generates an unique filename for an image in the temporary directory.
+ */
+- (NSString *)uniqueImageName:(CDVPictureOptions *)pictureOptions {
+    NSString *tempDir   = NSTemporaryDirectory();
+    NSString *guid      = [[NSProcessInfo processInfo] globallyUniqueString] ;
+    NSString *extension = (pictureOptions.encodingType == EncodingTypeJPEG) ? @"jpeg" : @"png";
+    NSString *uniqueFileName = [NSString stringWithFormat:@"%@%@.%@", tempDir, guid, extension];
+    return uniqueFileName;
+}
+
+@end

src/ubuntu/CaptureWidget.qml

@@ -1,118 +0,0 @@
-/*
- *
- * Copyright 2013 Canonical Ltd.
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
-*/
-import QtQuick 2.0
-import QtMultimedia 5.0
-
-Rectangle {
-    property string shootImagePath: "shoot.png"
-    function isSuffix(str, suffix) {
-        return String(str).substr(String(str).length - suffix.length) == suffix
-    }
-
-    id: ui
-    color: "#252423"
-    anchors.fill: parent
-
-    Camera {
-        objectName: "camera"
-        id: camera
-        onError: {
-            console.log(errorString);
-        }
-        videoRecorder.audioBitRate: 128000
-        imageCapture {
-            onImageSaved: {
-                root.exec("Camera", "onImageSaved", [path]);
-                ui.destroy();
-            }
-        }
-    }
-    VideoOutput {
-        id: output
-        source: camera
-        width: parent.width
-        height: parent.height
-    }
-
-    Item {
-        anchors.bottom: parent.bottom
-        width: parent.width
-        height: shootButton.height
-        BorderImage {
-            id: leftBackground
-            anchors.left: parent.left
-            anchors.top: parent.top
-            anchors.bottom: parent.bottom
-            anchors.right: middle.left
-            anchors.topMargin: units.dp(2)
-            anchors.bottomMargin: units.dp(2)
-            source: "toolbar-left.png"
-            Image {
-                anchors.verticalCenter: parent.verticalCenter
-                anchors.left: parent.left
-                anchors.leftMargin: parent.iconSpacing
-                source: "back.png"
-                width: units.gu(6)
-                height: units.gu(5)
-                MouseArea {
-                    anchors.fill: parent
-                    onClicked: {
-                        root.exec("Camera", "cancel");
-                    }
-                }
-            }
-        }
-        BorderImage {
-            id: middle
-            anchors.top: parent.top
-            anchors.bottom: parent.bottom
-            anchors.horizontalCenter: parent.horizontalCenter
-            height: shootButton.height + units.gu(1)
-            width: shootButton.width
-            source: "toolbar-middle.png"
-            Image {
-                id: shootButton
-                width: units.gu(8)
-                height: width
-                anchors.horizontalCenter: parent.horizontalCenter
-                source: shootImagePath
-                MouseArea {
-                    anchors.fill: parent
-                    onClicked: {
-                        camera.imageCapture.captureToLocation(ui.parent.plugin('Camera').generateLocation("jpg"));
-                    }
-                }
-            }
-        }
-        BorderImage {
-            id: rightBackground
-            anchors.right: parent.right
-            anchors.top: parent.top
-            anchors.bottom: parent.bottom
-            anchors.left: middle.right
-            anchors.topMargin: units.dp(2)
-            anchors.bottomMargin: units.dp(2)
-            source: "toolbar-right.png"
-        }
-    }
-}

src/ubuntu/camera.cpp

@@ -1,140 +0,0 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
-*/
-
-#include "camera.h"
-#include <cordova.h>
-
-#include <QCameraViewfinder>
-#include <QCameraImageCapture>
-#include <QGraphicsObject>
-#include <QCloseEvent>
-#include <QQuickItem>
-
-const char code[] = "\
-var component, object;                                                  \
-function createObject() {                                               \
-    component = Qt.createComponent(%1);                                 \
-    if (component.status == Component.Ready)                            \
-        finishCreation();                                               \
-    else                                                                \
-        component.statusChanged.connect(finishCreation);                \
-}                                                                       \
-function finishCreation() {                                             \
-    CordovaWrapper.global.cameraPluginWidget = component.createObject(root, \
-        {root: root, cordova: cordova});                                \
-}                                                                       \
-createObject()";
-
-
-Camera::Camera(Cordova *cordova):
-    CPlugin(cordova),
-    _lastScId(0),
-    _lastEcId(0) {
-}
-
-bool Camera::preprocessImage(QString &path) {
-    bool convertToPNG = (*_options.find("encodingType")).toInt() == Camera::PNG;
-    int quality = (*_options.find("quality")).toInt();
-    int width = (*_options.find("targetWidth")).toInt();
-    int height = (*_options.find("targetHeight")).toInt();
-
-    QImage image(path);
-    if (width <= 0)
-        width = image.width();
-    if (height <= 0)
-        height = image.height();
-    image = image.scaled(width, height, Qt::KeepAspectRatio, Qt::SmoothTransformation);
-
-    QFile oldImage(path);
-    QTemporaryFile newImage;
-
-    const char *type;
-    if (convertToPNG) {
-        path = generateLocation("png");
-        type = "png";
-    } else {
-        path = generateLocation("jpg");
-        type = "jpg";
-    }
-
-    image.save(path, type, quality);
-
-    oldImage.remove();
-
-    return true;
-}
-
-void Camera::onImageSaved(QString path) {
-    bool dataURL = _options.find("destinationType")->toInt() == Camera::DATA_URL;
-
-    QString cbParams;
-    if (preprocessImage(path)) {
-        QString absolutePath = QFileInfo(path).absoluteFilePath();
-        if (dataURL) {
-            QFile image(absolutePath);
-            image.open(QIODevice::ReadOnly);
-            QByteArray content = image.readAll().toBase64();
-            cbParams = QString("\"%1\"").arg(content.data());
-            image.remove();
-        } else {
-            cbParams = CordovaInternal::format(QString("file://localhost") + absolutePath);
-        }
-    }
-
-    this->callback(_lastScId, cbParams);
-
-    _lastEcId = _lastScId = 0;
-}
-
-void Camera::takePicture(int scId, int ecId, int quality, int destinationType, int/*sourceType*/, int targetWidth, int targetHeight, int encodingType,
-                         int/*mediaType*/, bool/*allowEdit*/, bool/*correctOrientation*/, bool/*saveToPhotoAlbum*/, const QVariantMap &/*popoverOptions*/, int/*cameraDirection*/) {
-    if (_camera.isNull()) {
-        _camera = QSharedPointer<QCamera>(new QCamera());
-    }
-
-    if (((_lastScId || _lastEcId) && (_lastScId != scId && _lastEcId != ecId)) || !_camera->isAvailable() || _camera->lockStatus() != QCamera::Unlocked) {
-        this->cb(_lastEcId, "Device is busy");
-        return;
-    }
-
-    _options.clear();
-    _options.insert("quality", quality);
-    _options.insert("destinationType", destinationType);
-    _options.insert("targetWidth", targetWidth);
-    _options.insert("targetHeight", targetHeight);
-    _options.insert("encodingType", encodingType);
-
-    _lastScId = scId;
-    _lastEcId = ecId;
-
-    QString path = m_cordova->get_app_dir() + "/../qml/CaptureWidget.qml";
-
-    // TODO: relative url
-    QString qml = QString(code).arg(CordovaInternal::format(path));
-    m_cordova->execQML(qml);
-}
-
-void Camera::cancel() {
-    m_cordova->execQML("CordovaWrapper.global.cameraPluginWidget.destroy()");
-    this->cb(_lastEcId, "canceled");
-
-    _lastEcId = _lastScId = 0;
-}

src/ubuntu/camera.h

@@ -1,86 +0,0 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
-*/
-
-#ifndef CAMERA_H
-#define CAMERA_H
-
-#include <cplugin.h>
-
-#include <QtCore>
-#include <QQuickView>
-#include <QCamera>
-#include <QtMultimediaWidgets/QCameraViewfinder>
-#include <QCameraImageCapture>
-
-class Camera: public CPlugin {
-    Q_OBJECT
-public:
-    explicit Camera(Cordova *cordova);
-
-    virtual const QString fullName() override {
-        return Camera::fullID();
-    }
-
-    virtual const QString shortName() override {
-        return "Camera";
-    }
-
-    static const QString fullID() {
-        return "Camera";
-    }
-
-public slots:
-    void takePicture(int scId, int ecId, int quality, int destinationType, int/*sourceType*/, int targetWidth, int targetHeight, int encodingType,
-                     int/*mediaType*/, bool/*allowEdit*/, bool/*correctOrientation*/, bool/*saveToPhotoAlbum*/, const QVariantMap &popoverOptions, int cameraDirection);
-    void cancel();
-
-    void onImageSaved(QString path);
-
-    QString generateLocation(const QString &extension) {
-        int i = 1;
-        for (;;++i) {
-            QString path = QString("%1/.local/share/%2/persistent/%3.%4").arg(QDir::homePath())
-                .arg(QCoreApplication::applicationName()).arg(i).arg(extension);
-
-            if (!QFileInfo(path).exists())
-                return path;
-        }
-    }
-private:
-    bool preprocessImage(QString &path);
-
-    int _lastScId;
-    int _lastEcId;
-    QSharedPointer<QCamera> _camera;
-
-    QVariantMap _options;
-protected:
-    enum DestinationType {
-        DATA_URL = 0,
-        FILE_URI = 1
-    };
-    enum EncodingType {
-        JPEG = 0,
-        PNG = 1
-    };
-};
-
-#endif // CAMERA_H

src/windows/CameraProxy.js

@@ -19,13 +19,10 @@
  *
 */
 
-/*jshint unused:true, undef:true, browser:true */
-/*global Windows:true, URL:true, module:true, require:true */
-
+/* global Windows:true, URL:true, module:true, require:true, WinJS:true */
 
 var Camera = require('./Camera');
 
-
 var getAppData = function () {
     return Windows.Storage.ApplicationData.current;
 };
@@ -58,7 +55,7 @@ module.exports = {
     takePicture: function (successCallback, errorCallback, args) {
         var sourceType = args[2];
 
-        if (sourceType != Camera.PictureSourceType.CAMERA) {
+        if (sourceType !== Camera.PictureSourceType.CAMERA) {
             takePictureFromFile(successCallback, errorCallback, args);
         } else {
             takePictureFromCamera(successCallback, errorCallback, args);
@@ -67,19 +64,26 @@ module.exports = {
 };
 
 // https://msdn.microsoft.com/en-us/library/windows/apps/ff462087(v=vs.105).aspx
-var windowsVideoContainers = [".avi", ".flv", ".asx", ".asf", ".mov", ".mp4", ".mpg", ".rm", ".srt", ".swf", ".wmv", ".vob"];
-var windowsPhoneVideoContainers =  [".avi", ".3gp", ".3g2", ".wmv", ".3gp", ".3g2", ".mp4", ".m4v"];
+var windowsVideoContainers = ['.avi', '.flv', '.asx', '.asf', '.mov', '.mp4', '.mpg', '.rm', '.srt', '.swf', '.wmv', '.vob'];
+var windowsPhoneVideoContainers = ['.avi', '.3gp', '.3g2', '.wmv', '.3gp', '.3g2', '.mp4', '.m4v'];
 
 // Default aspect ratio 1.78 (16:9 hd video standard)
 var DEFAULT_ASPECT_RATIO = '1.8';
 
+// Highest possible z-index supported across browsers. Anything used above is converted to this value.
+var HIGHEST_POSSIBLE_Z_INDEX = 2147483647;
+
 // Resize method
-function resizeImage(successCallback, errorCallback, file, targetWidth, targetHeight, encodingType) {
-    var tempPhotoFileName = "";
-    if (encodingType == Camera.EncodingType.PNG) {
-        tempPhotoFileName = "camera_cordova_temp_return.png";
+function resizeImage (successCallback, errorCallback, file, targetWidth, targetHeight, encodingType) {
+    var tempPhotoFileName = '';
+    var targetContentType = '';
+
+    if (encodingType === Camera.EncodingType.PNG) {
+        tempPhotoFileName = 'camera_cordova_temp_return.png';
+        targetContentType = 'image/png';
     } else {
-        tempPhotoFileName = "camera_cordova_temp_return.jpg";
+        tempPhotoFileName = 'camera_cordova_temp_return.jpg';
+        targetContentType = 'image/jpeg';
     }
 
     var storageFolder = getAppData().localFolder;
@@ -87,23 +91,25 @@ function resizeImage(successCallback, errorCallback, file, targetWidth, targetHe
         .then(function (storageFile) {
             return fileIO.readBufferAsync(storageFile);
         })
-        .then(function(buffer) {
+        .then(function (buffer) {
             var strBase64 = encodeToBase64String(buffer);
-            var imageData = "data:" + file.contentType + ";base64," + strBase64;
-            var image = new Image();
+            var imageData = 'data:' + file.contentType + ';base64,' + strBase64;
+            var image = new Image(); /* eslint no-undef : 0 */
             image.src = imageData;
-            image.onload = function() {
-                var imageWidth = targetWidth,
-                    imageHeight = targetHeight;
+            image.onload = function () {
+                var ratio = Math.min(targetWidth / this.width, targetHeight / this.height);
+                var imageWidth = ratio * this.width;
+                var imageHeight = ratio * this.height;
+
                 var canvas = document.createElement('canvas');
                 var storageFileName;
 
                 canvas.width = imageWidth;
                 canvas.height = imageHeight;
 
-                canvas.getContext("2d").drawImage(this, 0, 0, imageWidth, imageHeight);
+                canvas.getContext('2d').drawImage(this, 0, 0, imageWidth, imageHeight);
 
-                var fileContent = canvas.toDataURL(file.contentType).split(',')[1];
+                var fileContent = canvas.toDataURL(targetContentType).split(',')[1];
 
                 var storageFolder = getAppData().localFolder;
 
@@ -114,48 +120,48 @@ function resizeImage(successCallback, errorCallback, file, targetWidth, targetHe
                         return fileIO.writeBufferAsync(storagefile, content);
                     })
                     .done(function () {
-                        successCallback("ms-appdata:///local/" + storageFileName);
+                        successCallback('ms-appdata:///local/' + storageFileName);
                     }, errorCallback);
             };
         })
-        .done(null, function(err) {
+        .done(null, function (err) {
             errorCallback(err);
-        }
-    );
+        });
 }
 
 // Because of asynchronous method, so let the successCallback be called in it.
-function resizeImageBase64(successCallback, errorCallback, file, targetWidth, targetHeight) {
-    fileIO.readBufferAsync(file).done( function(buffer) {
+function resizeImageBase64 (successCallback, errorCallback, file, targetWidth, targetHeight) {
+    fileIO.readBufferAsync(file).done(function (buffer) {
         var strBase64 = encodeToBase64String(buffer);
-        var imageData = "data:" + file.contentType + ";base64," + strBase64;
+        var imageData = 'data:' + file.contentType + ';base64,' + strBase64;
 
-        var image = new Image();
+        var image = new Image(); /* eslint no-undef : 0 */
         image.src = imageData;
 
-        image.onload = function() {
-            var imageWidth = targetWidth,
-                imageHeight = targetHeight;
+        image.onload = function () {
+            var ratio = Math.min(targetWidth / this.width, targetHeight / this.height);
+            var imageWidth = ratio * this.width;
+            var imageHeight = ratio * this.height;
             var canvas = document.createElement('canvas');
 
             canvas.width = imageWidth;
             canvas.height = imageHeight;
 
-            var ctx = canvas.getContext("2d");
+            var ctx = canvas.getContext('2d');
             ctx.drawImage(this, 0, 0, imageWidth, imageHeight);
 
             // The resized file ready for upload
             var finalFile = canvas.toDataURL(file.contentType);
 
             // Remove the prefix such as "data:" + contentType + ";base64," , in order to meet the Cordova API.
-            var arr = finalFile.split(",");
+            var arr = finalFile.split(',');
             var newStr = finalFile.substr(arr[0].length + 1);
             successCallback(newStr);
         };
-    }, function(err) { errorCallback(err); });
+    }, function (err) { errorCallback(err); });
 }
 
-function takePictureFromFile(successCallback, errorCallback, args) {
+function takePictureFromFile (successCallback, errorCallback, args) {
     // Detect Windows Phone
     if (navigator.appVersion.indexOf('Windows Phone 8.1') >= 0) {
         takePictureFromFileWP(successCallback, errorCallback, args);
@@ -164,94 +170,87 @@ function takePictureFromFile(successCallback, errorCallback, args) {
     }
 }
 
-function takePictureFromFileWP(successCallback, errorCallback, args) {
-    var mediaType = args[6],
-        destinationType = args[1],
-        targetWidth = args[3],
-        targetHeight = args[4],
-        encodingType = args[5];
+function takePictureFromFileWP (successCallback, errorCallback, args) {
+    var mediaType = args[6];
+    var destinationType = args[1];
+    var targetWidth = args[3];
+    var targetHeight = args[4];
+    var encodingType = args[5];
 
     /*
         Need to add and remove an event listener to catch activation state
         Using FileOpenPicker will suspend the app and it's required to catch the PickSingleFileAndContinue
         https://msdn.microsoft.com/en-us/library/windows/apps/xaml/dn631755.aspx
     */
-    var filePickerActivationHandler = function(eventArgs) {
+    var filePickerActivationHandler = function (eventArgs) {
         if (eventArgs.kind === Windows.ApplicationModel.Activation.ActivationKind.pickFileContinuation) {
             var file = eventArgs.files[0];
             if (!file) {
                 errorCallback("User didn't choose a file.");
-                webUIApp.removeEventListener("activated", filePickerActivationHandler);
+                webUIApp.removeEventListener('activated', filePickerActivationHandler);
                 return;
             }
-            if (destinationType == Camera.DestinationType.FILE_URI || destinationType == Camera.DestinationType.NATIVE_URI) {
+            if (destinationType === Camera.DestinationType.FILE_URI || destinationType === Camera.DestinationType.NATIVE_URI) {
                 if (targetHeight > 0 && targetWidth > 0) {
                     resizeImage(successCallback, errorCallback, file, targetWidth, targetHeight, encodingType);
-                }
-                else {
+                } else {
                     var storageFolder = getAppData().localFolder;
                     file.copyAsync(storageFolder, file.name, Windows.Storage.NameCollisionOption.replaceExisting).done(function (storageFile) {
-                        if(destinationType == Camera.DestinationType.NATIVE_URI) {
-                            successCallback("ms-appdata:///local/" + storageFile.name);
-                        }
-                        else {
+                        if (destinationType === Camera.DestinationType.NATIVE_URI) {
+                            successCallback('ms-appdata:///local/' + storageFile.name);
+                        } else {
                             successCallback(URL.createObjectURL(storageFile));
                         }
                     }, function () {
                         errorCallback("Can't access localStorage folder.");
                     });
                 }
-            }
-            else {
+            } else {
                 if (targetHeight > 0 && targetWidth > 0) {
                     resizeImageBase64(successCallback, errorCallback, file, targetWidth, targetHeight);
                 } else {
                     fileIO.readBufferAsync(file).done(function (buffer) {
-                        var strBase64 =encodeToBase64String(buffer);
+                        var strBase64 = encodeToBase64String(buffer);
                         successCallback(strBase64);
                     }, errorCallback);
                 }
             }
-            webUIApp.removeEventListener("activated", filePickerActivationHandler);
+            webUIApp.removeEventListener('activated', filePickerActivationHandler);
         }
     };
 
     var fileOpenPicker = new Windows.Storage.Pickers.FileOpenPicker();
-    if (mediaType == Camera.MediaType.PICTURE) {
-        fileOpenPicker.fileTypeFilter.replaceAll([".png", ".jpg", ".jpeg"]);
+    if (mediaType === Camera.MediaType.PICTURE) {
+        fileOpenPicker.fileTypeFilter.replaceAll(['.png', '.jpg', '.jpeg']);
         fileOpenPicker.suggestedStartLocation = pickerLocId.picturesLibrary;
-    }
-    else if (mediaType == Camera.MediaType.VIDEO) {
+    } else if (mediaType === Camera.MediaType.VIDEO) {
         fileOpenPicker.fileTypeFilter.replaceAll(windowsPhoneVideoContainers);
         fileOpenPicker.suggestedStartLocation = pickerLocId.videosLibrary;
-    }
-    else {
-        fileOpenPicker.fileTypeFilter.replaceAll(["*"]);
+    } else {
+        fileOpenPicker.fileTypeFilter.replaceAll(['*']);
         fileOpenPicker.suggestedStartLocation = pickerLocId.documentsLibrary;
     }
 
-    webUIApp.addEventListener("activated", filePickerActivationHandler);
+    webUIApp.addEventListener('activated', filePickerActivationHandler);
     fileOpenPicker.pickSingleFileAndContinue();
 }
 
-function takePictureFromFileWindows(successCallback, errorCallback, args) {
-    var mediaType = args[6],
-        destinationType = args[1],
-        targetWidth = args[3],
-        targetHeight = args[4],
-        encodingType = args[5];
+function takePictureFromFileWindows (successCallback, errorCallback, args) {
+    var mediaType = args[6];
+    var destinationType = args[1];
+    var targetWidth = args[3];
+    var targetHeight = args[4];
+    var encodingType = args[5];
 
     var fileOpenPicker = new Windows.Storage.Pickers.FileOpenPicker();
-    if (mediaType == Camera.MediaType.PICTURE) {
-        fileOpenPicker.fileTypeFilter.replaceAll([".png", ".jpg", ".jpeg"]);
+    if (mediaType === Camera.MediaType.PICTURE) {
+        fileOpenPicker.fileTypeFilter.replaceAll(['.png', '.jpg', '.jpeg']);
         fileOpenPicker.suggestedStartLocation = pickerLocId.picturesLibrary;
-    }
-    else if (mediaType == Camera.MediaType.VIDEO) {
+    } else if (mediaType === Camera.MediaType.VIDEO) {
         fileOpenPicker.fileTypeFilter.replaceAll(windowsVideoContainers);
         fileOpenPicker.suggestedStartLocation = pickerLocId.videosLibrary;
-    }
-    else {
-        fileOpenPicker.fileTypeFilter.replaceAll(["*"]);
+    } else {
+        fileOpenPicker.fileTypeFilter.replaceAll(['*']);
         fileOpenPicker.suggestedStartLocation = pickerLocId.documentsLibrary;
     }
 
@@ -260,25 +259,27 @@ function takePictureFromFileWindows(successCallback, errorCallback, args) {
             errorCallback("User didn't choose a file.");
             return;
         }
-        if (destinationType == Camera.DestinationType.FILE_URI || destinationType == Camera.DestinationType.NATIVE_URI) {
+        if (destinationType === Camera.DestinationType.FILE_URI || destinationType === Camera.DestinationType.NATIVE_URI) {
             if (targetHeight > 0 && targetWidth > 0) {
                 resizeImage(successCallback, errorCallback, file, targetWidth, targetHeight, encodingType);
-            }
-            else {
+            } else {
                 var storageFolder = getAppData().localFolder;
                 file.copyAsync(storageFolder, file.name, Windows.Storage.NameCollisionOption.replaceExisting).done(function (storageFile) {
-                    successCallback(URL.createObjectURL(storageFile));
+                    if (destinationType === Camera.DestinationType.NATIVE_URI) {
+                        successCallback('ms-appdata:///local/' + storageFile.name);
+                    } else {
+                        successCallback(URL.createObjectURL(storageFile));
+                    }
                 }, function () {
                     errorCallback("Can't access localStorage folder.");
                 });
             }
-        }
-        else {
+        } else {
             if (targetHeight > 0 && targetWidth > 0) {
                 resizeImageBase64(successCallback, errorCallback, file, targetWidth, targetHeight);
             } else {
                 fileIO.readBufferAsync(file).done(function (buffer) {
-                    var strBase64 =encodeToBase64String(buffer);
+                    var strBase64 = encodeToBase64String(buffer);
                     successCallback(strBase64);
                 }, errorCallback);
             }
@@ -288,7 +289,7 @@ function takePictureFromFileWindows(successCallback, errorCallback, args) {
     });
 }
 
-function takePictureFromCamera(successCallback, errorCallback, args) {
+function takePictureFromCamera (successCallback, errorCallback, args) {
     // Check if necessary API available
     if (!Windows.Media.Capture.CameraCaptureUI) {
         takePictureFromCameraWP(successCallback, errorCallback, args);
@@ -297,47 +298,65 @@ function takePictureFromCamera(successCallback, errorCallback, args) {
     }
 }
 
-function takePictureFromCameraWP(successCallback, errorCallback, args) {
+function takePictureFromCameraWP (successCallback, errorCallback, args) {
     // We are running on WP8.1 which lacks CameraCaptureUI class
     // so we need to use MediaCapture class instead and implement custom UI for camera
-    var destinationType = args[1],
-        targetWidth = args[3],
-        targetHeight = args[4],
-        encodingType = args[5],
-        saveToPhotoAlbum = args[9],
-        cameraDirection = args[11],
-        capturePreview = null,
-        captureCancelButton = null,
-        capture = null,
-        captureSettings = null,
-        CaptureNS = Windows.Media.Capture,
-        sensor = null;
+    var destinationType = args[1];
+    var targetWidth = args[3];
+    var targetHeight = args[4];
+    var encodingType = args[5];
+    var saveToPhotoAlbum = args[9];
+    var cameraDirection = args[11];
+    var capturePreview = null;
+    var cameraCaptureButton = null;
+    var cameraCancelButton = null;
+    var capture = null;
+    var captureSettings = null;
+    var CaptureNS = Windows.Media.Capture;
+    var sensor = null;
+
+    function createCameraUI () {
+        // create style for take and cancel buttons
+        var buttonStyle = 'width:45%;padding: 10px 16px;font-size: 18px;line-height: 1.3333333;color: #333;background-color: #fff;border-color: #ccc; border: 1px solid transparent;border-radius: 6px; display: block; margin: 20px; z-index: 1000;border-color: #adadad;';
 
-    var createCameraUI = function () {
         // Create fullscreen preview
-        capturePreview = document.createElement("video");
-
-        // z-order style element for capturePreview and captureCancelButton elts
+        // z-order style element for capturePreview and cameraCancelButton elts
         // is necessary to avoid overriding by another page elements, -1 sometimes is not enough
-        capturePreview.style.cssText = "position: fixed; left: 0; top: 0; width: 100%; height: 100%; z-index: 999";
+        capturePreview = document.createElement('video');
+        capturePreview.style.cssText = 'position: fixed; left: 0; top: 0; width: 100%; height: 100%; z-index: ' + (HIGHEST_POSSIBLE_Z_INDEX - 1) + ';';
+
+        // Create capture button
+        cameraCaptureButton = document.createElement('button');
+        cameraCaptureButton.innerText = 'Take';
+        cameraCaptureButton.style.cssText = buttonStyle + 'position: fixed; left: 0; bottom: 0; margin: 20px; z-index: ' + HIGHEST_POSSIBLE_Z_INDEX + ';';
 
         // Create cancel button
-        captureCancelButton = document.createElement("button");
-        captureCancelButton.innerText = "Cancel";
-        captureCancelButton.style.cssText = "position: fixed; right: 0; bottom: 0; display: block; margin: 20px; z-index: 1000";
+        cameraCancelButton = document.createElement('button');
+        cameraCancelButton.innerText = 'Cancel';
+        cameraCancelButton.style.cssText = buttonStyle + 'position: fixed; right: 0; bottom: 0; margin: 20px; z-index: ' + HIGHEST_POSSIBLE_Z_INDEX + ';';
 
         capture = new CaptureNS.MediaCapture();
 
         captureSettings = new CaptureNS.MediaCaptureInitializationSettings();
         captureSettings.streamingCaptureMode = CaptureNS.StreamingCaptureMode.video;
-    };
+    }
 
-    var startCameraPreview = function () {
+    function continueVideoOnFocus () {
+        // if preview is defined it would be stuck, play it
+        if (capturePreview) {
+            capturePreview.play();
+        }
+    }
+
+    function startCameraPreview () {
         // Search for available camera devices
         // This is necessary to detect which camera (front or back) we should use
         var DeviceEnum = Windows.Devices.Enumeration;
         var expectedPanel = cameraDirection === 1 ? DeviceEnum.Panel.front : DeviceEnum.Panel.back;
 
+        // Add focus event handler to capture the event when user suspends the app and comes back while the preview is on
+        window.addEventListener('focus', continueVideoOnFocus);
+
         DeviceEnum.DeviceInformation.findAllAsync(DeviceEnum.DeviceClass.videoCapture).then(function (devices) {
             if (devices.length <= 0) {
                 destroyCameraPreview();
@@ -345,8 +364,8 @@ function takePictureFromCameraWP(successCallback, errorCallback, args) {
                 return;
             }
 
-            devices.forEach(function(currDev) {
-                if (currDev.enclosureLocation.panel && currDev.enclosureLocation.panel == expectedPanel) {
+            devices.forEach(function (currDev) {
+                if (currDev.enclosureLocation.panel && currDev.enclosureLocation.panel === expectedPanel) {
                     captureSettings.videoDeviceId = currDev.id;
                 }
             });
@@ -355,6 +374,28 @@ function takePictureFromCameraWP(successCallback, errorCallback, args) {
 
             return capture.initializeAsync(captureSettings);
         }).then(function () {
+
+            // create focus control if available
+            var VideoDeviceController = capture.videoDeviceController;
+            var FocusControl = VideoDeviceController.focusControl;
+
+            if (FocusControl.supported === true) {
+                capturePreview.addEventListener('click', function () {
+                    // Make sure function isn't called again before previous focus is completed
+                    if (this.getAttribute('clicked') === '1') {
+                        return false;
+                    } else {
+                        this.setAttribute('clicked', '1');
+                    }
+                    var preset = Windows.Media.Devices.FocusPreset.autoNormal;
+                    var parent = this;
+                    FocusControl.setPresetAsync(preset).done(function () {
+                        // set the clicked attribute back to '0' to allow focus again
+                        parent.setAttribute('clicked', '0');
+                    });
+                });
+            }
+
             // msdn.microsoft.com/en-us/library/windows/apps/hh452807.aspx
             capturePreview.msZoom = true;
             capturePreview.src = URL.createObjectURL(capture);
@@ -363,13 +404,12 @@ function takePictureFromCameraWP(successCallback, errorCallback, args) {
             // Bind events to controls
             sensor = Windows.Devices.Sensors.SimpleOrientationSensor.getDefault();
             if (sensor !== null) {
-                sensor.addEventListener("orientationchanged", onOrientationChange);
+                sensor.addEventListener('orientationchanged', onOrientationChange);
             }
-            capturePreview.addEventListener('click', captureAction);
-            captureCancelButton.addEventListener('click', function () {
-                destroyCameraPreview();
-                errorCallback('Cancelled');
-            }, false);
+
+            // add click events to capture and cancel buttons
+            cameraCaptureButton.addEventListener('click', onCameraCaptureButtonClick);
+            cameraCancelButton.addEventListener('click', onCameraCancelButtonClick);
 
             // Change default orientation
             if (sensor) {
@@ -388,9 +428,10 @@ function takePictureFromCameraWP(successCallback, errorCallback, args) {
                 return;
             }
 
-            // Insert preview frame and controls into page
+            // add elements to body
             document.body.appendChild(capturePreview);
-            document.body.appendChild(captureCancelButton);
+            document.body.appendChild(cameraCaptureButton);
+            document.body.appendChild(cameraCancelButton);
 
             if (aspectRatios.indexOf(DEFAULT_ASPECT_RATIO) > -1) {
                 return setAspectRatio(capture, DEFAULT_ASPECT_RATIO);
@@ -402,32 +443,46 @@ function takePictureFromCameraWP(successCallback, errorCallback, args) {
             destroyCameraPreview();
             errorCallback('Camera intitialization error ' + err);
         });
-    };
+    }
 
-    var destroyCameraPreview = function () {
+    function destroyCameraPreview () {
+        // If sensor is available, remove event listener
         if (sensor !== null) {
             sensor.removeEventListener('orientationchanged', onOrientationChange);
         }
+
+        // Pause and dispose preview element
         capturePreview.pause();
         capturePreview.src = null;
-        [capturePreview, captureCancelButton].forEach(function(elem) {
+
+        // Remove event listeners from buttons
+        cameraCaptureButton.removeEventListener('click', onCameraCaptureButtonClick);
+        cameraCancelButton.removeEventListener('click', onCameraCancelButtonClick);
+
+        // Remove the focus event handler
+        window.removeEventListener('focus', continueVideoOnFocus);
+
+        // Remove elements
+        [capturePreview, cameraCaptureButton, cameraCancelButton].forEach(function (elem) {
             if (elem /* && elem in document.body.childNodes */) {
                 document.body.removeChild(elem);
             }
         });
+
+        // Stop and dispose media capture manager
         if (capture) {
             capture.stopRecordAsync();
             capture = null;
         }
-    };
+    }
 
-    var captureAction = function () {
+    function captureAction () {
 
-        var encodingProperties,
-            fileName,
-            tempFolder = getAppData().temporaryFolder;
+        var encodingProperties;
+        var fileName;
+        var tempFolder = getAppData().temporaryFolder;
 
-        if (encodingType == Camera.EncodingType.PNG) {
+        if (encodingType === Camera.EncodingType.PNG) {
             fileName = 'photo.png';
             encodingProperties = Windows.Media.MediaProperties.ImageEncodingProperties.createPng();
         } else {
@@ -436,41 +491,41 @@ function takePictureFromCameraWP(successCallback, errorCallback, args) {
         }
 
         tempFolder.createFileAsync(fileName, OptUnique)
-            .then(function(tempCapturedFile) {
+            .then(function (tempCapturedFile) {
                 return new WinJS.Promise(function (complete) {
                     var photoStream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
                     var finalStream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
                     capture.capturePhotoToStreamAsync(encodingProperties, photoStream)
-                    .then(function() {
-                        return Windows.Graphics.Imaging.BitmapDecoder.createAsync(photoStream);
-                    })
-                    .then(function(dec) {
-                        finalStream.size = 0; // BitmapEncoder requires the output stream to be empty
-                        return Windows.Graphics.Imaging.BitmapEncoder.createForTranscodingAsync(finalStream, dec);
-                    })
-                    .then(function(enc) {
-                        // We need to rotate the photo wrt sensor orientation
-                        enc.bitmapTransform.rotation = orientationToRotation(sensor.getCurrentOrientation());
-                        return enc.flushAsync();
-                    })
-                    .then(function() {
-                        return tempCapturedFile.openAsync(Windows.Storage.FileAccessMode.readWrite);
-                    })
-                    .then(function(fileStream) {
-                        return Windows.Storage.Streams.RandomAccessStream.copyAsync(finalStream, fileStream);
-                    })
-                    .done(function() {
-                        photoStream.close();
-                        finalStream.close();
-                        complete(tempCapturedFile);
-                    }, function() {
-                        photoStream.close();
-                        finalStream.close();
-                        throw new Error("An error has occured while capturing the photo.");
-                    });
+                        .then(function () {
+                            return Windows.Graphics.Imaging.BitmapDecoder.createAsync(photoStream);
+                        })
+                        .then(function (dec) {
+                            finalStream.size = 0; // BitmapEncoder requires the output stream to be empty
+                            return Windows.Graphics.Imaging.BitmapEncoder.createForTranscodingAsync(finalStream, dec);
+                        })
+                        .then(function (enc) {
+                            // We need to rotate the photo wrt sensor orientation
+                            enc.bitmapTransform.rotation = orientationToRotation(sensor.getCurrentOrientation());
+                            return enc.flushAsync();
+                        })
+                        .then(function () {
+                            return tempCapturedFile.openAsync(Windows.Storage.FileAccessMode.readWrite);
+                        })
+                        .then(function (fileStream) {
+                            return Windows.Storage.Streams.RandomAccessStream.copyAndCloseAsync(finalStream, fileStream);
+                        })
+                        .done(function () {
+                            photoStream.close();
+                            finalStream.close();
+                            complete(tempCapturedFile);
+                        }, function () {
+                            photoStream.close();
+                            finalStream.close();
+                            throw new Error('An error has occured while capturing the photo.');
+                        });
                 });
             })
-            .done(function(capturedFile) {
+            .done(function (capturedFile) {
                 destroyCameraPreview();
                 savePhoto(capturedFile, {
                     destinationType: destinationType,
@@ -479,13 +534,13 @@ function takePictureFromCameraWP(successCallback, errorCallback, args) {
                     encodingType: encodingType,
                     saveToPhotoAlbum: saveToPhotoAlbum
                 }, successCallback, errorCallback);
-            }, function(err) {
-                    destroyCameraPreview();
-                    errorCallback(err);
+            }, function (err) {
+                destroyCameraPreview();
+                errorCallback(err);
             });
-    };
+    }
 
-    var getAspectRatios = function (capture) {
+    function getAspectRatios (capture) {
         var videoDeviceController = capture.videoDeviceController;
         var photoAspectRatios = videoDeviceController.getAvailableMediaStreamProperties(CapMSType.photo).map(function (element) {
             return (element.width / element.height).toFixed(1);
@@ -512,9 +567,9 @@ function takePictureFromCameraWP(successCallback, errorCallback, args) {
         return Object.keys(aspectObj).filter(function (k) {
             return aspectObj[k] === 3;
         });
-    };
+    }
 
-    var setAspectRatio = function (capture, aspect) {
+    function setAspectRatio (capture, aspect) {
         // Max photo resolution with desired aspect ratio
         var videoDeviceController = capture.videoDeviceController;
         var photoResolution = videoDeviceController.getAvailableMediaStreamProperties(CapMSType.photo)
@@ -550,15 +605,42 @@ function takePictureFromCameraWP(successCallback, errorCallback, args) {
             .then(function () {
                 return videoDeviceController.setMediaStreamPropertiesAsync(CapMSType.videoRecord, videoRecordResolution);
             });
-    };
+    }
+
+    /**
+     * When Capture button is clicked, try to capture a picture and return
+     */
+    function onCameraCaptureButtonClick () {
+        // Make sure user can't click more than once
+        if (this.getAttribute('clicked') === '1') {
+            return false;
+        } else {
+            this.setAttribute('clicked', '1');
+        }
+        captureAction();
+    }
+
+    /**
+     * When Cancel button is clicked, destroy camera preview and return with error callback
+     */
+    function onCameraCancelButtonClick () {
+        // Make sure user can't click more than once
+        if (this.getAttribute('clicked') === '1') {
+            return false;
+        } else {
+            this.setAttribute('clicked', '1');
+        }
+        destroyCameraPreview();
+        errorCallback('no image selected');
+    }
 
     /**
      * When the phone orientation change, get the event and change camera preview rotation
      * @param  {Object} e - SimpleOrientationSensorOrientationChangedEventArgs
      */
-    var onOrientationChange = function (e) {
+    function onOrientationChange (e) {
         setPreviewRotation(e.orientation);
-    };
+    }
 
     /**
      * Converts SimpleOrientation to a VideoRotation to remove difference between camera sensor orientation
@@ -566,39 +648,39 @@ function takePictureFromCameraWP(successCallback, errorCallback, args) {
      * @param  {number} orientation - Windows.Devices.Sensors.SimpleOrientation
      * @return {number} - Windows.Media.Capture.VideoRotation
      */
-    var orientationToRotation = function (orientation) {
+    function orientationToRotation (orientation) {
         // VideoRotation enumerable and BitmapRotation enumerable have the same values
         // https://msdn.microsoft.com/en-us/library/windows/apps/windows.media.capture.videorotation.aspx
         // https://msdn.microsoft.com/en-us/library/windows/apps/windows.graphics.imaging.bitmaprotation.aspx
 
         switch (orientation) {
-            // portrait
-            case Windows.Devices.Sensors.SimpleOrientation.notRotated:
-                return Windows.Media.Capture.VideoRotation.clockwise90Degrees;
-            // landscape
-            case Windows.Devices.Sensors.SimpleOrientation.rotated90DegreesCounterclockwise:
-                return Windows.Media.Capture.VideoRotation.none;
-            // portrait-flipped (not supported by WinPhone Apps)
-            case Windows.Devices.Sensors.SimpleOrientation.rotated180DegreesCounterclockwise:
-                // Falling back to portrait default
-                return Windows.Media.Capture.VideoRotation.clockwise90Degrees;
-            // landscape-flipped
-            case Windows.Devices.Sensors.SimpleOrientation.rotated270DegreesCounterclockwise:
-                return Windows.Media.Capture.VideoRotation.clockwise180Degrees;
-            // faceup & facedown
-            default:
-                // Falling back to portrait default
-                return Windows.Media.Capture.VideoRotation.clockwise90Degrees;
+        // portrait
+        case Windows.Devices.Sensors.SimpleOrientation.notRotated:
+            return Windows.Media.Capture.VideoRotation.clockwise90Degrees;
+        // landscape
+        case Windows.Devices.Sensors.SimpleOrientation.rotated90DegreesCounterclockwise:
+            return Windows.Media.Capture.VideoRotation.none;
+        // portrait-flipped (not supported by WinPhone Apps)
+        case Windows.Devices.Sensors.SimpleOrientation.rotated180DegreesCounterclockwise:
+            // Falling back to portrait default
+            return Windows.Media.Capture.VideoRotation.clockwise90Degrees;
+        // landscape-flipped
+        case Windows.Devices.Sensors.SimpleOrientation.rotated270DegreesCounterclockwise:
+            return Windows.Media.Capture.VideoRotation.clockwise180Degrees;
+        // faceup & facedown
+        default:
+            // Falling back to portrait default
+            return Windows.Media.Capture.VideoRotation.clockwise90Degrees;
         }
-    };
+    }
 
     /**
      * Rotates the current MediaCapture's video
      * @param {number} orientation - Windows.Devices.Sensors.SimpleOrientation
      */
-    var setPreviewRotation = function(orientation) {
+    function setPreviewRotation (orientation) {
         capture.setPreviewRotation(orientationToRotation(orientation));
-    };
+    }
 
     try {
         createCameraUI();
@@ -608,19 +690,19 @@ function takePictureFromCameraWP(successCallback, errorCallback, args) {
     }
 }
 
-function takePictureFromCameraWindows(successCallback, errorCallback, args) {
-    var destinationType = args[1],
-        targetWidth = args[3],
-        targetHeight = args[4],
-        encodingType = args[5],
-        allowCrop = !!args[7],
-        saveToPhotoAlbum = args[9],
-        WMCapture = Windows.Media.Capture,
-        cameraCaptureUI = new WMCapture.CameraCaptureUI();
+function takePictureFromCameraWindows (successCallback, errorCallback, args) {
+    var destinationType = args[1];
+    var targetWidth = args[3];
+    var targetHeight = args[4];
+    var encodingType = args[5];
+    var allowCrop = !!args[7];
+    var saveToPhotoAlbum = args[9];
+    var WMCapture = Windows.Media.Capture;
+    var cameraCaptureUI = new WMCapture.CameraCaptureUI();
 
     cameraCaptureUI.photoSettings.allowCropping = allowCrop;
 
-    if (encodingType == Camera.EncodingType.PNG) {
+    if (encodingType === Camera.EncodingType.PNG) {
         cameraCaptureUI.photoSettings.format = WMCapture.CameraCaptureUIPhotoFormat.png;
     } else {
         cameraCaptureUI.photoSettings.format = WMCapture.CameraCaptureUIPhotoFormat.jpeg;
@@ -629,66 +711,93 @@ function takePictureFromCameraWindows(successCallback, errorCallback, args) {
     // decide which max pixels should be supported by targetWidth or targetHeight.
     var maxRes = null;
     var UIMaxRes = WMCapture.CameraCaptureUIMaxPhotoResolution;
-    switch (true) {
-        case (targetWidth >= 1280 || targetHeight >= 960) :
-            cameraCaptureUI.photoSettings.maxResolution = UIMaxRes.large3M;
-            break;
-        case (targetWidth >= 1024 || targetHeight >= 768) :
-            maxRes = UIMaxRes.mediumXga;
-            break;
-        case    (targetWidth >= 800 || targetHeight >= 600) :
-            maxRes = UIMaxRes.mediumXga;
-            break;
-        case  (targetWidth >= 640 || targetHeight >= 480) :
-            maxRes = UIMaxRes.smallVga;
-            break;
-        case    (targetWidth >= 320 || targetHeight >= 240) :
-            maxRes = UIMaxRes.verySmallQvga;
-            break;
-        default :
-            maxRes = UIMaxRes.highestAvailable;
+    var totalPixels = targetWidth * targetHeight;
+
+    if (targetWidth === -1 && targetHeight === -1) {
+        maxRes = UIMaxRes.highestAvailable;
+    // Temp fix for CB-10539
+    /* else if (totalPixels <= 320 * 240) {
+        maxRes = UIMaxRes.verySmallQvga;
+    } */
+    } else if (totalPixels <= 640 * 480) {
+        maxRes = UIMaxRes.smallVga;
+    } else if (totalPixels <= 1024 * 768) {
+        maxRes = UIMaxRes.mediumXga;
+    } else if (totalPixels <= 3 * 1000 * 1000) {
+        maxRes = UIMaxRes.large3M;
+    } else if (totalPixels <= 5 * 1000 * 1000) {
+        maxRes = UIMaxRes.veryLarge5M;
+    } else {
+        maxRes = UIMaxRes.highestAvailable;
     }
 
     cameraCaptureUI.photoSettings.maxResolution = maxRes;
 
-    cameraCaptureUI.captureFileAsync(WMCapture.CameraCaptureUIMode.photo).done(function(picture) {
-        if (!picture) {
-            errorCallback("User didn't capture a photo.");
-            return;
-        }
+    var cameraPicture;
 
-        savePhoto(picture, {
+    // define focus handler for windows phone 10.0
+    var savePhotoOnFocus = function () {
+        window.removeEventListener('focus', savePhotoOnFocus);
+        // call only when the app is in focus again
+        savePhoto(cameraPicture, {
             destinationType: destinationType,
             targetHeight: targetHeight,
             targetWidth: targetWidth,
             encodingType: encodingType,
             saveToPhotoAlbum: saveToPhotoAlbum
         }, successCallback, errorCallback);
-    }, function() {
-        errorCallback("Fail to capture a photo.");
+    };
+
+    // if windows phone 10, add and delete focus eventHandler to capture the focus back from cameraUI to app
+    if (navigator.appVersion.indexOf('Windows Phone 10.0') >= 0) {
+        window.addEventListener('focus', savePhotoOnFocus);
+    }
+
+    cameraCaptureUI.captureFileAsync(WMCapture.CameraCaptureUIMode.photo).done(function (picture) {
+        if (!picture) {
+            errorCallback("User didn't capture a photo.");
+            // Remove the focus handler if present
+            window.removeEventListener('focus', savePhotoOnFocus);
+            return;
+        }
+        cameraPicture = picture;
+
+        // If not windows 10, call savePhoto() now. If windows 10, wait for the app to be in focus again
+        if (navigator.appVersion.indexOf('Windows Phone 10.0') < 0) {
+            savePhoto(cameraPicture, {
+                destinationType: destinationType,
+                targetHeight: targetHeight,
+                targetWidth: targetWidth,
+                encodingType: encodingType,
+                saveToPhotoAlbum: saveToPhotoAlbum
+            }, successCallback, errorCallback);
+        }
+    }, function () {
+        errorCallback('Fail to capture a photo.');
+        window.removeEventListener('focus', savePhotoOnFocus);
     });
 }
 
-function savePhoto(picture, options, successCallback, errorCallback) {
+function savePhoto (picture, options, successCallback, errorCallback) {
     // success callback for capture operation
-    var success = function(picture) {
-        if (options.destinationType == Camera.DestinationType.FILE_URI || options.destinationType == Camera.DestinationType.NATIVE_URI) {
+    var success = function (picture) {
+        if (options.destinationType === Camera.DestinationType.FILE_URI || options.destinationType === Camera.DestinationType.NATIVE_URI) {
             if (options.targetHeight > 0 && options.targetWidth > 0) {
                 resizeImage(successCallback, errorCallback, picture, options.targetWidth, options.targetHeight, options.encodingType);
             } else {
                 picture.copyAsync(getAppData().localFolder, picture.name, OptUnique).done(function (copiedFile) {
-                    successCallback("ms-appdata:///local/" + copiedFile.name);
-                },errorCallback);
+                    successCallback('ms-appdata:///local/' + copiedFile.name);
+                }, errorCallback);
             }
         } else {
             if (options.targetHeight > 0 && options.targetWidth > 0) {
                 resizeImageBase64(successCallback, errorCallback, picture, options.targetWidth, options.targetHeight);
             } else {
-                fileIO.readBufferAsync(picture).done(function(buffer) {
-                    var strBase64 =encodeToBase64String(buffer);
-                    picture.deleteAsync().done(function() {
+                fileIO.readBufferAsync(picture).done(function (buffer) {
+                    var strBase64 = encodeToBase64String(buffer);
+                    picture.deleteAsync().done(function () {
                         successCallback(strBase64);
-                    }, function(err) {
+                    }, function (err) {
                         errorCallback(err);
                     });
                 }, errorCallback);
@@ -698,38 +807,38 @@ function savePhoto(picture, options, successCallback, errorCallback) {
 
     if (!options.saveToPhotoAlbum) {
         success(picture);
-        return;
+
     } else {
         var savePicker = new Windows.Storage.Pickers.FileSavePicker();
-        var saveFile = function(file) {
+        var saveFile = function (file) {
             if (file) {
                 // Prevent updates to the remote version of the file until we're done
                 Windows.Storage.CachedFileManager.deferUpdates(file);
                 picture.moveAndReplaceAsync(file)
-                    .then(function() {
+                    .then(function () {
                         // Let Windows know that we're finished changing the file so
                         // the other app can update the remote version of the file.
                         return Windows.Storage.CachedFileManager.completeUpdatesAsync(file);
                     })
-                    .done(function(updateStatus) {
+                    .done(function (updateStatus) {
                         if (updateStatus === Windows.Storage.Provider.FileUpdateStatus.complete) {
                             success(picture);
                         } else {
-                            errorCallback("File update status is not complete.");
+                            errorCallback('File update status is not complete.');
                         }
                     }, errorCallback);
             } else {
-                errorCallback("Failed to select a file.");
+                errorCallback('Failed to select a file.');
             }
         };
         savePicker.suggestedStartLocation = pickerLocId.picturesLibrary;
 
         if (options.encodingType === Camera.EncodingType.PNG) {
-            savePicker.fileTypeChoices.insert("PNG", [".png"]);
-            savePicker.suggestedFileName = "photo.png";
+            savePicker.fileTypeChoices.insert('PNG', ['.png']);
+            savePicker.suggestedFileName = 'photo.png';
         } else {
-            savePicker.fileTypeChoices.insert("JPEG", [".jpg"]);
-            savePicker.suggestedFileName = "photo.jpg";
+            savePicker.fileTypeChoices.insert('JPEG', ['.jpg']);
+            savePicker.suggestedFileName = 'photo.jpg';
         }
 
         // If Windows Phone 8.1 use pickSaveFileAndContinue()
@@ -739,14 +848,14 @@ function savePhoto(picture, options, successCallback, errorCallback) {
                 Using FileSavePicker will suspend the app and it's required to catch the pickSaveFileContinuation
                 https://msdn.microsoft.com/en-us/library/windows/apps/xaml/dn631755.aspx
             */
-            var fileSaveHandler = function(eventArgs) {
+            var fileSaveHandler = function (eventArgs) {
                 if (eventArgs.kind === Windows.ApplicationModel.Activation.ActivationKind.pickSaveFileContinuation) {
                     var file = eventArgs.file;
                     saveFile(file);
-                    webUIApp.removeEventListener("activated", fileSaveHandler);
+                    webUIApp.removeEventListener('activated', fileSaveHandler);
                 }
             };
-            webUIApp.addEventListener("activated", fileSaveHandler);
+            webUIApp.addEventListener('activated', fileSaveHandler);
             savePicker.pickSaveFileAndContinue();
         } else {
             savePicker.pickSaveFileAsync()
@@ -755,4 +864,4 @@ function savePhoto(picture, options, successCallback, errorCallback) {
     }
 }
 
-require("cordova/exec/proxy").add("Camera",module.exports);
+require('cordova/exec/proxy').add('Camera', module.exports);

src/wp/Camera.cs

@@ -1,522 +0,0 @@
-/*  
-	Licensed under the Apache License, Version 2.0 (the "License");
-	you may not use this file except in compliance with the License.
-	You may obtain a copy of the License at
-	
-	http://www.apache.org/licenses/LICENSE-2.0
-	
-	Unless required by applicable law or agreed to in writing, software
-	distributed under the License is distributed on an "AS IS" BASIS,
-	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-	See the License for the specific language governing permissions and
-	limitations under the License.
-*/
-
-using System;
-using System.Net;
-using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Documents;
-using System.Windows.Ink;
-using System.Windows.Input;
-using System.Windows.Media;
-using System.Windows.Media.Animation;
-using System.Collections.Generic;
-using Microsoft.Phone.Tasks;
-using System.Runtime.Serialization;
-using System.IO;
-using System.IO.IsolatedStorage;
-using System.Windows.Media.Imaging;
-using Microsoft.Phone;
-using Microsoft.Xna.Framework.Media;
-using System.Diagnostics;
-
-namespace WPCordovaClassLib.Cordova.Commands
-{
-    public class Camera : BaseCommand
-    {
-
-        /// <summary>
-        /// Return base64 encoded string
-        /// </summary>
-        private const int DATA_URL = 0;
-
-        /// <summary>
-        /// Return file uri
-        /// </summary>
-        private const int FILE_URI = 1;
-
-        /// <summary>
-        /// Choose image from picture library
-        /// </summary>
-        private const int PHOTOLIBRARY = 0;
-
-        /// <summary>
-        /// Take picture from camera
-        /// </summary>
-
-        private const int CAMERA = 1;
-
-        /// <summary>
-        /// Choose image from picture library
-        /// </summary>
-        private const int SAVEDPHOTOALBUM = 2;
-
-        /// <summary>
-        /// Take a picture of type JPEG
-        /// </summary>
-        private const int JPEG = 0;
-
-        /// <summary>
-        /// Take a picture of type PNG
-        /// </summary>
-        private const int PNG = 1;
-
-        /// <summary>
-        /// Folder to store captured images
-        /// </summary>
-        private const string isoFolder = "CapturedImagesCache";
-
-        /// <summary>
-        /// Represents captureImage action options.
-        /// </summary>
-        [DataContract]
-        public class CameraOptions
-        {
-            /// <summary>
-            /// Source to getPicture from.
-            /// </summary>
-            [DataMember(IsRequired = false, Name = "sourceType")]
-            public int PictureSourceType { get; set; }
-
-            /// <summary>
-            /// Format of image that returned from getPicture.
-            /// </summary>
-            [DataMember(IsRequired = false, Name = "destinationType")]
-            public int DestinationType { get; set; }
-
-            /// <summary>
-            /// Quality of saved image
-            /// </summary>
-            [DataMember(IsRequired = false, Name = "quality")]
-            public int Quality { get; set; }
-
-            /// <summary>
-            /// Controls whether or not the image is also added to the device photo album.
-            /// </summary>
-            [DataMember(IsRequired = false, Name = "saveToPhotoAlbum")]
-            public bool SaveToPhotoAlbum { get; set; }
-
-            /// <summary>
-            /// Ignored
-            /// </summary>
-            [DataMember(IsRequired = false, Name = "correctOrientation")]
-            public bool CorrectOrientation { get; set; }
-
-            /// <summary>
-            /// Ignored
-            /// </summary>
-            [DataMember(IsRequired = false, Name = "allowEdit")]
-            public bool AllowEdit { get; set; }
-
-                        /// <summary>
-            /// Height in pixels to scale image
-            /// </summary>
-            [DataMember(IsRequired = false, Name = "encodingType")]
-            public int EncodingType { get; set; }
-
-                        /// <summary>
-            /// Height in pixels to scale image
-            /// </summary>
-            [DataMember(IsRequired = false, Name = "mediaType")]
-            public int MediaType { get; set; }
-
-
-            /// <summary>
-            /// Height in pixels to scale image
-            /// </summary>
-            [DataMember(IsRequired = false, Name = "targetHeight")]
-            public int TargetHeight { get; set; }
-
-
-            /// <summary>
-            /// Width in pixels to scale image
-            /// </summary>
-            [DataMember(IsRequired = false, Name = "targetWidth")]
-            public int TargetWidth { get; set; }
-
-            /// <summary>
-            /// Creates options object with default parameters
-            /// </summary>
-            public CameraOptions()
-            {
-                this.SetDefaultValues(new StreamingContext());
-            }
-
-            /// <summary>
-            /// Initializes default values for class fields.
-            /// Implemented in separate method because default constructor is not invoked during deserialization.
-            /// </summary>
-            /// <param name="context"></param>
-            [OnDeserializing()]
-            public void SetDefaultValues(StreamingContext context)
-            {
-                PictureSourceType = CAMERA;
-                DestinationType = FILE_URI;
-                Quality = 80;
-                TargetHeight = -1;
-                TargetWidth = -1;
-                SaveToPhotoAlbum = false;
-                CorrectOrientation = true;
-                AllowEdit = false;
-                MediaType = -1;
-                EncodingType = -1;
-            }
-        }
-
-        /// <summary>
-        /// Camera options
-        /// </summary>
-        CameraOptions cameraOptions;
-
-        public void takePicture(string options)
-        {
-            try
-            {
-                string[] args = JSON.JsonHelper.Deserialize<string[]>(options);
-                // ["quality", "destinationType", "sourceType", "targetWidth", "targetHeight", "encodingType",
-                //     "mediaType", "allowEdit", "correctOrientation", "saveToPhotoAlbum" ]
-                cameraOptions = new CameraOptions();
-                cameraOptions.Quality = int.Parse(args[0]);
-                cameraOptions.DestinationType = int.Parse(args[1]);
-                cameraOptions.PictureSourceType = int.Parse(args[2]);
-                cameraOptions.TargetWidth = int.Parse(args[3]);
-                cameraOptions.TargetHeight = int.Parse(args[4]);
-                cameraOptions.EncodingType = int.Parse(args[5]);
-                cameraOptions.MediaType = int.Parse(args[6]);
-                cameraOptions.AllowEdit = bool.Parse(args[7]);
-                cameraOptions.CorrectOrientation = bool.Parse(args[8]);
-                cameraOptions.SaveToPhotoAlbum = bool.Parse(args[9]);
-
-                // a very large number will force the other value to be the bound
-                if (cameraOptions.TargetWidth > -1 && cameraOptions.TargetHeight == -1)
-                {
-                    cameraOptions.TargetHeight = 100000;   
-                }
-                else if (cameraOptions.TargetHeight > -1 && cameraOptions.TargetWidth == -1)
-                {
-                    cameraOptions.TargetWidth = 100000;
-                }
-            }
-            catch (Exception ex)
-            {
-                DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION, ex.Message));
-                return;
-            }
-
-            if(cameraOptions.DestinationType != Camera.FILE_URI && cameraOptions.DestinationType != Camera.DATA_URL )
-            {
-                DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, "Incorrect option: destinationType"));
-                return;
-            }
-
-            ChooserBase<PhotoResult> chooserTask = null;
-            if (cameraOptions.PictureSourceType == CAMERA)
-            {
-                chooserTask = new CameraCaptureTask();
-            }
-            else if ((cameraOptions.PictureSourceType == PHOTOLIBRARY) || (cameraOptions.PictureSourceType == SAVEDPHOTOALBUM))
-            {
-                chooserTask = new PhotoChooserTask();
-            }
-            // if chooserTask is still null, then PictureSourceType was invalid
-            if (chooserTask != null)
-            {
-                chooserTask.Completed += onTaskCompleted;
-                chooserTask.Show();
-            }
-            else
-            {
-                Debug.WriteLine("Unrecognized PictureSourceType :: " + cameraOptions.PictureSourceType.ToString());
-                DispatchCommandResult(new PluginResult(PluginResult.Status.NO_RESULT));
-            }
-        }
-
-        public void onTaskCompleted(object sender, PhotoResult e)
-        {
-            var task = sender as ChooserBase<PhotoResult>;
-            if (task != null)
-            {
-                task.Completed -= onTaskCompleted;
-            }
-
-            if (e.Error != null)
-            {
-                DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR));
-                return;
-            }
-
-            switch (e.TaskResult)
-            {
-                case TaskResult.OK:
-                    try
-                    {
-                        string imagePathOrContent = string.Empty;
-
-                        // Save image back to media library
-                        // only save to photoalbum if it didn't come from there ...
-                        if (cameraOptions.PictureSourceType == CAMERA && cameraOptions.SaveToPhotoAlbum)
-                        {
-                            MediaLibrary library = new MediaLibrary();
-                            Picture pict = library.SavePicture(e.OriginalFileName, e.ChosenPhoto); // to save to photo-roll ...
-                        }
-
-                        int newAngle = 0;
-                        // There's bug in Windows Phone 8.1 causing Seek on a DssPhotoStream not working properly.
-                        // https://connect.microsoft.com/VisualStudio/feedback/details/783252
-                        // But a mis-oriented file is better than nothing, so try and catch.
-                        try {
-                            int orient = ImageExifHelper.getImageOrientationFromStream(e.ChosenPhoto);
-                            switch (orient) {
-                                case ImageExifOrientation.LandscapeLeft:
-                                    newAngle = 90;
-                                    break;
-                                case ImageExifOrientation.PortraitUpsideDown:
-                                    newAngle = 180;
-                                    break;
-                                case ImageExifOrientation.LandscapeRight:
-                                    newAngle = 270;
-                                    break;
-                                case ImageExifOrientation.Portrait:
-                                default: break; // 0 default already set
-                            }
-                        } catch {
-                            Debug.WriteLine("Error fetching orientation from Exif");
-                        }
-
-                        if (newAngle != 0)
-                        {
-                            using (Stream rotImageStream = ImageExifHelper.RotateStream(e.ChosenPhoto, newAngle))
-                            {
-                                // we should reset stream position after saving stream to media library
-                                rotImageStream.Seek(0, SeekOrigin.Begin);
-                                if (cameraOptions.DestinationType == DATA_URL)
-                                {
-                                    imagePathOrContent = GetImageContent(rotImageStream);
-                                }
-                                else   // FILE_URL
-                                {
-                                    imagePathOrContent = SaveImageToLocalStorage(rotImageStream, Path.GetFileName(e.OriginalFileName));
-                                }
-                            }
-                        }
-                        else   // no need to reorient
-                        {
-                            if (cameraOptions.DestinationType == DATA_URL)
-                            {
-                                imagePathOrContent = GetImageContent(e.ChosenPhoto);
-                            }
-                            else  // FILE_URL
-                            {
-                                imagePathOrContent = SaveImageToLocalStorage(e.ChosenPhoto, Path.GetFileName(e.OriginalFileName));
-                            }
-                        }
-
-                        DispatchCommandResult(new PluginResult(PluginResult.Status.OK, imagePathOrContent));
-                    }
-                    catch (Exception)
-                    {
-                        DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, "Error retrieving image."));
-                    }
-                    break;
-                case TaskResult.Cancel:
-                    DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, "Selection cancelled."));
-                    break;
-                default:
-                    DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, "Selection did not complete!"));
-                    break;
-            }
-        }
-     
-        /// <summary>
-        /// Returns image content in a form of base64 string
-        /// </summary>
-        /// <param name="stream">Image stream</param>
-        /// <returns>Base64 representation of the image</returns>
-        private string GetImageContent(Stream stream)
-        {
-            byte[] imageContent = null;
-
-            try
-            {
-                // Resize photo and convert to JPEG
-                imageContent = ResizePhoto(stream);
-            }
-            finally
-            {
-                stream.Dispose();
-            }
-
-            return Convert.ToBase64String(imageContent);
-        }
-
-        /// <summary>
-        /// Resize image
-        /// </summary>
-        /// <param name="stream">Image stream</param>
-        /// <returns>resized image</returns>
-        private byte[] ResizePhoto(Stream stream)
-        {
-            //output
-            byte[] resizedFile;
-
-            BitmapImage objBitmap = new BitmapImage();
-            objBitmap.SetSource(stream);
-            objBitmap.CreateOptions = BitmapCreateOptions.None;
-
-            WriteableBitmap objWB = new WriteableBitmap(objBitmap);
-            objBitmap.UriSource = null;
-
-            // Calculate resultant image size
-            int width, height;
-            if (cameraOptions.TargetWidth >= 0 && cameraOptions.TargetHeight >= 0)
-            {
-                // Keep proportionally
-                double ratio = Math.Min(
-                    (double)cameraOptions.TargetWidth / objWB.PixelWidth,
-                    (double)cameraOptions.TargetHeight / objWB.PixelHeight);
-                width = Convert.ToInt32(ratio * objWB.PixelWidth);
-                height = Convert.ToInt32(ratio * objWB.PixelHeight);
-            }
-            else
-            {
-                width = objWB.PixelWidth;
-                height = objWB.PixelHeight;
-            }
-
-            //Hold the result stream
-            using (MemoryStream objBitmapStreamResized = new MemoryStream())
-            {
-
-                try
-                {
-                    // resize the photo with user defined TargetWidth & TargetHeight
-                    Extensions.SaveJpeg(objWB, objBitmapStreamResized, width, height, 0, cameraOptions.Quality);
-                }
-                finally
-                {
-                    //Dispose bitmaps immediately, they are memory expensive
-                    DisposeImage(objBitmap);
-                    DisposeImage(objWB);
-                    GC.Collect();
-                }
-
-                //Convert the resized stream to a byte array. 
-                int streamLength = (int)objBitmapStreamResized.Length;
-                resizedFile = new Byte[streamLength]; //-1 
-                objBitmapStreamResized.Position = 0;
-
-                //for some reason we have to set Position to zero, but we don't have to earlier when we get the bytes from the chosen photo... 
-                objBitmapStreamResized.Read(resizedFile, 0, streamLength);
-            }
-
-            return resizedFile;
-        }
-
-        /// <summary>
-        /// Util: Dispose a bitmap resource
-        /// </summary>
-        /// <param name="image">BitmapSource subclass to dispose</param>
-        private void DisposeImage(BitmapSource image)
-        {
-            if (image != null)
-            {
-                try
-                {
-                    using (var ms = new MemoryStream(new byte[] { 0x0 }))
-                    {
-                        image.SetSource(ms);
-                    }
-                }
-                catch (Exception)
-                {
-                }
-            }
-        }
-
-        /// <summary>
-        /// Saves captured image in isolated storage
-        /// </summary>
-        /// <param name="imageFileName">image file name</param>
-        /// <returns>Image path</returns>
-        private string SaveImageToLocalStorage(Stream stream, string imageFileName)
-        {
-
-            if (stream == null)
-            {
-                throw new ArgumentNullException("imageBytes");
-            }
-            try
-            {
-                var isoFile = IsolatedStorageFile.GetUserStoreForApplication();
-
-                if (!isoFile.DirectoryExists(isoFolder))
-                {
-                    isoFile.CreateDirectory(isoFolder);
-                }
-
-                string filePath = System.IO.Path.Combine("///" + isoFolder + "/", imageFileName);
-
-                using (IsolatedStorageFileStream outputStream = isoFile.CreateFile(filePath))
-                {
-                    BitmapImage objBitmap = new BitmapImage();
-                    objBitmap.SetSource(stream);
-                    objBitmap.CreateOptions = BitmapCreateOptions.None;
-
-                    WriteableBitmap objWB = new WriteableBitmap(objBitmap);
-                    objBitmap.UriSource = null;
-
-                    try
-                    {
-
-                        //use photo's actual width & height if user doesn't provide width & height
-                        if (cameraOptions.TargetWidth < 0 && cameraOptions.TargetHeight < 0)
-                        {
-                            objWB.SaveJpeg(outputStream, objWB.PixelWidth, objWB.PixelHeight, 0, cameraOptions.Quality);
-                        }
-                        else
-                        {
-                            //Resize
-                            //Keep proportionally
-                            double ratio = Math.Min((double)cameraOptions.TargetWidth / objWB.PixelWidth, (double)cameraOptions.TargetHeight / objWB.PixelHeight);
-                            int width = Convert.ToInt32(ratio * objWB.PixelWidth);
-                            int height = Convert.ToInt32(ratio * objWB.PixelHeight);
-
-                            // resize the photo with user defined TargetWidth & TargetHeight
-                            objWB.SaveJpeg(outputStream, width, height, 0, cameraOptions.Quality);
-                        }
-                    }
-                    finally
-                    {
-                        //Dispose bitmaps immediately, they are memory expensive
-                        DisposeImage(objBitmap);
-                        DisposeImage(objWB);
-                        GC.Collect();
-                    }
-                }
-
-                return new Uri(filePath, UriKind.Relative).ToString();
-            }
-            catch (Exception)
-            {
-                //TODO: log or do something else
-                throw;
-            }
-            finally
-            {
-                stream.Dispose();
-            }
-        }
-
-    }
-}

tests/ios/CDVCameraTest/CDVCameraLibTests/CameraTest.m

@@ -21,9 +21,6 @@
 #import <XCTest/XCTest.h>
 #import "CDVCamera.h"
 #import "UIImage+CropScaleOrientation.h"
-#import <Cordova/NSArray+Comparisons.h>
-#import <Cordova/NSData+Base64.h>
-#import <Cordova/NSDictionary+Extensions.h>
 #import <MobileCoreServices/UTCoreTypes.h>
 
 
@@ -291,12 +288,14 @@
     
     // test 640x480
     
-    targetSize = CGSizeMake(640, 480);
+    targetSize = CGSizeMake(480, 640);
     
     targetImage = [sourceImagePortrait imageByScalingNotCroppingForSize:targetSize];
     XCTAssertEqual(targetImage.size.width, targetSize.width);
     XCTAssertEqual(targetImage.size.height, targetSize.height);
-    
+
+    targetSize = CGSizeMake(640, 480);
+
     targetImage = [sourceImageLandscape imageByScalingNotCroppingForSize:targetSize];
     XCTAssertEqual(targetImage.size.width, targetSize.width);
     XCTAssertEqual(targetImage.size.height, targetSize.height);
@@ -304,24 +303,28 @@
     
     // test 800x600
     
-    targetSize = CGSizeMake(800, 600);
+    targetSize = CGSizeMake(600, 800);
     
     targetImage = [sourceImagePortrait imageByScalingNotCroppingForSize:targetSize];
     XCTAssertEqual(targetImage.size.width, targetSize.width);
     XCTAssertEqual(targetImage.size.height, targetSize.height);
     
+    targetSize = CGSizeMake(800, 600);
+
     targetImage = [sourceImageLandscape imageByScalingNotCroppingForSize:targetSize];
     XCTAssertEqual(targetImage.size.width, targetSize.width);
     XCTAssertEqual(targetImage.size.height, targetSize.height);
     
     // test 1024x768
     
-    targetSize = CGSizeMake(1024, 768);
+    targetSize = CGSizeMake(768, 1024);
     
     targetImage = [sourceImagePortrait imageByScalingNotCroppingForSize:targetSize];
     XCTAssertEqual(targetImage.size.width, targetSize.width);
     XCTAssertEqual(targetImage.size.height, targetSize.height);
     
+    targetSize = CGSizeMake(1024, 768);
+
     targetImage = [sourceImageLandscape imageByScalingNotCroppingForSize:targetSize];
     XCTAssertEqual(targetImage.size.width, targetSize.width);
     XCTAssertEqual(targetImage.size.height, targetSize.height);
@@ -476,7 +479,7 @@
     pictureOptions.encodingType = EncodingTypePNG;
     
     resultData = [self.plugin processImage:originalImage info:@{} options:pictureOptions];
-    XCTAssertEqualObjects([resultData base64EncodedString], [originalImageDataPNG base64EncodedString]);
+    XCTAssertEqualObjects([resultData base64EncodedStringWithOptions:0], [originalImageDataPNG base64EncodedStringWithOptions:0]);
 
     // Original, JPEG, full quality
     
@@ -487,7 +490,7 @@
     pictureOptions.encodingType = EncodingTypeJPEG;
     
     resultData = [self.plugin processImage:originalImage info:@{} options:pictureOptions];
-    XCTAssertEqualObjects([resultData base64EncodedString], [originalImageDataJPEG base64EncodedString]);
+    XCTAssertEqualObjects([resultData base64EncodedStringWithOptions:0], [originalImageDataJPEG base64EncodedStringWithOptions:0]);
     
     // Original, JPEG, with quality value
     
@@ -500,7 +503,7 @@
     
     NSData* originalImageDataJPEGWithQuality = UIImageJPEGRepresentation(originalImage, [pictureOptions.quality floatValue]/ 100.f);
     resultData = [self.plugin processImage:originalImage info:@{} options:pictureOptions];
-    XCTAssertEqualObjects([resultData base64EncodedString], [originalImageDataJPEGWithQuality base64EncodedString]);
+    XCTAssertEqualObjects([resultData base64EncodedStringWithOptions:0], [originalImageDataJPEGWithQuality base64EncodedStringWithOptions:0]);
     
     // TODO: usesGeolocation is not tested
 }

tests/ios/package.json

@@ -5,9 +5,9 @@
     "author": "Apache Software Foundation",
     "license": "Apache Version 2.0",
     "dependencies": {
-        "cordova-ios": "^3.7.0"
+        "cordova-ios": "*"
     },
     "scripts": {
         "test": "xcodebuild -scheme CordovaLib && xcodebuild test -scheme CDVCameraLibTests -destination 'platform=iOS Simulator,name=iPhone 5'"
-    }    
-}
+    }
+}

tests/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "cordova-plugin-camera-tests",
+  "version": "2.4.1-dev",
+  "description": "",
+  "cordova": {
+    "id": "cordova-plugin-camera-tests",
+    "platforms": []
+  },
+  "keywords": [
+    "ecosystem:cordova"
+  ],
+  "author": "",
+  "license": "Apache 2.0"
+}

tests/plugin.xml

@@ -22,11 +22,11 @@
     xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:rim="http://www.blackberry.com/ns/widgets"
     id="cordova-plugin-camera-tests"
-    version="1.2.0">
+    version="4.0.1">
     <name>Cordova Camera Plugin Tests</name>
     <license>Apache 2.0</license>
-    
-    <dependency id="cordova-plugin-file" version=">=2.0.0" />
+
+    <dependency id="cordova-plugin-file-transfer" />
 
     <js-module src="tests.js" name="tests">
     </js-module>

tests/tests.js

@@ -19,24 +19,27 @@
  *
 */
 
+/* globals Camera, resolveLocalFileSystemURL, FileEntry, CameraPopoverOptions, FileTransfer, FileUploadOptions, LocalFileSystem, MSApp */
+/* eslint-env jasmine */
+
 exports.defineAutoTests = function () {
     describe('Camera (navigator.camera)', function () {
-        it("should exist", function () {
+        it('should exist', function () {
             expect(navigator.camera).toBeDefined();
         });
 
-        it("should contain a getPicture function", function () {
+        it('should contain a getPicture function', function () {
             expect(navigator.camera.getPicture).toBeDefined();
-            expect(typeof navigator.camera.getPicture == 'function').toBe(true);
+            expect(typeof navigator.camera.getPicture === 'function').toBe(true);
         });
     });
 
     describe('Camera Constants (window.Camera + navigator.camera)', function () {
-        it("camera.spec.1 window.Camera should exist", function () {
+        it('camera.spec.1 window.Camera should exist', function () {
             expect(window.Camera).toBeDefined();
         });
 
-        it("camera.spec.2 should contain three DestinationType constants", function () {
+        it('camera.spec.2 should contain three DestinationType constants', function () {
             expect(Camera.DestinationType.DATA_URL).toBe(0);
             expect(Camera.DestinationType.FILE_URI).toBe(1);
             expect(Camera.DestinationType.NATIVE_URI).toBe(2);
@@ -45,14 +48,14 @@ exports.defineAutoTests = function () {
             expect(navigator.camera.DestinationType.NATIVE_URI).toBe(2);
         });
 
-        it("camera.spec.3 should contain two EncodingType constants", function () {
+        it('camera.spec.3 should contain two EncodingType constants', function () {
             expect(Camera.EncodingType.JPEG).toBe(0);
             expect(Camera.EncodingType.PNG).toBe(1);
             expect(navigator.camera.EncodingType.JPEG).toBe(0);
             expect(navigator.camera.EncodingType.PNG).toBe(1);
         });
 
-        it("camera.spec.4 should contain three MediaType constants", function () {
+        it('camera.spec.4 should contain three MediaType constants', function () {
             expect(Camera.MediaType.PICTURE).toBe(0);
             expect(Camera.MediaType.VIDEO).toBe(1);
             expect(Camera.MediaType.ALLMEDIA).toBe(2);
@@ -61,7 +64,7 @@ exports.defineAutoTests = function () {
             expect(navigator.camera.MediaType.ALLMEDIA).toBe(2);
         });
 
-        it("camera.spec.5 should contain three PictureSourceType constants", function () {
+        it('camera.spec.5 should contain three PictureSourceType constants', function () {
             expect(Camera.PictureSourceType.PHOTOLIBRARY).toBe(0);
             expect(Camera.PictureSourceType.CAMERA).toBe(1);
             expect(Camera.PictureSourceType.SAVEDPHOTOALBUM).toBe(2);
@@ -72,19 +75,17 @@ exports.defineAutoTests = function () {
     });
 };
 
-
 /******************************************************************************/
 /******************************************************************************/
 /******************************************************************************/
 
 exports.defineManualTests = function (contentEl, createActionButton) {
-    var platformId = cordova.require('cordova/platform').id;
     var pictureUrl = null;
     var fileObj = null;
     var fileEntry = null;
     var pageStartTime = +new Date();
 
-    //default camera options
+    // default camera options
     var camQualityDefault = ['50', 50];
     var camDestinationTypeDefault = ['FILE_URI', 1];
     var camPictureSourceTypeDefault = ['CAMERA', 1];
@@ -94,17 +95,12 @@ exports.defineManualTests = function (contentEl, createActionButton) {
     var camCorrectOrientationDefault = ['correctOrientation', false];
     var camSaveToPhotoAlbumDefault = ['saveToPhotoAlbum', true];
 
-    var clearLog = function () {
-        var log = document.getElementById('info');
-        log.innerHTML = "";
-    }
-
-    function log(value) {
+    function log (value) {
         console.log(value);
         document.getElementById('camera_status').textContent += (new Date() - pageStartTime) / 1000 + ': ' + value + '\n';
     }
 
-    function clearStatus() {
+    function clearStatus () {
         document.getElementById('camera_status').innerHTML = '';
         document.getElementById('camera_image').src = 'about:blank';
         var canvas = document.getElementById('canvas');
@@ -114,39 +110,43 @@ exports.defineManualTests = function (contentEl, createActionButton) {
         fileEntry = null;
     }
 
-    function setPicture(url, callback) {
+    function setPicture (url, callback) {
         try {
             window.atob(url);
             // if we got here it is a base64 string (DATA_URL)
-            url = "data:image/jpeg;base64," + url;
+            url = 'data:image/jpeg;base64,' + url;
         } catch (e) {
             // not DATA_URL
-            log('URL: ' + url.slice(0, 100));
         }
+        log('URL: "' + url.slice(0, 90) + '"');
 
         pictureUrl = url;
         var img = document.getElementById('camera_image');
         var startTime = new Date();
         img.src = url;
-        img.onloadend = function () {
+        img.onload = function () {
+            log('Img size: ' + img.naturalWidth + 'x' + img.naturalHeight);
             log('Image tag load time: ' + (new Date() - startTime));
-            callback && callback();
+            if (callback) {
+                callback();
+            }
         };
     }
 
-    function onGetPictureError(e) {
+    function onGetPictureError (e) {
         log('Error getting picture: ' + (e.code || e));
     }
 
-    function getPictureWin(data) {
+    function getPictureWin (data) {
         setPicture(data);
         // TODO: Fix resolveLocalFileSystemURI to work with native-uri.
-        if (pictureUrl.indexOf('file:') == 0 || pictureUrl.indexOf('content:') == 0 || pictureUrl.indexOf('ms-appdata:') === 0) {
-            resolveLocalFileSystemURI(data, function (e) {
+        if (pictureUrl.indexOf('file:') === 0 || pictureUrl.indexOf('content:') === 0 || pictureUrl.indexOf('ms-appdata:') === 0 || pictureUrl.indexOf('assets-library:') === 0) {
+            resolveLocalFileSystemURL(data, function (e) {
                 fileEntry = e;
-                logCallback('resolveLocalFileSystemURI()', true)(e.toURL());
-            }, logCallback('resolveLocalFileSystemURI()', false));
-        } else if (pictureUrl.indexOf('data:image/jpeg;base64') == 0) {
+                logCallback('resolveLocalFileSystemURL()', true)(e.toURL());
+                readFile();
+            }, logCallback('resolveLocalFileSystemURL()', false));
+        } else if (pictureUrl.indexOf('data:image/jpeg;base64') === 0) {
             // do nothing
         } else {
             var path = pictureUrl.replace(/^file:\/\/(localhost)?/, '').replace(/%20/g, ' ');
@@ -154,7 +154,7 @@ exports.defineManualTests = function (contentEl, createActionButton) {
         }
     }
 
-    function getPicture() {
+    function getPicture () {
         clearStatus();
         var options = extractOptions();
         log('Getting picture with options: ' + JSON.stringify(options));
@@ -164,32 +164,30 @@ exports.defineManualTests = function (contentEl, createActionButton) {
         window.onorientationchange = function () {
             var newPopoverOptions = new CameraPopoverOptions(0, 0, 100, 100, 0);
             popoverHandle.setPosition(newPopoverOptions);
-        }
+        };
     }
 
-    function uploadImage() {
-        var ft = new FileTransfer(),
-            uploadcomplete = 0,
-            progress = 0,
-            options = new FileUploadOptions();
-        options.fileKey = "photo";
+    function uploadImage () {
+        var ft = new FileTransfer();
+        var options = new FileUploadOptions();
+        options.fileKey = 'photo';
         options.fileName = 'test.jpg';
-        options.mimeType = "image/jpeg";
+        options.mimeType = 'image/jpeg';
         ft.onprogress = function (progressEvent) {
             console.log('progress: ' + progressEvent.loaded + ' of ' + progressEvent.total);
         };
-        var server = "http://cordova-filetransfer.jitsu.com";
+        var server = 'http://sheltered-retreat-43956.herokuapp.com';
 
         ft.upload(pictureUrl, server + '/upload', win, fail, options);
-        function win(information_back) {
+        function win (information_back) {
             log('upload complete');
         }
-        function fail(message) {
+        function fail (message) {
             log('upload failed: ' + JSON.stringify(message));
         }
     }
 
-    function logCallback(apiName, success) {
+    function logCallback (apiName, success) {
         return function () {
             log('Call to ' + apiName + (success ? ' success: ' : ' failed: ') + JSON.stringify([].slice.call(arguments)));
         };
@@ -199,26 +197,29 @@ exports.defineManualTests = function (contentEl, createActionButton) {
      * Select image from library using a NATIVE_URI destination type
      * This calls FileEntry.getMetadata, FileEntry.setMetadata, FileEntry.getParent, FileEntry.file, and FileReader.readAsDataURL.
      */
-    function readFile() {
-        function onFileReadAsDataURL(evt) {
+    function readFile () {
+        function onFileReadAsDataURL (evt) {
             var img = document.getElementById('camera_image');
-            img.style.visibility = "visible";
-            img.style.display = "block";
+            img.style.visibility = 'visible';
+            img.style.display = 'block';
             img.src = evt.target.result;
-            log("FileReader.readAsDataURL success");
-        };
+            log('FileReader.readAsDataURL success');
+        }
 
-        function onFileReceived(file) {
+        function onFileReceived (file) {
             log('Got file: ' + JSON.stringify(file));
             fileObj = file;
-
+            /* eslint-disable no-undef */
             var reader = new FileReader();
+            /* eslint-enable no-undef */
             reader.onload = function () {
                 log('FileReader.readAsDataURL() - length = ' + reader.result.length);
             };
             reader.onerror = logCallback('FileReader.readAsDataURL', false);
+            reader.onloadend = onFileReadAsDataURL;
             reader.readAsDataURL(file);
-        };
+        }
+
         // Test out onFileReceived when the file object was set via a native <input> elements.
         if (fileObj) {
             onFileReceived(fileObj);
@@ -226,19 +227,20 @@ exports.defineManualTests = function (contentEl, createActionButton) {
             fileEntry.file(onFileReceived, logCallback('FileEntry.file', false));
         }
     }
-    function getFileInfo() {
+
+    function getFileInfo () {
         // Test FileEntry API here.
         fileEntry.getMetadata(logCallback('FileEntry.getMetadata', true), logCallback('FileEntry.getMetadata', false));
-        fileEntry.setMetadata(logCallback('FileEntry.setMetadata', true), logCallback('FileEntry.setMetadata', false), { "com.apple.MobileBackup": 1 });
+        fileEntry.setMetadata(logCallback('FileEntry.setMetadata', true), logCallback('FileEntry.setMetadata', false), { 'com.apple.MobileBackup': 1 });
         fileEntry.getParent(logCallback('FileEntry.getParent', true), logCallback('FileEntry.getParent', false));
         fileEntry.getParent(logCallback('FileEntry.getParent', true), logCallback('FileEntry.getParent', false));
-    };
+    }
 
     /**
      * Copy image from library using a NATIVE_URI destination type
      * This calls FileEntry.copyTo and FileEntry.moveTo.
      */
-    function copyImage() {
+    function copyImage () {
         var onFileSystemReceived = function (fileSystem) {
             var destDirEntry = fileSystem.root;
             var origName = fileEntry.name;
@@ -247,17 +249,17 @@ exports.defineManualTests = function (contentEl, createActionButton) {
             fileEntry.copyTo(destDirEntry, 'copied_file.png', logCallback('FileEntry.copyTo', true), logCallback('FileEntry.copyTo', false));
             fileEntry.moveTo(destDirEntry, 'moved_file.png', logCallback('FileEntry.moveTo', true), logCallback('FileEntry.moveTo', false));
 
-            //cleanup
-            //rename moved file back to original name so other tests can reference image
-            resolveLocalFileSystemURI(destDirEntry.nativeURL+'moved_file.png', function(fileEntry) {
+            // cleanup
+            // rename moved file back to original name so other tests can reference image
+            resolveLocalFileSystemURL(destDirEntry.nativeURL + 'moved_file.png', function (fileEntry) {
                 fileEntry.moveTo(destDirEntry, origName, logCallback('FileEntry.moveTo', true), logCallback('FileEntry.moveTo', false));
                 console.log('Cleanup: successfully renamed file back to original name');
             }, function () {
                 console.log('Cleanup: failed to rename file back to original name');
             });
 
-            //remove copied file
-            resolveLocalFileSystemURI(destDirEntry.nativeURL+'copied_file.png', function(fileEntry) {
+            // remove copied file
+            resolveLocalFileSystemURL(destDirEntry.nativeURL + 'copied_file.png', function (fileEntry) {
                 fileEntry.remove(logCallback('FileEntry.remove', true), logCallback('FileEntry.remove', false));
                 console.log('Cleanup: successfully removed copied file');
             }, function () {
@@ -266,17 +268,17 @@ exports.defineManualTests = function (contentEl, createActionButton) {
         };
 
         window.requestFileSystem(LocalFileSystem.TEMPORARY, 0, onFileSystemReceived, null);
-    };
+    }
 
     /**
      * Write image to library using a NATIVE_URI destination type
      * This calls FileEntry.createWriter, FileWriter.write, and FileWriter.truncate.
      */
-    function writeImage() {
+    function writeImage () {
         var onFileWriterReceived = function (fileWriter) {
             fileWriter.onwrite = logCallback('FileWriter.write', true);
             fileWriter.onerror = logCallback('FileWriter.write', false);
-            fileWriter.write("some text!");
+            fileWriter.write('some text!');
         };
 
         var onFileTruncateWriterReceived = function (fileWriter) {
@@ -287,9 +289,9 @@ exports.defineManualTests = function (contentEl, createActionButton) {
 
         fileEntry.createWriter(onFileWriterReceived, logCallback('FileEntry.createWriter', false));
         fileEntry.createWriter(onFileTruncateWriterReceived, null);
-    };
+    }
 
-    function displayImageUsingCanvas() {
+    function displayImageUsingCanvas () {
         var canvas = document.getElementById('canvas');
         var img = document.getElementById('camera_image');
         var w = img.width;
@@ -300,26 +302,27 @@ exports.defineManualTests = function (contentEl, createActionButton) {
         canvas.height = h;
         var context = canvas.getContext('2d');
         context.drawImage(img, 0, 0, w, h);
-    };
+    }
 
     /**
      * Remove image from library using a NATIVE_URI destination type
      * This calls FileEntry.remove.
      */
-    function removeImage() {
+    function removeImage () {
         fileEntry.remove(logCallback('FileEntry.remove', true), logCallback('FileEntry.remove', false));
-    };
+    }
 
-    function testInputTag(inputEl) {
+    function testInputTag (inputEl) {
         clearStatus();
         // iOS 6 likes to dead-lock in the onchange context if you
         // do any alerts or try to remote-debug.
         window.setTimeout(function () {
             testNativeFile2(inputEl);
         }, 0);
-    };
+    }
 
-    function testNativeFile2(inputEl) {
+    function testNativeFile2 (inputEl) {
+        /* eslint-disable no-undef */
         if (!inputEl.value) {
             alert('No file selected.');
             return;
@@ -329,6 +332,7 @@ exports.defineManualTests = function (contentEl, createActionButton) {
             alert('Got value but no file.');
             return;
         }
+        /* eslint-enable no-undef */
         var URLApi = window.URL || window.webkitURL;
         if (URLApi) {
             var blobURL = URLApi.createObjectURL(fileObj);
@@ -344,38 +348,42 @@ exports.defineManualTests = function (contentEl, createActionButton) {
         }
     }
 
-    function extractOptions() {
+    function extractOptions () {
         var els = document.querySelectorAll('#image-options select');
         var ret = {};
+        /* eslint-disable no-cond-assign */
         for (var i = 0, el; el = els[i]; ++i) {
             var value = el.value;
             if (value === '') continue;
+            value = +value;
+
             if (el.isBool) {
-                ret[el.getAttribute("name")] = !!+value;
+                ret[el.getAttribute('name')] = !!value;
             } else {
-                ret[el.getAttribute("name")] = +value;
+                ret[el.getAttribute('name')] = value;
             }
         }
+        /* eslint-enable no-cond-assign */
         return ret;
     }
 
-    function createOptionsEl(name, values, selectionDefault) {
+    function createOptionsEl (name, values, selectionDefault) {
         var openDiv = '<div style="display: inline-block">' + name + ': ';
-        var select = '<select name=' + name + '>';
+        var select = '<select name=' + name + ' id="' + name + '">';
 
         var defaultOption = '';
-        if (selectionDefault == undefined) {
+        if (selectionDefault === undefined) {
             defaultOption = '<option value="">default</option>';
         }
 
         var options = '';
-        if (typeof values == 'boolean') {
+        if (typeof values === 'boolean') {
             values = { 'true': 1, 'false': 0 };
         }
         for (var k in values) {
             var isSelected = '';
             if (selectionDefault) {
-                if (selectionDefault[0] == k) {
+                if (selectionDefault[0] === k) {
                     isSelected = 'selected';
                 }
             }
@@ -394,8 +402,8 @@ exports.defineManualTests = function (contentEl, createActionButton) {
             '<b>Status:</b> <div id="camera_status"></div>' +
             'img: <img width="100" id="camera_image">' +
             'canvas: <canvas id="canvas" width="1" height="1"></canvas>' +
-            '</div>',
-        options_div = '<h2>Cordova Camera API Options</h2>' +
+            '</div>';
+    var options_div = '<h2>Cordova Camera API Options</h2>' +
             '<div id="image-options">' +
             createOptionsEl('sourceType', Camera.PictureSourceType, camPictureSourceTypeDefault) +
             createOptionsEl('destinationType', Camera.DestinationType, camDestinationTypeDefault) +
@@ -408,9 +416,9 @@ exports.defineManualTests = function (contentEl, createActionButton) {
             createOptionsEl('correctOrientation', true, camCorrectOrientationDefault) +
             createOptionsEl('saveToPhotoAlbum', true, camSaveToPhotoAlbumDefault) +
             createOptionsEl('cameraDirection', Camera.Direction) +
-            '</div>',
-        getpicture_div = '<div id="getpicture"></div>',
-        test_procedure = '<h4>Recommended Test Procedure</h4>' +
+            '</div>';
+    var getpicture_div = '<div id="getpicture"></div>';
+    var test_procedure = '<h4>Recommended Test Procedure</h4>' +
             'Options not specified should be the default value' +
             '<br>Status box should update with image and info whenever an image is taken or selected from library' +
             '</p><div style="background:#B0C4DE;border:1px solid #FFA07A;margin:15px 6px 0px;min-width:295px;max-width:97%;padding:4px 0px 2px 10px;min-height:160px;max-height:200px;overflow:auto">' +
@@ -423,14 +431,14 @@ exports.defineManualTests = function (contentEl, createActionButton) {
             '</p><li>sourceType=PHOTOLIBRARY<br>mediaType=ALLMEDIA<br>allowEdit=true<br>Should be able to select pics and videos and edit picture if selected</li>' +
             '</p><li>sourceType=CAMERA<br>targetWidth & targetHeight=50<br>allowEdit=false<br>Do Get File Metadata test below and take note of size<br>Repeat test but with width and height=800. Size should be significantly larger.</li>' +
             '</p><li>quality=0<br>targetWidth & targetHeight=default<br>allowEdit=false<br>Do Get File Metadata test below and take note of size<br>Repeat test but with quality=80. Size should be significantly larger.</li>' +
-            '</ol></div>',
-        inputs_div = '<h2>Native File Inputs</h2>' +
+            '</ol></div>';
+    var inputs_div = '<h2>Native File Inputs</h2>' +
             'For the following tests, status box should update with file selected' +
             '</p><div>input type=file <input type="file" class="testInputTag"></div>' +
             '<div>capture=camera <input type="file" accept="image/*;capture=camera" class="testInputTag"></div>' +
             '<div>capture=camcorder <input type="file" accept="video/*;capture=camcorder" class="testInputTag"></div>' +
-            '<div>capture=microphone <input type="file" accept="audio/*;capture=microphone" class="testInputTag"></div>',
-        actions_div = '<h2>Actions</h2>' +
+            '<div>capture=microphone <input type="file" accept="audio/*;capture=microphone" class="testInputTag"></div>';
+    var actions_div = '<h2>Actions</h2>' +
             'For the following tests, ensure that an image is set in status box' +
             '</p><div id="metadata"></div>' +
             'Expected result: Get metadata about file selected.<br>Status box will show, along with the metadata, "Call to FileEntry.getMetadata success, Call to FileEntry.setMetadata success, Call to FileEntry.getParent success"' +
@@ -450,20 +458,20 @@ exports.defineManualTests = function (contentEl, createActionButton) {
     // We need to wrap this code due to Windows security restrictions
     // see http://msdn.microsoft.com/en-us/library/windows/apps/hh465380.aspx#differences for details
     if (window.MSApp && window.MSApp.execUnsafeLocalFunction) {
-        MSApp.execUnsafeLocalFunction(function() {
+        MSApp.execUnsafeLocalFunction(function () {
             contentEl.innerHTML = info_div + options_div + getpicture_div + test_procedure + inputs_div + actions_div;
         });
     } else {
         contentEl.innerHTML = info_div + options_div + getpicture_div + test_procedure + inputs_div + actions_div;
     }
 
-    var elements = document.getElementsByClassName("testInputTag");
+    var elements = document.getElementsByClassName('testInputTag');
     var listener = function (e) {
         testInputTag(e.target);
-    }
+    };
     for (var i = 0; i < elements.length; ++i) {
         var item = elements[i];
-        item.addEventListener("change", listener, false);
+        item.addEventListener('change', listener, false);
     }
 
     createActionButton('Get picture', function () {

types/index.d.ts

@@ -0,0 +1,174 @@
+// Type definitions for Apache Cordova Camera plugin
+// Project: https://github.com/apache/cordova-plugin-camera
+// Definitions by: Microsoft Open Technologies Inc <http://msopentech.com>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// 
+// Copyright (c) Microsoft Open Technologies Inc
+// Licensed under the MIT license.
+
+interface Navigator {
+    /**
+     * This plugin provides an API for taking pictures and for choosing images from the system's image library.
+     */
+    camera: Camera;
+}
+
+/**
+ * This plugin provides an API for taking pictures and for choosing images from the system's image library.
+ */
+interface Camera {
+    /**
+     * Removes intermediate photos taken by the camera from temporary storage.
+     * @param onSuccess Success callback, that called when cleanup succeeds.
+     * @param onError Error callback, that get an error message.
+     */
+    cleanup(
+        onSuccess: () => void,
+        onError: (message: string) => void): void;
+    /**
+     * Takes a photo using the camera, or retrieves a photo from the device's image gallery.
+     * @param cameraSuccess Success callback, that get the image
+     * as a base64-encoded String, or as the URI for the image file.
+     * @param cameraError Error callback, that get an error message.
+     * @param cameraOptions Optional parameters to customize the camera settings.
+     */
+    getPicture(
+        cameraSuccess: (data: string) => void,
+        cameraError: (message: string) => void,
+        cameraOptions?: CameraOptions): void;
+    // Next will work only on iOS
+    //getPicture(
+    //    cameraSuccess: (data: string) => void,
+    //    cameraError: (message: string) => void,
+    //    cameraOptions?: CameraOptions): CameraPopoverHandle;
+}
+
+interface CameraOptions {
+    /** Picture quality in range 0-100. Default is 50 */
+    quality?: number;
+    /**
+     * Choose the format of the return value.
+     * Defined in navigator.camera.DestinationType. Default is FILE_URI.
+     *      DATA_URL : 0,   Return image as base64-encoded string
+     *      FILE_URI : 1,   Return image file URI
+     *      NATIVE_URI : 2  Return image native URI
+     *          (e.g., assets-library:// on iOS or content:// on Android)
+     */
+    destinationType?: number;
+    /**
+     * Set the source of the picture.
+     * Defined in navigator.camera.PictureSourceType. Default is CAMERA.
+     *      PHOTOLIBRARY : 0,
+     *      CAMERA : 1,
+     *      SAVEDPHOTOALBUM : 2
+     */
+    sourceType?: number;
+    /** Allow simple editing of image before selection. */
+    allowEdit?: boolean;
+    /**
+     * Choose the returned image file's encoding.
+     * Defined in navigator.camera.EncodingType. Default is JPEG
+     *      JPEG : 0    Return JPEG encoded image
+     *      PNG : 1     Return PNG encoded image
+     */
+    encodingType?: number;
+    /**
+     * Width in pixels to scale image. Must be used with targetHeight.
+     * Aspect ratio remains constant.
+    */
+    targetWidth?: number;
+    /**
+     * Height in pixels to scale image. Must be used with targetWidth.
+     * Aspect ratio remains constant.
+     */
+    targetHeight?: number;
+    /**
+     * Set the type of media to select from. Only works when PictureSourceType
+     * is PHOTOLIBRARY or SAVEDPHOTOALBUM. Defined in nagivator.camera.MediaType
+     *      PICTURE: 0      allow selection of still pictures only. DEFAULT.
+     *          Will return format specified via DestinationType
+     *      VIDEO: 1        allow selection of video only, WILL ALWAYS RETURN FILE_URI
+     *      ALLMEDIA : 2    allow selection from all media types
+     */
+    mediaType?: number;
+    /** Rotate the image to correct for the orientation of the device during capture. */
+    correctOrientation?: boolean;
+    /** Save the image to the photo album on the device after capture. */
+    saveToPhotoAlbum?: boolean;
+    /**
+     * Choose the camera to use (front- or back-facing).
+     * Defined in navigator.camera.Direction. Default is BACK.
+     *      FRONT: 0
+     *      BACK: 1
+     */
+    cameraDirection?: number;
+    /** iOS-only options that specify popover location in iPad. Defined in CameraPopoverOptions. */
+    popoverOptions?: CameraPopoverOptions;
+}
+
+/**
+ * A handle to the popover dialog created by navigator.camera.getPicture. Used on iOS only.
+ */
+interface CameraPopoverHandle {
+    /**
+     * Set the position of the popover.
+     * @param popoverOptions the CameraPopoverOptions that specify the new position.
+     */
+    setPosition(popoverOptions: CameraPopoverOptions): void;
+}
+
+/**
+ * iOS-only parameters that specify the anchor element location and arrow direction
+ * of the popover when selecting images from an iPad's library or album.
+ */
+interface CameraPopoverOptions {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /**
+     * Direction the arrow on the popover should point. Defined in Camera.PopoverArrowDirection
+     * Matches iOS UIPopoverArrowDirection constants.
+     *      ARROW_UP : 1,        
+     *      ARROW_DOWN : 2,
+     *      ARROW_LEFT : 4,
+     *      ARROW_RIGHT : 8,
+     *      ARROW_ANY : 15
+     */
+    arrowDir : number;
+}
+
+declare var Camera: {
+    // Camera constants, defined in Camera plugin
+    DestinationType: {
+        DATA_URL: number;
+        FILE_URI: number;
+        NATIVE_URI: number
+    }
+    Direction: {
+        BACK: number;
+        FRONT: number;
+    }
+    EncodingType: {
+        JPEG: number;
+        PNG: number;
+    }
+    MediaType: {
+        PICTURE: number;
+        VIDEO: number;
+        ALLMEDIA: number;
+    }
+    PictureSourceType: {
+        PHOTOLIBRARY: number;
+        CAMERA: number;
+        SAVEDPHOTOALBUM: number;
+    }
+    // Used only on iOS
+    PopoverArrowDirection: {
+        ARROW_UP: number;
+        ARROW_DOWN: number;
+        ARROW_LEFT: number;
+        ARROW_RIGHT: number;
+        ARROW_ANY: number;
+    }
+};

www/Camera.js

@@ -19,12 +19,19 @@
  *
 */
 
-var argscheck = require('cordova/argscheck'),
-    exec = require('cordova/exec'),
-    Camera = require('./Camera');
-    // XXX: commented out
-    //CameraPopoverHandle = require('./CameraPopoverHandle');
+var argscheck = require('cordova/argscheck');
+var exec = require('cordova/exec');
+var Camera = require('./Camera');
+// XXX: commented out
+// CameraPopoverHandle = require('./CameraPopoverHandle');
 
+/**
+ * @namespace navigator
+ */
+
+/**
+ * @exports camera
+ */
 var cameraExport = {};
 
 // Tack on the Camera Constants to the base camera plugin.
@@ -33,16 +40,98 @@ for (var key in Camera) {
 }
 
 /**
- * Gets a picture from source defined by "options.sourceType", and returns the
- * image as defined by the "options.destinationType" option.
-
- * The defaults are sourceType=CAMERA and destinationType=FILE_URI.
- *
- * @param {Function} successCallback
- * @param {Function} errorCallback
- * @param {Object} options
+ * Callback function that provides an error message.
+ * @callback module:camera.onError
+ * @param {string} message - The message is provided by the device's native code.
  */
-cameraExport.getPicture = function(successCallback, errorCallback, options) {
+
+/**
+ * Callback function that provides the image data.
+ * @callback module:camera.onSuccess
+ * @param {string} imageData - Base64 encoding of the image data, _or_ the image file URI, depending on [`cameraOptions`]{@link module:camera.CameraOptions} in effect.
+ * @example
+ * // Show image
+ * //
+ * function cameraCallback(imageData) {
+ *    var image = document.getElementById('myImage');
+ *    image.src = "data:image/jpeg;base64," + imageData;
+ * }
+ */
+
+/**
+ * Optional parameters to customize the camera settings.
+ * * [Quirks](#CameraOptions-quirks)
+ * @typedef module:camera.CameraOptions
+ * @type {Object}
+ * @property {number} [quality=50] - Quality of the saved image, expressed as a range of 0-100, where 100 is typically full resolution with no loss from file compression. (Note that information about the camera's resolution is unavailable.)
+ * @property {module:Camera.DestinationType} [destinationType=FILE_URI] - Choose the format of the return value.
+ * @property {module:Camera.PictureSourceType} [sourceType=CAMERA] - Set the source of the picture.
+ * @property {Boolean} [allowEdit=true] - Allow simple editing of image before selection.
+ * @property {module:Camera.EncodingType} [encodingType=JPEG] - Choose the  returned image file's encoding.
+ * @property {number} [targetWidth] - Width in pixels to scale image. Must be used with `targetHeight`. Aspect ratio remains constant.
+ * @property {number} [targetHeight] - Height in pixels to scale image. Must be used with `targetWidth`. Aspect ratio remains constant.
+ * @property {module:Camera.MediaType} [mediaType=PICTURE] - Set the type of media to select from.  Only works when `PictureSourceType` is `PHOTOLIBRARY` or `SAVEDPHOTOALBUM`.
+ * @property {Boolean} [correctOrientation] - Rotate the image to correct for the orientation of the device during capture.
+ * @property {Boolean} [saveToPhotoAlbum] - Save the image to the photo album on the device after capture.
+ * @property {module:CameraPopoverOptions} [popoverOptions] - iOS-only options that specify popover location in iPad.
+ * @property {module:Camera.Direction} [cameraDirection=BACK] - Choose the camera to use (front- or back-facing).
+ */
+
+/**
+ * @description Takes a photo using the camera, or retrieves a photo from the device's
+ * image gallery.  The image is passed to the success callback as a
+ * Base64-encoded `String`, or as the URI for the image file.
+ *
+ * The `camera.getPicture` function opens the device's default camera
+ * application that allows users to snap pictures by default - this behavior occurs,
+ * when `Camera.sourceType` equals [`Camera.PictureSourceType.CAMERA`]{@link module:Camera.PictureSourceType}.
+ * Once the user snaps the photo, the camera application closes and the application is restored.
+ *
+ * If `Camera.sourceType` is `Camera.PictureSourceType.PHOTOLIBRARY` or
+ * `Camera.PictureSourceType.SAVEDPHOTOALBUM`, then a dialog displays
+ * that allows users to select an existing image.
+ *
+ * The return value is sent to the [`cameraSuccess`]{@link module:camera.onSuccess} callback function, in
+ * one of the following formats, depending on the specified
+ * `cameraOptions`:
+ *
+ * - A `String` containing the Base64-encoded photo image.
+ * - A `String` representing the image file location on local storage (default).
+ *
+ * You can do whatever you want with the encoded image or URI, for
+ * example:
+ *
+ * - Render the image in an `<img>` tag, as in the example below
+ * - Save the data locally (`LocalStorage`, [Lawnchair](http://brianleroux.github.com/lawnchair/), etc.)
+ * - Post the data to a remote server
+ *
+ * __NOTE__: Photo resolution on newer devices is quite good. Photos
+ * selected from the device's gallery are not downscaled to a lower
+ * quality, even if a `quality` parameter is specified.  To avoid common
+ * memory problems, set `Camera.destinationType` to `FILE_URI` rather
+ * than `DATA_URL`.
+ *
+ * __Supported Platforms__
+ *
+ * - Android
+ * - BlackBerry
+ * - Browser
+ * - Firefox
+ * - FireOS
+ * - iOS
+ * - Windows
+ * - WP8
+ * - Ubuntu
+ *
+ * More examples [here](#camera-getPicture-examples). Quirks [here](#camera-getPicture-quirks).
+ *
+ * @example
+ * navigator.camera.getPicture(cameraSuccess, cameraError, cameraOptions);
+ * @param {module:camera.onSuccess} successCallback
+ * @param {module:camera.onError} errorCallback
+ * @param {module:camera.CameraOptions} options CameraOptions
+ */
+cameraExport.getPicture = function (successCallback, errorCallback, options) {
     argscheck.checkArgs('fFO', 'Camera.getPicture', arguments);
     options = options || {};
     var getValue = argscheck.getValue;
@@ -61,15 +150,36 @@ cameraExport.getPicture = function(successCallback, errorCallback, options) {
     var cameraDirection = getValue(options.cameraDirection, Camera.Direction.BACK);
 
     var args = [quality, destinationType, sourceType, targetWidth, targetHeight, encodingType,
-                mediaType, allowEdit, correctOrientation, saveToPhotoAlbum, popoverOptions, cameraDirection];
+        mediaType, allowEdit, correctOrientation, saveToPhotoAlbum, popoverOptions, cameraDirection];
 
-    exec(successCallback, errorCallback, "Camera", "takePicture", args);
+    exec(successCallback, errorCallback, 'Camera', 'takePicture', args);
     // XXX: commented out
-    //return new CameraPopoverHandle();
+    // return new CameraPopoverHandle();
 };
 
-cameraExport.cleanup = function(successCallback, errorCallback) {
-    exec(successCallback, errorCallback, "Camera", "cleanup", []);
+/**
+ * Removes intermediate image files that are kept in temporary storage
+ * after calling [`camera.getPicture`]{@link module:camera.getPicture}. Applies only when the value of
+ * `Camera.sourceType` equals `Camera.PictureSourceType.CAMERA` and the
+ * `Camera.destinationType` equals `Camera.DestinationType.FILE_URI`.
+ *
+ * __Supported Platforms__
+ *
+ * - iOS
+ *
+ * @example
+ * navigator.camera.cleanup(onSuccess, onFail);
+ *
+ * function onSuccess() {
+ *     console.log("Camera cleanup success.")
+ * }
+ *
+ * function onFail(message) {
+ *     alert('Failed because: ' + message);
+ * }
+ */
+cameraExport.cleanup = function (successCallback, errorCallback) {
+    exec(successCallback, errorCallback, 'Camera', 'cleanup', []);
 };
 
 module.exports = cameraExport;

www/CameraConstants.js

@@ -19,35 +19,83 @@
  *
 */
 
+/**
+ * @module Camera
+ */
 module.exports = {
-  DestinationType:{
-    DATA_URL: 0,         // Return base64 encoded string
-    FILE_URI: 1,         // Return file uri (content://media/external/images/media/2 for Android)
-    NATIVE_URI: 2        // Return native uri (eg. asset-library://... for iOS)
-  },
-  EncodingType:{
-    JPEG: 0,             // Return JPEG encoded image
-    PNG: 1               // Return PNG encoded image
-  },
-  MediaType:{
-    PICTURE: 0,          // allow selection of still pictures only. DEFAULT. Will return format specified via DestinationType
-    VIDEO: 1,            // allow selection of video only, ONLY RETURNS URL
-    ALLMEDIA : 2         // allow selection from all media types
-  },
-  PictureSourceType:{
-    PHOTOLIBRARY : 0,    // Choose image from picture library (same as SAVEDPHOTOALBUM for Android)
-    CAMERA : 1,          // Take picture from camera
-    SAVEDPHOTOALBUM : 2  // Choose image from picture library (same as PHOTOLIBRARY for Android)
-  },
-  PopoverArrowDirection:{
-      ARROW_UP : 1,        // matches iOS UIPopoverArrowDirection constants to specify arrow location on popover
-      ARROW_DOWN : 2,
-      ARROW_LEFT : 4,
-      ARROW_RIGHT : 8,
-      ARROW_ANY : 15
-  },
-  Direction:{
-      BACK: 0,
-      FRONT: 1
-  }
+    /**
+     * @description
+     * Defines the output format of `Camera.getPicture` call.
+     * _Note:_ On iOS passing `DestinationType.NATIVE_URI` along with
+     * `PictureSourceType.PHOTOLIBRARY` or `PictureSourceType.SAVEDPHOTOALBUM` will
+     * disable any image modifications (resize, quality change, cropping, etc.) due
+     * to implementation specific.
+     *
+     * @enum {number}
+     */
+    DestinationType: {
+        /** Return base64 encoded string. DATA_URL can be very memory intensive and cause app crashes or out of memory errors. Use FILE_URI or NATIVE_URI if possible */
+        DATA_URL: 0,
+        /** Return file uri (content://media/external/images/media/2 for Android) */
+        FILE_URI: 1,
+        /** Return native uri (eg. asset-library://... for iOS) */
+        NATIVE_URI: 2
+    },
+    /**
+     * @enum {number}
+     */
+    EncodingType: {
+        /** Return JPEG encoded image */
+        JPEG: 0,
+        /** Return PNG encoded image */
+        PNG: 1
+    },
+    /**
+     * @enum {number}
+     */
+    MediaType: {
+        /** Allow selection of still pictures only. DEFAULT. Will return format specified via DestinationType */
+        PICTURE: 0,
+        /** Allow selection of video only, ONLY RETURNS URL */
+        VIDEO: 1,
+        /** Allow selection from all media types */
+        ALLMEDIA: 2
+    },
+    /**
+     * @description
+     * Defines the output format of `Camera.getPicture` call.
+     * _Note:_ On iOS passing `PictureSourceType.PHOTOLIBRARY` or `PictureSourceType.SAVEDPHOTOALBUM`
+     * along with `DestinationType.NATIVE_URI` will disable any image modifications (resize, quality
+     * change, cropping, etc.) due to implementation specific.
+     *
+     * @enum {number}
+     */
+    PictureSourceType: {
+        /** Choose image from the device's photo library (same as SAVEDPHOTOALBUM for Android) */
+        PHOTOLIBRARY: 0,
+        /** Take picture from camera */
+        CAMERA: 1,
+        /** Choose image only from the device's Camera Roll album (same as PHOTOLIBRARY for Android) */
+        SAVEDPHOTOALBUM: 2
+    },
+    /**
+     * Matches iOS UIPopoverArrowDirection constants to specify arrow location on popover.
+     * @enum {number}
+     */
+    PopoverArrowDirection: {
+        ARROW_UP: 1,
+        ARROW_DOWN: 2,
+        ARROW_LEFT: 4,
+        ARROW_RIGHT: 8,
+        ARROW_ANY: 15
+    },
+    /**
+     * @enum {number}
+     */
+    Direction: {
+        /** Use the back-facing camera */
+        BACK: 0,
+        /** Use the front-facing camera */
+        FRONT: 1
+    }
 };

www/CameraPopoverHandle.js

@@ -19,13 +19,12 @@
  *
 */
 
-var exec = require('cordova/exec');
-
 /**
+ * @ignore in favour of iOS' one
  * A handle to an image picker popover.
  */
-var CameraPopoverHandle = function() {
-    this.setPosition = function(popoverOptions) {
+var CameraPopoverHandle = function () {
+    this.setPosition = function (popoverOptions) {
         console.log('CameraPopoverHandle.setPosition is only supported on iOS.');
     };
 };

www/CameraPopoverOptions.js

@@ -22,15 +22,30 @@
 var Camera = require('./Camera');
 
 /**
- * Encapsulates options for iOS Popover image picker
+ * @namespace navigator
  */
-var CameraPopoverOptions = function(x,y,width,height,arrowDir){
+
+/**
+ * iOS-only parameters that specify the anchor element location and arrow
+ * direction of the popover when selecting images from an iPad's library
+ * or album.
+ * Note that the size of the popover may change to adjust to the
+ * direction of the arrow and orientation of the screen.  Make sure to
+ * account for orientation changes when specifying the anchor element
+ * location.
+ * @module CameraPopoverOptions
+ * @param {Number} [x=0] - x pixel coordinate of screen element onto which to anchor the popover.
+ * @param {Number} [y=32] - y pixel coordinate of screen element onto which to anchor the popover.
+ * @param {Number} [width=320] - width, in pixels, of the screen element onto which to anchor the popover.
+ * @param {Number} [height=480] - height, in pixels, of the screen element onto which to anchor the popover.
+ * @param {module:Camera.PopoverArrowDirection} [arrowDir=ARROW_ANY] - Direction the arrow on the popover should point.
+ */
+var CameraPopoverOptions = function (x, y, width, height, arrowDir) {
     // information of rectangle that popover should be anchored to
     this.x = x || 0;
     this.y = y || 32;
     this.width = width || 320;
     this.height = height || 480;
-    // The direction of the popover arrow
     this.arrowDir = arrowDir || Camera.PopoverArrowDirection.ARROW_ANY;
 };
 

www/blackberry10/assets/camera.html

@@ -1,82 +0,0 @@
-<!--
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
- -->
-<!DOCTYPE HTML>
-<html lang="en">
-    <head>
-        <meta charset="utf-8">
-        <script src="camera.js" type="text/javascript"></script>
-        <script>
-            var meta = document.createElement("meta");
-            meta.setAttribute('name','viewport');
-            meta.setAttribute('content','initial-scale='+ (1/window.devicePixelRatio) + ',user-scalable=no');
-            document.getElementsByTagName('head')[0].appendChild(meta);
-        </script>
-    </head>
-    <style type="text/css">
-        body {
-            background-color: black;
-        }
-        .action-bar {
-            position: fixed;
-            left: 0px;
-            bottom: 0px;
-            height: 100px;
-            width: 100%;
-            background-image: linear-gradient(rgb(41, 41, 41), rgb(32, 32, 32));
-        }
-        .action-bar-back {
-            width: 78px;
-            height: 100px;
-            background-color: black;
-        }
-        .action-bar-divider {
-            position: fixed;
-            bottom: 0px;
-            left: 78px;
-            width: 28px;
-            height: 100px;
-            background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABwAAABkCAYAAACVfFA4AAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH3ggLDiUo1ElOKAAABHdJREFUaN612ktvE1cUB/Bz7bGdGcePJk1i4tA0DomCRJUQEGphAa3KQwGpUHWFYMEiIBZdtKgfADbdsekXaFW1XZUuQAiFh0BRi+iqap2EJrUSJSjg2I7Hk3GmdmwPi5Z4ziQEx57/XeXKUn6255w558y1ICKTUOvKverfpkl0/ahwEXKZ1c/iLhlERAQDu85etcrkX3mGBbPhPiIhXnkUyPyNBfO+1upGEIUyU1iQXG52LSd/HRNY0BIwPiNbfR8Iq+3CN5brZ5KiJrBgLrCT7cPpKSxYlPyWgBE0e/d7AQMHDh0nEhavVOSx5DRodA6zm6WSX8SC2dYBFjCvEh4GrsjtbB9MT2BB0+Vh++nx2wIG7jp2liW8VNQ23oAc/To79lavH5nkV+ewoBrqsVak9Rs2DCx4Q6xCfDbUKcHA/R+dsnydRKJSputfXyvDwHSgl1cIPbl51XLs+rXvYQnfnJ3BgprSyfah1AQWrLh9ZI2YxKNfBAzs//A0a2/da/nXdx5OgHpkH9sr2jwWVFv6eIVIT2HBVV8Lq/DB9CQWZP/GrNDTJw8FDIydHGUB4zXStb61OvOvY5BXiOUEFlSb3+EVYouAcQQsSTKrEHP3fxQwsP/gCdYSukqF7YRXHS1hlLeE8v8zIAzMtu62tYTTWDAvt7HrF0jFsaApJBahM7+NCRjYe+wcS3hPIbfde9I2W8LIEK8Q2QQWVEMxFjDB1CQWLHoCrEIs3P1OwMD/WkKLV16rp67UvpYCu1jCN+kvsKC9JfQvT2NBXdnB9rUkfEMgawkF0ez4TQEDe4+c4S1hMV9vM1Jjw7RjH3vapGwyAzoKqm/1sSmp+Q0VvmHQ8IVZwn85MuSFguwpYaVMX31+eQ0Gdo9cZDOgdzXdSAdbQ0sYGeQBk5nBgiuBnSxggqm/sGDJrbCAmX/0s4CBvQdPsIR3rRmNTiFvagmtM6BJsraABXMtA+xYwJ96igVXlTZbhZjAgqZLYl9p4vf7Agb2fHyOPyU0VCdG1y3yr3Mvr/A1toR1g1qwh+39S3EsWPTylnDxwQ8CBg7bW0LbsYDj4FKQt4Q+/TkW1Nre4+dIqSksqPt5SxhMxbFgxW09FhA09/iOgIGxw2fY9XMXdSefWW0yUkeHWYTK6iwW1MJ9tC6aJvlrnAHrBo0m/pTwxtVRFxQk6+8KKmU69P4BEwZ2j4w23BJuC1Q7hnjC284BHQd128FxczKOBcuSwhL+2fgNAQNjHxznLWHJIKfWpqDRxY8FmnILWFCzPSV0IuG3BPPK2yzho//OYUESHjYl/fHgloCB3UfPs4T3GMvk5NoA5iODvEJk/sGCWijGK8RSHAvaW8LnD38SUJDFTrlITi8GRj/5gr3oW1nEglo7bwnlOmfAmkFdiVjv1xRI/okFTclrHQFp/smYgIHvHv6U/5awoBFirYOr0WH2gpydxYK5cD+vEA4n/Aaw0BRiCZ+8962AgrwlLBFquYiIuk5ess2ASRgoERHp7XtIUGUdlTPTVACBLwEignyX5voIbgAAAABJRU5ErkJggg==);
-        }
-        .action-bar-back-button {
-            position: fixed;
-            bottom: 35px;
-            left: 34px;
-            width: 18px;
-            height: 28px;
-            background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABIAAAAcCAYAAABsxO8nAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH3ggLDh43ZfOs5QAAAvdJREFUOMuVlU9LMm0Uh6+ZRguUKaNoWbs0QVIMCb9CqQtb1UdI2lS0dBNhn6D2EVQQLaM2UZpTUknRwm3UooI2lTZ/9H42b/M+g2k+A/fmPjcXF+f8OAMg/vVEIhFRLBbF4+Oj0DRNjI2NCem/YsdfJBJhf38fWZbtu4eHBzoGSZJELBZjZ2cHSZKa6nKnkKmpKQ4ODgAQQjhOpVL53UiWZaanp9nY2EDX9ab6+/s76XS6vVFXVxepVIrNzc0fIU9PTySTSSqVCkoriKIozM7OksvlqNVqjpoQwoa8vb217pHL5SKTybC+vk61WnX0o9FocH9/TyKRsCFAs5Hb7SaTybC8vMzn56ej1mg0uL29ZWZmhnq93npqHo+HhYUFlpaW+Pj4sC0ALMuiUCiQTqebIA4jr9dLNptlbm7OYSJJEqZpcnx8zPz8fOuIAEJVVdbW1kilUo7GSpJErVbj8PCQxcXF9lnz+XxidXWVRCLRNJ1qtcr29ja5XO7X0MorKyskk8kmiCzLHB0ddQQBkF9eXnh9fUWSpKboK4rCwMBAR6CuYrGYdbvdBAIBuru77SkJIQiFQoyMjKBpGtVqtT0IyF5cXKAoCuFwGEX5P1qWZeH3+xkeHiafz/P19dUeBFAqlejr68Pv9+NyuWwz0zQJBAKoqkq5XG7qZRMI4OzsDFVVCQQCuFwu+5FhGExMTKCqKtfX1z/CHCCAQqGA1+tlfHzcHgCArutEo1E8Hg+lUgnDMNqDAM7PzxkcHMTv9yPLsg0zDINoNIosy9zd3TlWy48ggJOTE/r7+wkGg47Vapom8XgcRVG4ubmxzVqCAE5PT+nt7SUcDtNoNOx7XdeZnJwE4OrqCsuy2oMA8vk8Q0NDBINBxzYwDINYLMb3xH8FfZv5fD5CoZAN+s5ZPB5H07TOQEII8vk8qqoSjUaxLMu2M02T5+fnzn5HAPV6nVwux+7uLm63277v6emhXC53ZvT3qr28vMTn8zE6OgrA3t4eW1tb/AH4Zo+8fEoEngAAAABJRU5ErkJggg==);
-        }
-        .camera-cross-hairs {
-            position: fixed;
-            top: 50%;
-            left: 50%;
-            -webkit-transform: translate(-50%, -147px);
-            width: 194px;
-            height: 195px;
-            background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMIAAADDCAQAAAB6tAYfAAAAAmJLR0QA/4ePzL8AAAAJcEhZcwAACxMAAAsTAQCanBgAAAAHdElNRQfeCAsPDxicOdibAAACbElEQVR42u3a7U7aYBgG4Oet0yZLTMx2bDu5nYo7nSUmzi34DUSe/bA0UHSDbpS5Xpc/sECNuW/a5yV5I4CI8toL03y31R94ipMy7gj/PKmNp7/lWSx27PEuzkZaxFWe7viJL3EdH8ovS5hnRkTu+K9UcVzGehX0u/WsXxNVt4LcuYLoccb/ok9WGRHzfKWEWS56xvkw2hLue1a3WKuh9L+wluqRD+bH7BdA6Q7qr59mOW1/LBr3Wdky5VlenK9dCattjv2TPdwwXy5oqu4iSQX7VpfsjPVq7OubQ1i8VMLFefndF2j24i7b1O/z6LWJzT4Wtp28K5EcnhKUgBKUgBKUgBKUgBKUgBKUgBKUgBKUgBLeSglP7eFMIgPo5t3Zd2TDyzCWe4/q1X1HPz5HREykM5BJyBsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWhfn05zl95TEMC5zmrO8bPIuzw+zfD44LgIawjxzJe8qIuI2MzIyFnHnWhjATS6avG+zLaFqXz6W0ACO2t9OYj1/DkYJSkAJSkAJSkAJSkAJSkAJSkAJSkAJSkAJb6WE6y+COIzbiGh3WzxmaQ5P7LfYu4dc3oDq4nb0j8yA5ni50yWbHUjsz2bCTQmTlakwVcMeraZ73TyWzftUiYiMjO2Gw1O8H/kUuc+jrd6XUZpsY20ixGrSy+HceXoLN/FxpEVc5elO71+9ydTlxbT73oiq0e5hneei55l1eWVQ1z2jHO8Qyb9QwcZqqS6TPuve8a74e5wz2fiwl22m+C6tjnu9IyngTfsJ8D+4z5r15Y4AAAAASUVORK5CYII=); 
-        }
-    </style>
-    <body>
-        <div id="camera">
-            <video id="v"></video>
-            <div class="camera-cross-hairs"></div>
-        </div>
-        <canvas id="c" style="display: none;"></canvas>
-        <div class="action-bar">
-            <div id="back" class="action-bar-back">
-                <div class="action-bar-back-button"></div>
-            </div>
-            <div class="action-bar-divider"></div>
-        </div>
-    </body>
-</html>

www/blackberry10/assets/camera.js

@@ -1,46 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
-*/
-
-document.addEventListener('DOMContentLoaded', function () {
-    document.getElementById('back').onclick = function () {
-        window.qnx.callExtensionMethod('cordova-plugin-camera', 'cancel');
-    };
-    window.navigator.webkitGetUserMedia(
-        { video: true },
-        function (stream) {
-            var video = document.getElementById('v'),
-                canvas = document.getElementById('c'),
-                camera = document.getElementById('camera');
-            video.autoplay = true;
-            video.width = window.innerWidth;
-            video.height = window.innerHeight - 100;
-            video.src = window.webkitURL.createObjectURL(stream);
-            camera.onclick = function () {
-                canvas.width = video.videoWidth;
-                canvas.height = video.videoHeight;
-                canvas.getContext('2d').drawImage(video, 0, 0, video.videoWidth, video.videoHeight);
-                window.qnx.callExtensionMethod('cordova-plugin-camera', canvas.toDataURL('img/png'));
-            };
-        },
-        function () {
-            window.qnx.callExtensionMethod('cordova-plugin-camera', 'error', 'getUserMedia failed');
-        }
-    );
-});

www/ios/CameraPopoverHandle.js

@@ -22,12 +22,44 @@
 var exec = require('cordova/exec');
 
 /**
- * A handle to an image picker popover.
+ * @namespace navigator
  */
-var CameraPopoverHandle = function() {
-    this.setPosition = function(popoverOptions) {
+
+/**
+ * A handle to an image picker popover.
+ *
+ * __Supported Platforms__
+ *
+ * - iOS
+ *
+ * @example
+ * navigator.camera.getPicture(onSuccess, onFail,
+ * {
+ *     destinationType: Camera.DestinationType.FILE_URI,
+ *     sourceType: Camera.PictureSourceType.PHOTOLIBRARY,
+ *     popoverOptions: new CameraPopoverOptions(300, 300, 100, 100, Camera.PopoverArrowDirection.ARROW_ANY)
+ * });
+ *
+ * // Reposition the popover if the orientation changes.
+ * window.onorientationchange = function() {
+ *     var cameraPopoverHandle = new CameraPopoverHandle();
+ *     var cameraPopoverOptions = new CameraPopoverOptions(0, 0, 100, 100, Camera.PopoverArrowDirection.ARROW_ANY);
+ *     cameraPopoverHandle.setPosition(cameraPopoverOptions);
+ * }
+ * @module CameraPopoverHandle
+ */
+var CameraPopoverHandle = function () {
+    /**
+     * Can be used to reposition the image selection dialog,
+     * for example, when the device orientation changes.
+     * @memberof CameraPopoverHandle
+     * @instance
+     * @method setPosition
+     * @param {module:CameraPopoverOptions} popoverOptions
+     */
+    this.setPosition = function (popoverOptions) {
         var args = [ popoverOptions ];
-        exec(null, null, "Camera", "repositionPopover", args);
+        exec(null, null, 'Camera', 'repositionPopover', args);
     };
 };