CB-7571 Updated version and RELEASENOTES.md for release 0.3.2

Signed-off-by: Shazron Abdullah <shazron@apache.org>

CONTRIBUTING.md

@@ -0,0 +1,37 @@
+<!--
+#
+# 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.
+#
+-->
+
+# Contributing to Apache Cordova
+
+Anyone can contribute to Cordova. And we need your contributions.
+
+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).
+
+The details are explained there, but the important items are:
+ - Sign and submit an Apache ICLA (Contributor License Agreement).
+ - Have a Jira issue open that corresponds to your contribution.
+ - Run the tests so your patch doesn't break existing functionality.
+
+We look forward to your contributions!

RELEASENOTES.md

@@ -80,3 +80,70 @@
 * 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

doc/de/index.md

@@ -0,0 +1,409 @@
+<!---
+    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.
+-->
+
+# org.apache.cordova.camera
+
+Dieses Plugin stellt eine API für Aufnahmen und für die Auswahl der Bilder aus dem System-Image-Library.
+
+    cordova plugin add org.apache.cordova.camera
+    
+
+## navigator.camera.getPicture
+
+Nimmt ein Foto mit der Kamera, oder ein Foto aus dem Gerät Bildergalerie abgerufen. Das Bild wird an den Erfolg-Rückruf als eine base64-codierte übergeben `String` , oder als den URI für die Image-Datei. Die Methode selbst gibt ein `CameraPopoverHandle` -Objekt, das verwendet werden kann, um die Datei-Auswahl-Popover neu zu positionieren.
+
+    navigator.camera.getPicture( cameraSuccess, cameraError, cameraOptions );
+    
+
+### Beschreibung
+
+Die `camera.getPicture` -Funktion öffnet das Gerät Standard-Kamera-Anwendung, die Benutzern ermöglicht, Bilder ausrichten. Dieses Verhalten tritt standardmäßig, wenn `Camera.sourceType` gleich `Camera.PictureSourceType.CAMERA` . Sobald der Benutzer die Fotoschnäpper, die Kameraanwendung geschlossen wird und die Anwendung wird wiederhergestellt.
+
+Wenn `Camera.sourceType` ist `Camera.PictureSourceType.PHOTOLIBRARY` oder `Camera.PictureSourceType.SAVEDPHOTOALBUM` , dann ein Dialog-Displays, die Benutzern ermöglicht, ein vorhandenes Bild auszuwählen. Die `camera.getPicture` Funktion gibt ein `CameraPopoverHandle` -Objekt, das verwendet werden kann, um den Bild-Auswahl-Dialog, zum Beispiel beim ändert sich der Orientierung des Geräts neu positionieren.
+
+Der Rückgabewert wird gesendet, um die `cameraSuccess` Callback-Funktion in einem der folgenden Formate, je nach dem angegebenen `cameraOptions` :
+
+*   A `String` mit dem base64-codierte Foto-Bild.
+
+*   A `String` , die die Bild-Datei-Stelle auf lokalem Speicher (Standard).
+
+Sie können tun, was Sie wollen, mit dem codierten Bildes oder URI, zum Beispiel:
+
+*   Rendern Sie das Bild in ein `<img>` Tag, wie im folgenden Beispiel
+
+*   Die Daten lokal zu speichern ( `LocalStorage` , [Lawnchair][1], etc..)
+
+*   Post die Daten an einen entfernten server
+
+ [1]: http://brianleroux.github.com/lawnchair/
+
+**Hinweis**: Fotoauflösung auf neueren Geräten ist ganz gut. Fotos aus dem Gerät Galerie ausgewählt sind nicht zu einer niedrigeren Qualität herunterskaliert auch wenn ein `quality` -Parameter angegeben wird. Um Speicherprobleme zu vermeiden, legen Sie `Camera.destinationType` auf `FILE_URI` statt`DATA_URL`.
+
+### Unterstützte Plattformen
+
+*   Amazon Fire OS
+*   Android
+*   BlackBerry 10
+*   Browser
+*   Firefox OS
+*   iOS
+*   Tizen
+*   Windows Phone 7 und 8
+*   Windows 8
+
+### "Einstellungen" (iOS)
+
+*   **CameraUsesGeolocation** (Boolean, Standardwert ist False). Zur Erfassung von JPEGs, auf true festgelegt, um Geolocation-Daten im EXIF-Header zu erhalten. Dies löst einen Antrag auf Geolocation-Berechtigungen, wenn auf True festgelegt.
+    
+        <preference name="CameraUsesGeolocation" value="false" />
+        
+
+### Amazon Fire OS Macken
+
+Amazon Fire OS verwendet Absichten zum Starten von der Kamera-Aktivität auf dem Gerät, um Bilder zu erfassen und auf Handys mit wenig Speicher, Cordova Tätigkeit getötet werden kann. In diesem Szenario kann das Bild nicht angezeigt, wenn die Aktivität von Cordova wiederhergestellt wird.
+
+### Android Macken
+
+Android verwendet Absichten zum Starten von der Kamera-Aktivität auf dem Gerät, um Bilder zu erfassen und auf Handys mit wenig Speicher, Cordova Tätigkeit getötet werden kann. In diesem Szenario kann das Bild nicht angezeigt, wenn die Aktivität von Cordova wiederhergestellt wird.
+
+### Browser-Eigenheiten
+
+Fotos können nur als base64-codierte Bild zurückgeben werden.
+
+### Firefox OS Macken
+
+Kamera-Plugin ist derzeit implementiert mithilfe von [Web-Aktivitäten][2].
+
+ [2]: https://hacks.mozilla.org/2013/01/introducing-web-activities/
+
+### iOS Macken
+
+Darunter eine JavaScript `alert()` entweder des Rückrufs Funktionen können Probleme verursachen. Wickeln Sie die Warnung innerhalb einer `setTimeout()` erlauben die iOS-Bild-Picker oder Popover vollständig zu schließen, bevor die Warnung angezeigt:
+
+    setTimeout(function() {/ / Mach dein Ding hier!}, 0);
+    
+
+### Windows Phone 7 Macken
+
+Die native Kameraanwendung aufrufen, während das Gerät via Zune angeschlossen ist funktioniert nicht und löst eine Fehler-Callback.
+
+### Tizen Macken
+
+Tizen unterstützt nur eine `destinationType` der `Camera.DestinationType.FILE_URI` und eine `sourceType` von`Camera.PictureSourceType.PHOTOLIBRARY`.
+
+### Beispiel
+
+Nehmen Sie ein Foto und rufen Sie sie als base64-codierte Bild:
+
+    navigator.camera.getPicture(onSuccess, onFail, { quality: 50,
+        destinationType: Camera.DestinationType.DATA_URL
+    });
+    
+    function onSuccess(imageData) {
+        var image = document.getElementById('myImage');
+        image.src = "data:image/jpeg;base64," + imageData;
+    }
+    
+    function onFail(message) {
+        alert('Failed because: ' + message);
+    }
+    
+
+Nehmen Sie ein Foto und rufen Sie das Bild-Datei-Speicherort:
+
+    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);
+    }
+    
+
+## CameraOptions
+
+Optionale Parameter die Kameraeinstellungen anpassen.
+
+    {Qualität: 75, DestinationType: Camera.DestinationType.DATA_URL, SourceType: Camera.PictureSourceType.CAMERA, AllowEdit: stimmt, EncodingType: Camera.EncodingType.JPEG, TargetWidth: 100, TargetHeight: 100, PopoverOptions: CameraPopoverOptions, SaveToPhotoAlbum: false};
+    
+
+### Optionen
+
+*   **Qualität**: Qualität des gespeicherten Bildes, ausgedrückt als ein Bereich von 0-100, wo 100 in der Regel voller Auflösung ohne Verlust aus der Dateikomprimierung ist. Der Standardwert ist 50. *(Anzahl)* (Beachten Sie, dass Informationen über die Kamera Auflösung nicht verfügbar ist.)
+
+*   **DestinationType**: Wählen Sie das Format des Rückgabewerts. Der Standardwert ist FILE_URI. Im Sinne `navigator.camera.DestinationType` *(Anzahl)*
+    
+        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**: Legen Sie die Quelle des Bildes. Der Standardwert ist die Kamera. Im Sinne `navigator.camera.PictureSourceType` *(Anzahl)*
+    
+        Camera.PictureSourceType = {
+            PHOTOLIBRARY : 0,
+            CAMERA : 1,
+            SAVEDPHOTOALBUM : 2
+        };
+        
+
+*   **AllowEdit**: einfache Bearbeitung des Bildes vor Auswahl zu ermöglichen. *(Boolesch)*
+
+*   **EncodingType**: die zurückgegebene Image-Datei ist Codierung auswählen. Standardwert ist JPEG. Im Sinne `navigator.camera.EncodingType` *(Anzahl)*
+    
+        Camera.EncodingType = {
+            JPEG : 0,               // Return JPEG encoded image
+            PNG : 1                 // Return PNG encoded image
+        };
+        
+
+*   **TargetWidth**: Breite in Pixel zum Bild skalieren. Muss mit **TargetHeight**verwendet werden. Seitenverhältnis bleibt konstant. *(Anzahl)*
+
+*   **TargetHeight**: Höhe in Pixel zum Bild skalieren. Muss mit **TargetWidth**verwendet werden. Seitenverhältnis bleibt konstant. *(Anzahl)*
+
+*   **MediaType**: Legen Sie den Typ der Medien zur Auswahl. Funktioniert nur, wenn `PictureSourceType` ist `PHOTOLIBRARY` oder `SAVEDPHOTOALBUM` . Im Sinne `nagivator.camera.MediaType` *(Anzahl)*
+    
+        Camera.MediaType = {
+            PICTURE: 0,    // allow selection of still pictures only. STANDARD. 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**: Drehen Sie das Bild um die Ausrichtung des Geräts während der Aufnahme zu korrigieren. *(Boolesch)*
+
+*   **SaveToPhotoAlbum**: das Bild auf das Fotoalbum auf dem Gerät zu speichern, nach Einnahme. *(Boolesch)*
+
+*   **PopoverOptions**: iOS-nur Optionen, die Popover Lage in iPad angeben. In definierten`CameraPopoverOptions`.
+
+*   **CameraDirection**: Wählen Sie die Kamera (vorn oder hinten-gerichtete) verwenden. Der Standardwert ist zurück. Im Sinne `navigator.camera.Direction` *(Anzahl)*
+    
+        Camera.Direction = {
+            BACK : 0,      // Use the back-facing camera
+            FRONT : 1      // Use the front-facing camera
+        };
+        
+
+### Amazon Fire OS Macken
+
+*   `cameraDirection`Ergebnisse in einem hinten gerichteter Foto Wert.
+
+*   Ignoriert die `allowEdit` Parameter.
+
+*   `Camera.PictureSourceType.PHOTOLIBRARY`und `Camera.PictureSourceType.SAVEDPHOTOALBUM` beide das gleiche Fotoalbum anzuzeigen.
+
+### Android Macken
+
+*   `cameraDirection`Ergebnisse in einem hinten gerichteter Foto Wert.
+
+*   Ignoriert die `allowEdit` Parameter.
+
+*   `Camera.PictureSourceType.PHOTOLIBRARY`und `Camera.PictureSourceType.SAVEDPHOTOALBUM` beide das gleiche Fotoalbum anzuzeigen.
+
+### BlackBerry 10 Macken
+
+*   Ignoriert die `quality` Parameter.
+
+*   Ignoriert die `allowEdit` Parameter.
+
+*   `Camera.MediaType`wird nicht unterstützt.
+
+*   Ignoriert die `correctOrientation` Parameter.
+
+*   Ignoriert die `cameraDirection` Parameter.
+
+### Firefox OS Macken
+
+*   Ignoriert die `quality` Parameter.
+
+*   `Camera.DestinationType`wird ignoriert, und gleich `1` (Bilddatei-URI)
+
+*   Ignoriert die `allowEdit` Parameter.
+
+*   Ignoriert die `PictureSourceType` Parameter (Benutzer wählt es in einem Dialogfenster)
+
+*   Ignoriert die`encodingType`
+
+*   Ignoriert die `targetWidth` und`targetHeight`
+
+*   `Camera.MediaType`wird nicht unterstützt.
+
+*   Ignoriert die `correctOrientation` Parameter.
+
+*   Ignoriert die `cameraDirection` Parameter.
+
+### iOS Macken
+
+*   Legen Sie `quality` unter 50 Speicherfehler auf einigen Geräten zu vermeiden.
+
+*   Bei der Verwendung `destinationType.FILE_URI` , Fotos werden im temporären Verzeichnis der Anwendung gespeichert. Den Inhalt des temporären Verzeichnis der Anwendung wird gelöscht, wenn die Anwendung beendet.
+
+### Tizen Macken
+
+*   nicht unterstützte Optionen
+
+*   gibt immer einen Datei-URI
+
+### Windows Phone 7 und 8 Macken
+
+*   Ignoriert die `allowEdit` Parameter.
+
+*   Ignoriert die `correctOrientation` Parameter.
+
+*   Ignoriert die `cameraDirection` Parameter.
+
+*   Ignoriert die `saveToPhotoAlbum` Parameter. WICHTIG: Alle Aufnahmen die wp7/8 Cordova-Kamera-API werden immer in Kamerarolle des Telefons kopiert. Abhängig von den Einstellungen des Benutzers könnte dies auch bedeuten, dass das Bild in ihre OneDrive automatisch hochgeladen ist. Dies könnte möglicherweise bedeuten, dass das Bild für ein breiteres Publikum als Ihre Anwendung vorgesehen ist. Wenn diese einen Blocker für Ihre Anwendung, Sie müssen die CameraCaptureTask zu implementieren, wie im Msdn dokumentiert: <http://msdn.microsoft.com/en-us/library/windowsphone/develop/hh394006.aspx> Sie können kommentieren oder Up-Abstimmung das Beiträge zu diesem Thema im [Bugtracker][3]
+
+*   Ignoriert die `mediaType` -Eigenschaft des `cameraOptions` wie das Windows Phone SDK keine Möglichkeit, Fotothek Videos wählen.
+
+ [3]: https://issues.apache.org/jira/browse/CB-2083
+
+## CameraError
+
+OnError-Callback-Funktion, die eine Fehlermeldung bereitstellt.
+
+    function(message) {
+        // Show a helpful message
+    }
+    
+
+### Parameter
+
+*   **Meldung**: die Nachricht wird durch das Gerät systemeigenen Code bereitgestellt. *(String)*
+
+## cameraSuccess
+
+OnSuccess Callback-Funktion, die die Bilddaten bereitstellt.
+
+    function(imageData) {
+        // Do something with the image
+    }
+    
+
+### Parameter
+
+*   **CMYK**: Base64-Codierung der Bilddaten, *oder* die Image-Datei-URI, je nach `cameraOptions` in Kraft. *(String)*
+
+### Beispiel
+
+    // Show image
+    //
+    function cameraCallback(imageData) {
+        var image = document.getElementById('myImage');
+        image.src = "data:image/jpeg;base64," + imageData;
+    }
+    
+
+## CameraPopoverHandle
+
+Ein Handle für das Dialogfeld "Popover" erstellt von`navigator.camera.getPicture`.
+
+### Methoden
+
+*   **SetPosition**: Legen Sie die Position der Popover.
+
+### Unterstützte Plattformen
+
+*   iOS
+
+### setPosition
+
+Legen Sie die Position von der Popover.
+
+**Parameter**:
+
+*   `cameraPopoverOptions`: die `CameraPopoverOptions` angeben, dass die neue Position
+
+### Beispiel
+
+     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)
+         });
+    
+     // 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);
+     }
+    
+
+## CameraPopoverOptions
+
+nur iOS-Parametern, die Anker-Element Lage und Pfeil Richtung der Popover angeben, bei der Auswahl von Bildern aus einem iPad Bibliothek oder Album.
+
+    {X: 0, y: 32, Breite: 320, Höhe: 480, ArrowDir: Camera.PopoverArrowDirection.ARROW_ANY};
+    
+
+### CameraPopoverOptions
+
+*   **X**: x Pixelkoordinate des Bildschirmelement auf dem der Popover zu verankern. *(Anzahl)*
+
+*   **y**: y Pixelkoordinate des Bildschirmelement auf dem der Popover zu verankern. *(Anzahl)*
+
+*   **Breite**: Breite in Pixeln, das Bildschirmelement auf dem der Popover zu verankern. *(Anzahl)*
+
+*   **Höhe**: Höhe in Pixeln, das Bildschirmelement auf dem der Popover zu verankern. *(Anzahl)*
+
+*   **ArrowDir**: Richtung der Pfeil auf der Popover zeigen sollte. Im Sinne `Camera.PopoverArrowDirection` *(Anzahl)*
+    
+            Camera.PopoverArrowDirection = {
+                ARROW_UP : 1,        // matches iOS UIPopoverArrowDirection constants
+                ARROW_DOWN : 2,
+                ARROW_LEFT : 4,
+                ARROW_RIGHT : 8,
+                ARROW_ANY : 15
+            };
+        
+
+Beachten Sie, dass die Größe der Popover ändern kann, um die Richtung des Pfeils und Ausrichtung des Bildschirms anzupassen. Achten Sie darauf, um Orientierung zu berücksichtigen, wenn Sie den Anker-Element-Speicherort angeben.
+
+## Navigator.Camera.Cleanup
+
+Entfernt Mittelstufe Fotos von der Kamera aus der vorübergehenden Verwahrung genommen.
+
+    navigator.camera.cleanup( cameraSuccess, cameraError );
+    
+
+### Beschreibung
+
+Entfernt Mittelstufe Image-Dateien, die nach der Berufung in vorübergehender Verwahrung gehalten werden `camera.getPicture` . Gilt nur, wenn der Wert des `Camera.sourceType` ist gleich `Camera.PictureSourceType.CAMERA` und der `Camera.destinationType` entspricht`Camera.DestinationType.FILE_URI`.
+
+### Unterstützte Plattformen
+
+*   iOS
+
+### Beispiel
+
+    navigator.camera.cleanup(onSuccess, onFail);
+    
+    function onSuccess() {
+        console.log("Camera cleanup success.")
+    }
+    
+    function onFail(message) {
+        alert('Failed because: ' + message);
+    }

doc/es/index.md

@@ -0,0 +1,424 @@
+<!---
+    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.
+-->
+
+# org.apache.cordova.camera
+
+Este plugin proporciona una API para tomar fotografías y por elegir imágenes de biblioteca de imágenes del sistema.
+
+    cordova plugin add org.apache.cordova.camera
+    
+
+## navigator.camera.getPicture
+
+Toma una foto con la cámara, o recupera una foto de Galería de imágenes del dispositivo. La imagen se pasa a la devolución de llamada de éxito como un codificado en base64 `String` , o como el URI para el archivo de imagen. El método se devuelve un `CameraPopoverHandle` objeto que puede utilizarse para volver a colocar el popover de selección de archivo.
+
+    navigator.camera.getPicture( cameraSuccess, cameraError, cameraOptions );
+    
+
+### Descripción
+
+El `camera.getPicture` función abre la aplicación de cámara predeterminada del dispositivo que permite a los usuarios ajustar imágenes. Este comportamiento se produce de forma predeterminada, cuando `Camera.sourceType` es igual a `Camera.PictureSourceType.CAMERA` . Una vez que el usuario ajusta la foto, una aplicación de cámara se cierra y se restablecerá la aplicación.
+
+Si `Camera.sourceType` es `Camera.PictureSourceType.PHOTOLIBRARY` o `Camera.PictureSourceType.SAVEDPHOTOALBUM` , entonces una muestra de diálogo que permite a los usuarios seleccionar una imagen existente. El `camera.getPicture` función devuelve un `CameraPopoverHandle` objeto, que puede utilizarse para volver a colocar el diálogo de selección de imagen, por ejemplo, cuando cambia la orientación del dispositivo.
+
+El valor devuelto es enviado a la `cameraSuccess` función de callback, en uno de los formatos siguientes, dependiendo del objeto `cameraOptions` :
+
+*   A `String` que contiene la imagen codificada en base64.
+
+*   A `String` que representa la ubicación del archivo de imagen de almacenamiento local (por defecto).
+
+Puedes hacer lo que quieras con la imagen codificada o URI, por ejemplo:
+
+*   Utilidad de la imagen en un `<img>` etiqueta, como en el ejemplo siguiente
+
+*   Guardar los datos localmente ( `LocalStorage` , [Lawnchair][1], etc..)
+
+*   Enviar los datos a un servidor remoto
+
+ [1]: http://brianleroux.github.com/lawnchair/
+
+**Nota**: resolución de la foto en los nuevos dispositivos es bastante bueno. Fotos seleccionadas de la Galería del dispositivo no son degradadas a una calidad más baja, incluso si un `quality` se especifica el parámetro. Para evitar problemas con la memoria común, establezca `Camera.destinationType` a `FILE_URI` en lugar de`DATA_URL`.
+
+### Plataformas soportadas
+
+*   Amazon fuego OS
+*   Android
+*   BlackBerry 10
+*   Explorador
+*   Firefox OS
+*   iOS
+*   Tizen
+*   Windows Phone 7 y 8
+*   Windows 8
+
+### Preferencias (iOS)
+
+*   **CameraUsesGeolocation** (booleano, el valor predeterminado de false). Para la captura de imágenes JPEG, establecido en true para obtener datos de geolocalización en la cabecera EXIF. Esto activará la solicitud de permisos de geolocalización si establecido en true.
+    
+        <preference name="CameraUsesGeolocation" value="false" />
+        
+
+### Amazon fuego OS rarezas
+
+Amazon fuego OS utiliza los intentos para poner en marcha la actividad de la cámara del dispositivo para capturar imágenes y en teléfonos con poca memoria, puede matar la actividad Cordova. En este escenario, la imagen no aparezca cuando se restaura la actividad cordova.
+
+### Rarezas Android
+
+Android utiliza los intentos para iniciar la actividad de la cámara del dispositivo para capturar imágenes, y en los teléfonos con poca memoria, puede matar la actividad Cordova. En este escenario, la imagen no aparezca cuando se restaura la actividad Cordova.
+
+### Navegador rarezas
+
+Sólo puede devolver fotos como imagen codificada en base64.
+
+### Firefox OS rarezas
+
+Cámara plugin actualmente se implementa mediante [Actividades Web][2].
+
+ [2]: https://hacks.mozilla.org/2013/01/introducing-web-activities/
+
+### iOS rarezas
+
+Incluyendo un JavaScript `alert()` en cualquiera de la devolución de llamada funciones pueden causar problemas. Envuelva la alerta dentro de un `setTimeout()` para permitir que el selector de imagen iOS o popover cerrar completamente antes de la alerta se muestra:
+
+    setTimeout(function() {
+        // do your thing here!
+    }, 0);
+    
+
+### Windows Phone 7 rarezas
+
+Invocando la aplicación de cámara nativa mientras el dispositivo está conectado vía Zune no funciona y desencadena un callback de error.
+
+### Rarezas Tizen
+
+Tizen sólo es compatible con un `destinationType` de `Camera.DestinationType.FILE_URI` y un `sourceType` de`Camera.PictureSourceType.PHOTOLIBRARY`.
+
+### Ejemplo
+
+Tomar una foto y recuperarlo como una imagen codificada en base64:
+
+    navigator.camera.getPicture(onSuccess, onFail, { quality: 50,
+        destinationType: Camera.DestinationType.DATA_URL
+    });
+    
+    function onSuccess(imageData) {
+        var image = document.getElementById('myImage');
+        image.src = "data:image/jpeg;base64," + imageData;
+    }
+    
+    function onFail(message) {
+        alert('Failed because: ' + message);
+    }
+    
+
+Tomar una foto y recuperar la ubicación del archivo de la imagen:
+
+    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);
+    }
+    
+
+## CameraOptions
+
+Parámetros opcionales para personalizar la configuración de la cámara.
+
+    { 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 };
+    
+
+### Opciones
+
+*   **calidad**: calidad de la imagen guardada, expresada en un rango de 0-100, donde 100 es típicamente resolución sin pérdida de compresión del archivo. El valor predeterminado es 50. *(Número)* (Tenga en cuenta que no está disponible información sobre resolución de la cámara).
+
+*   **destinationType**: elegir el formato del valor devuelto. El valor predeterminado es FILE_URI. Definido en `navigator.camera.DestinationType` *(número)*
+    
+        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**: establecer el origen de la imagen. El valor predeterminado es cámara. Definido en `navigator.camera.PictureSourceType` *(número)*
+    
+        Camera.PictureSourceType = {
+            PHOTOLIBRARY : 0,
+            CAMERA : 1,
+            SAVEDPHOTOALBUM : 2
+        };
+        
+
+*   **allowEdit**: permite edición sencilla de imagen antes de la selección. *(Booleano)*
+
+*   **encodingType**: elegir la codificación del archivo de imagen devuelta. Por defecto es JPEG. Definido en `navigator.camera.EncodingType` *(número)*
+    
+        Camera.EncodingType = {
+            JPEG : 0,               // Return JPEG encoded image
+            PNG : 1                 // Return PNG encoded image
+        };
+        
+
+*   **targetWidth**: ancho en píxeles a escala de la imagen. Debe usarse con **targetHeight**. Proporción se mantiene constante. *(Número)*
+
+*   **targetHeight**: altura en píxeles a escala de la imagen. Debe usarse con **targetWidth**. Proporción se mantiene constante. *(Número)*
+
+*   **mediaType**: definir el tipo de medios para seleccionar. Sólo funciona cuando `PictureSourceType` es `PHOTOLIBRARY` o `SAVEDPHOTOALBUM` . Definido en `nagivator.camera.MediaType` *(número)*
+    
+        Camera.MediaType = {
+            PICTURE: 0,    // allow selection of still pictures only. DE FORMA PREDETERMINADA. 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**: rotar la imagen para corregir la orientación del dispositivo durante la captura. *(Booleano)*
+
+*   **saveToPhotoAlbum**: guardar la imagen en el álbum de fotos en el dispositivo después de su captura. *(Booleano)*
+
+*   **popoverOptions**: opciones sólo iOS que especifican popover ubicación en iPad. Definido en`CameraPopoverOptions`.
+
+*   **cameraDirection**: elegir la cámara para usar (o parte posterior-frontal). El valor predeterminado es atrás. Definido en `navigator.camera.Direction` *(número)*
+    
+        Camera.Direction = {
+            BACK : 0,      // Use the back-facing camera
+            FRONT : 1      // Use the front-facing camera
+        };
+        
+
+### Amazon fuego OS rarezas
+
+*   Cualquier `cameraDirection` valor resultados en una foto orientada hacia atrás.
+
+*   Ignora el `allowEdit` parámetro.
+
+*   `Camera.PictureSourceType.PHOTOLIBRARY`y `Camera.PictureSourceType.SAVEDPHOTOALBUM` ambas muestran el mismo álbum de fotos.
+
+### Rarezas Android
+
+*   Cualquier `cameraDirection` valor resultados en una foto orientada hacia atrás.
+
+*   Ignora el `allowEdit` parámetro.
+
+*   `Camera.PictureSourceType.PHOTOLIBRARY`y `Camera.PictureSourceType.SAVEDPHOTOALBUM` ambas muestran el mismo álbum de fotos.
+
+### BlackBerry 10 rarezas
+
+*   Ignora el `quality` parámetro.
+
+*   Ignora el `allowEdit` parámetro.
+
+*   `Camera.MediaType`No se admite.
+
+*   Ignora el `correctOrientation` parámetro.
+
+*   Ignora el `cameraDirection` parámetro.
+
+### Firefox OS rarezas
+
+*   Ignora el `quality` parámetro.
+
+*   `Camera.DestinationType`se ignora y es igual a `1` (URI del archivo de imagen)
+
+*   Ignora el `allowEdit` parámetro.
+
+*   Ignora el `PictureSourceType` parámetro (el usuario lo elige en una ventana de diálogo)
+
+*   Ignora el`encodingType`
+
+*   Ignora el `targetWidth` y`targetHeight`
+
+*   `Camera.MediaType`No se admite.
+
+*   Ignora el `correctOrientation` parámetro.
+
+*   Ignora el `cameraDirection` parámetro.
+
+### iOS rarezas
+
+*   Establecer `quality` por debajo de 50 para evitar errores de memoria en algunos dispositivos.
+
+*   Cuando se utiliza `destinationType.FILE_URI` , fotos se guardan en el directorio temporal de la aplicación. El contenido del directorio temporal de la aplicación se eliminará cuando finalice la aplicación.
+
+### Rarezas Tizen
+
+*   opciones no compatibles
+
+*   siempre devuelve un identificador URI de archivo
+
+### Windows Phone 7 y 8 rarezas
+
+*   Ignora el `allowEdit` parámetro.
+
+*   Ignora el `correctOrientation` parámetro.
+
+*   Ignora el `cameraDirection` parámetro.
+
+*   Ignora el `saveToPhotoAlbum` parámetro. IMPORTANTE: Todas las imágenes tomadas con la cámara wp7/8 cordova API siempre se copian en rollo de cámara del teléfono. Dependiendo de la configuración del usuario, esto podría significar también que la imagen es auto-subido a su OneDrive. Esto potencialmente podría significar que la imagen está disponible a una audiencia más amplia que su aplicación previsto. Si un bloqueador para su aplicación, usted necesitará aplicar el CameraCaptureTask como se documenta en msdn: <http://msdn.microsoft.com/en-us/library/windowsphone/develop/hh394006.aspx> también puede comentar o votar hasta el tema relacionado en el [issue tracker de][3]
+
+*   Ignora el `mediaType` propiedad de `cameraOptions` como el SDK de Windows Phone no proporciona una manera para elegir vídeos fototeca.
+
+ [3]: https://issues.apache.org/jira/browse/CB-2083
+
+## CameraError
+
+onError función callback que proporciona un mensaje de error.
+
+    function(message) {
+        // Show a helpful message
+    }
+    
+
+### Parámetros
+
+*   **mensaje**: el mensaje es proporcionado por código nativo del dispositivo. *(String)*
+
+## cameraSuccess
+
+onSuccess función callback que proporciona los datos de imagen.
+
+    function(imageData) {
+        // Do something with the image
+    }
+    
+
+### Parámetros
+
+*   **imageData**: codificación en Base64 de los datos de imagen, *o* el archivo de imagen URI, dependiendo de `cameraOptions` en vigor. *(String)*
+
+### Ejemplo
+
+    // Show image
+    //
+    function cameraCallback(imageData) {
+        var image = document.getElementById('myImage');
+        image.src = "data:image/jpeg;base64," + imageData;
+    }
+    
+
+## CameraPopoverHandle
+
+Un identificador para el cuadro de diálogo popover creado por`navigator.camera.getPicture`.
+
+### Métodos
+
+*   **setPosition**: establecer la posición de la popover.
+
+### Plataformas soportadas
+
+*   iOS
+
+### setPosition
+
+Establecer la posición de la popover.
+
+**Parámetros**:
+
+*   `cameraPopoverOptions`: el `CameraPopoverOptions` que especifican la nueva posición
+
+### Ejemplo
+
+     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)
+         });
+    
+     // 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);
+     }
+    
+
+## CameraPopoverOptions
+
+Sólo iOS parámetros que especifican la dirección ancla elemento ubicación y la flecha de la popover al seleccionar imágenes de biblioteca o álbum de un iPad.
+
+    { x : 0,
+      y :  32,
+      width : 320,
+      height : 480,
+      arrowDir : Camera.PopoverArrowDirection.ARROW_ANY
+    };
+    
+
+### CameraPopoverOptions
+
+*   **x**: coordenadas de píxeles del elemento de la pantalla en la que anclar el popover x. *(Número)*
+
+*   **y**: coordenada píxeles del elemento de la pantalla en la que anclar el popover. *(Número)*
+
+*   **anchura**: anchura, en píxeles, del elemento sobre el que anclar el popover pantalla. *(Número)*
+
+*   **altura**: alto, en píxeles, del elemento sobre el que anclar el popover pantalla. *(Número)*
+
+*   **arrowDir**: dirección de la flecha en el popover debe apuntar. Definido en `Camera.PopoverArrowDirection` *(número)*
+    
+            Camera.PopoverArrowDirection = {
+                ARROW_UP : 1,        // matches iOS UIPopoverArrowDirection constants
+                ARROW_DOWN : 2,
+                ARROW_LEFT : 4,
+                ARROW_RIGHT : 8,
+                ARROW_ANY : 15
+            };
+        
+
+Tenga en cuenta que puede cambiar el tamaño de la popover para ajustar la dirección de la flecha y orientación de la pantalla. Asegúrese de que para tener en cuenta los cambios de orientación cuando se especifica la ubicación del elemento de anclaje.
+
+## Navigator.Camera.Cleanup
+
+Elimina intermedio fotos tomadas por la cámara de almacenamiento temporal.
+
+    navigator.camera.cleanup( cameraSuccess, cameraError );
+    
+
+### Descripción
+
+Elimina intermedio archivos de imagen que se mantienen en depósito temporal después de llamar `camera.getPicture` . Se aplica sólo cuando el valor de `Camera.sourceType` es igual a `Camera.PictureSourceType.CAMERA` y el `Camera.destinationType` es igual a`Camera.DestinationType.FILE_URI`.
+
+### Plataformas soportadas
+
+*   iOS
+
+### Ejemplo
+
+    navigator.camera.cleanup(onSuccess, onFail);
+    
+    function onSuccess() {
+        console.log("Camera cleanup success.")
+    }
+    
+    function onFail(message) {
+        alert('Failed because: ' + message);
+    }

doc/fr/index.md

@@ -0,0 +1,417 @@
+<!---
+    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.
+-->
+
+# org.apache.cordova.camera
+
+Ce plugin fournit une API pour la prise de photos et de choisir des images de la bibliothèque d'images du système.
+
+    cordova plugin add org.apache.cordova.camera
+    
+
+## navigator.camera.getPicture
+
+Prend une photo à l'aide de la caméra, ou récupère une photo de la Galerie d'images de l'appareil. L'image est passée au callback "succès" comme une `String` encodée en base64 ou l'URI du fichier de l'image. La méthode elle-même renvoie un objet `CameraPopoverHandle` qui permet de repositionner la boite de dialogue de selection d'image.
+
+    navigator.camera.getPicture( cameraSuccess, cameraError, cameraOptions );
+    
+
+### Description
+
+La fonction `camera.getPicture` ouvre l'application par défaut de l'appareil qui permet aux utilisateurs de prendre des photos. Ce comportement se produit par défaut, lorsque `Camera.sourceType` est égal à `Camera.PictureSourceType.CAMERA`. Une fois que l'utilisateur a pris la photo, l'application "camera" se ferme et l'application est restaurée.
+
+Si `Camera.sourceType` est `Camera.PictureSourceType.PHOTOLIBRARY` ou `Camera.PictureSourceType.SAVEDPHOTOALBUM`, alors une boîte de dialogue s'affiche pour permettre aux utilisateurs de sélectionner une image existante. La fonction `camera.getPicture` retourne un objet `CameraPopoverHandle` qui permet de repositionner le dialogue de sélection d'image, par exemple, lorsque l'orientation de l'appareil change.
+
+La valeur de retour est envoyée à la fonction callback `cameraSuccess`, dans l'un des formats suivants, selon spécifié par `cameraOptions` :
+
+*   A `String` contenant l'image photo codée en base64.
+
+*   A `String` qui représente l'emplacement du fichier image sur le stockage local (par défaut).
+
+Vous pouvez faire ce que vous voulez avec l'image encodée ou l'URI, par exemple :
+
+*   Afficher l'image dans un `<img>` tag, comme dans l'exemple ci-dessous
+
+*   Enregistrer les données localement ( `LocalStorage` , [poids][1], etc..)
+
+*   Publier les données sur un serveur distant
+
+ [1]: http://brianleroux.github.com/lawnchair/
+
+**NOTE**: la résolution de Photo sur les nouveaux appareils est assez bonne. Les photos sélectionnées de la Galerie de l'appareil ne sont pas réduites avec une baisse de la qualité, même si un paramètre de `qualité` est spécifié. Pour éviter les problèmes de mémoire, définissez `Camera.destinationType` à `FILE_URI` plutôt que `DATA_URL`.
+
+### Plates-formes prises en charge
+
+*   Amazon Fire OS
+*   Android
+*   BlackBerry 10
+*   Navigateur
+*   Firefox OS
+*   iOS
+*   Paciarelli
+*   Windows Phone 7 et 8
+*   Windows 8
+
+### Préférences (iOS)
+
+*   **CameraUsesGeolocation** (boolean, par défaut, false). Pour capturer des images JPEG, true pour obtenir des données de géolocalisation dans l'en-tête EXIF. Cela va déclencher une demande d'autorisations de géolocalisation si défini à true.
+    
+        <preference name="CameraUsesGeolocation" value="false" />
+        
+
+### Amazon Fire OS Quirks
+
+Amazon Fire OS utilise des intentions pour lancer l'activité de l'appareil photo sur l'appareil pour capturer des images et sur les téléphones avec peu de mémoire, l'activité de Cordova peut être tuée. Dans ce scénario, l'image peut ne pas apparaître lorsque l'activité de cordova est restaurée.
+
+### Quirks Android
+
+Android utilise des intentions pour lancer l'activité de l'appareil photo sur l'appareil pour capturer des images et sur les téléphones avec peu de mémoire, l'activité de Cordova peut être tuée. Dans ce scénario, l'image peut ne pas apparaître lorsque l'activité de Cordova est restaurée.
+
+### Bizarreries navigateur
+
+Peut retourner uniquement les photos comme image codée en base64.
+
+### Firefox OS Quirks
+
+Appareil photo plugin est actuellement mis en œuvre à l'aide [d'Activités sur le Web][2].
+
+ [2]: https://hacks.mozilla.org/2013/01/introducing-web-activities/
+
+### iOS Quirks
+
+Y compris un JavaScript `alert()` dans les deux le rappel fonctions peuvent causer des problèmes. Envelopper l'alerte dans un `setTimeout()` pour permettre le sélecteur d'image iOS ou kangourou pour fermer entièrement avant que l'alerte s'affiche :
+
+    setTimeout(function() {/ / votre code ici!}, 0) ;
+    
+
+### Windows Phone 7 Quirks
+
+Invoquant l'application native caméra alors que l'appareil est connecté via Zune ne fonctionne pas et déclenche un rappel de l'erreur.
+
+### Bizarreries de paciarelli
+
+Paciarelli prend uniquement en charge un `destinationType` de `Camera.DestinationType.FILE_URI` et un `sourceType` de`Camera.PictureSourceType.PHOTOLIBRARY`.
+
+### Exemple
+
+Prendre une photo, puis extrayez-la comme une image codée en base64 :
+
+    navigator.camera.getPicture(onSuccess, onFail, { quality: 50,
+        destinationType: Camera.DestinationType.DATA_URL
+    });
+    
+    function onSuccess(imageData) {
+        var image = document.getElementById('myImage');
+        image.src = "data:image/jpeg;base64," + imageData;
+    }
+    
+    function onFail(message) {
+        alert('Failed because: ' + message);
+    }
+    
+
+Prendre une photo et récupérer l'emplacement du fichier de l'image :
+
+    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);
+    }
+    
+
+## CameraOptions
+
+Paramètres optionnels pour personnaliser les réglages de l'appareil.
+
+    { 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 };
+    
+
+### Options
+
+*   **qualité**: qualité de l'image enregistrée, exprimée en une gamme de 0 à 100, 100 étant généralement pleine résolution sans perte de compression de fichiers. La valeur par défaut est 50. *(Nombre)* (Notez que les informations sur la résolution de la caméra sont indisponibles).
+
+*   **destinationType**: choisissez le format de la valeur de retour. La valeur par défaut est FILE_URI. Définies dans `navigator.camera.DestinationType` *(nombre)*
+    
+        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**: définissez la source de l'image. La valeur par défaut est la caméra. Définies dans `navigator.camera.PictureSourceType` *(nombre)*
+    
+        Camera.PictureSourceType = {
+            PHOTOLIBRARY : 0,
+            CAMERA : 1,
+            SAVEDPHOTOALBUM : 2
+        };
+        
+
+*   **allowEdit**: permettre un montage simple d'image avant la sélection. *(Booléen)*
+
+*   **encodingType**: choisir le fichier image retournée de codage. Valeur par défaut est JPEG. Définies dans `navigator.camera.EncodingType` *(nombre)*
+    
+        Camera.EncodingType = {
+            JPEG : 0,               // Return JPEG encoded image
+            PNG : 1                 // Return PNG encoded image
+        };
+        
+
+*   **targetWidth**: largeur en pixels de l'image de l'échelle. Doit être utilisé avec **targetHeight**. Aspect ratio reste constant. *(Nombre)*
+
+*   **targetHeight**: hauteur en pixels de l'image de l'échelle. Doit être utilisé avec **targetWidth**. Aspect ratio reste constant. *(Nombre)*
+
+*   **mediaType**: définir le type de média pour choisir de. Ne fonctionne que quand `PictureSourceType` est `PHOTOLIBRARY` ou `SAVEDPHOTOALBUM` . Définies dans `nagivator.camera.MediaType` *(nombre)*
+    
+        Camera.MediaType = {
+            PICTURE: 0,    // allow selection of still pictures only. PAR DÉFAUT. 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**: faire pivoter l'image afin de corriger l'orientation de l'appareil lors de la capture. *(Booléen)*
+
+*   **saveToPhotoAlbum**: enregistrer l'image sur l'album photo sur l'appareil après la capture. *(Booléen)*
+
+*   **popoverOptions**: iOS uniquement des options qui spécifient l'emplacement de kangourou dans iPad. Défini dans`CameraPopoverOptions`.
+
+*   **cameraDirection**: choisissez la caméra à utiliser (ou dos-face). La valeur par défaut est de retour. Définies dans `navigator.camera.Direction` *(nombre)*
+    
+        Camera.Direction = {
+            BACK : 0,      // Use the back-facing camera
+            FRONT : 1      // Use the front-facing camera
+        };
+        
+
+### Amazon Fire OS Quirks
+
+*   Tout `cameraDirection` résultats dans le back-face photo de valeur.
+
+*   Ignore la `allowEdit` paramètre.
+
+*   `Camera.PictureSourceType.PHOTOLIBRARY`et `Camera.PictureSourceType.SAVEDPHOTOALBUM` les deux affichent le même album photo.
+
+### Quirks Android
+
+*   Tout `cameraDirection` résultats dans le back-face photo de valeur.
+
+*   Ignore la `allowEdit` paramètre.
+
+*   `Camera.PictureSourceType.PHOTOLIBRARY`et `Camera.PictureSourceType.SAVEDPHOTOALBUM` les deux affichent le même album photo.
+
+### BlackBerry 10 Quirks
+
+*   Ignore la `quality` paramètre.
+
+*   Ignore la `allowEdit` paramètre.
+
+*   `Camera.MediaType`n'est pas pris en charge.
+
+*   Ignore la `correctOrientation` paramètre.
+
+*   Ignore la `cameraDirection` paramètre.
+
+### Firefox OS Quirks
+
+*   Ignore la `quality` paramètre.
+
+*   `Camera.DestinationType`est ignorée et est égal à `1` (URI du fichier image)
+
+*   Ignore la `allowEdit` paramètre.
+
+*   Ignore la `PictureSourceType` paramètre (utilisateur il choisit dans une fenêtre de dialogue)
+
+*   Ignore le`encodingType`
+
+*   Ignore la `targetWidth` et`targetHeight`
+
+*   `Camera.MediaType`n'est pas pris en charge.
+
+*   Ignore la `correctOrientation` paramètre.
+
+*   Ignore la `cameraDirection` paramètre.
+
+### iOS Quirks
+
+*   La valeur `quality` inférieur à 50 pour éviter les erreurs de mémoire sur certains appareils.
+
+*   Lorsque vous utilisez `destinationType.FILE_URI` , les photos sont sauvegardées dans le répertoire temporaire de l'application. Le contenu du répertoire temporaire de l'application est supprimé lorsque l'application se termine.
+
+### Bizarreries de paciarelli
+
+*   options non prises en charge
+
+*   retourne toujours un URI de fichier
+
+### Windows Phone 7 et 8 Quirks
+
+*   Ignore la `allowEdit` paramètre.
+
+*   Ignore la `correctOrientation` paramètre.
+
+*   Ignore la `cameraDirection` paramètre.
+
+*   Ignore la `saveToPhotoAlbum` paramètre. IMPORTANT : Toutes les images prises avec la caméra de cordova wp7/8 API sont toujours copiés au rôle d'appareil photo du téléphone. Selon les paramètres de l'utilisateur, cela pourrait également signifier que l'image est auto-téléchargées à leur OneDrive. Potentiellement, cela pourrait signifier que l'image est disponible à un public plus large que votre application destinée. Si ce un bloqueur pour votre application, vous devrez implémenter le CameraCaptureTask tel que documenté sur msdn : <http://msdn.microsoft.com/en-us/library/windowsphone/develop/hh394006.aspx> vous pouvez aussi commenter ou haut-vote la question connexe dans le [gestionnaire d'incidents][3]
+
+*   Ignore la `mediaType` propriété de `cameraOptions` comme le kit de développement Windows Phone ne fournit pas un moyen de choisir les vidéos de PHOTOLIBRARY.
+
+ [3]: https://issues.apache.org/jira/browse/CB-2083
+
+## CameraError
+
+fonction de rappel onError qui fournit un message d'erreur.
+
+    function(message) {
+        // Show a helpful message
+    }
+    
+
+### Paramètres
+
+*   **message**: le message est fourni par du code natif de l'appareil. *(String)*
+
+## cameraSuccess
+
+fonction de rappel onSuccess qui fournit les données d'image.
+
+    function(imageData) {
+        // Do something with the image
+    }
+    
+
+### Paramètres
+
+*   **imageData**: codage Base64 de l'image, *ou* le fichier image URI, selon `cameraOptions` en vigueur. *(String)*
+
+### Exemple
+
+    // Show image
+    //
+    function cameraCallback(imageData) {
+        var image = document.getElementById('myImage');
+        image.src = "data:image/jpeg;base64," + imageData;
+    }
+    
+
+## CameraPopoverHandle
+
+Un handle vers la boîte de dialogue de kangourou créé par`navigator.camera.getPicture`.
+
+### Méthodes
+
+*   **setPosition**: définir la position de la kangourou.
+
+### Plates-formes prises en charge
+
+*   iOS
+
+### setPosition
+
+Définir la position de la kangourou.
+
+**Paramètres**:
+
+*   `cameraPopoverOptions`: la `CameraPopoverOptions` qui spécifie la nouvelle position
+
+### Exemple
+
+     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)
+         });
+    
+     // 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);
+     }
+    
+
+## CameraPopoverOptions
+
+iOS uniquement les paramètres qui spécifient la direction ancre élément emplacement et de la flèche de la kangourou lors de la sélection des images de la bibliothèque de l'iPad ou l'album.
+
+    { x : 0, y :  32, width : 320, height : 480, arrowDir : Camera.PopoverArrowDirection.ARROW_ANY };
+    
+
+### CameraPopoverOptions
+
+*   **x**: coordonnée de pixel de l'élément de l'écran sur lequel ancrer le kangourou x. *(Nombre)*
+
+*   **y**: coordonnée de y pixels de l'élément de l'écran sur lequel ancrer le kangourou. *(Nombre)*
+
+*   **largeur**: largeur, en pixels, de l'élément de l'écran sur lequel ancrer le kangourou. *(Nombre)*
+
+*   **hauteur**: hauteur, en pixels, de l'élément de l'écran sur lequel ancrer le kangourou. *(Nombre)*
+
+*   **arrowDir**: Direction de la flèche sur le kangourou doit pointer. Définies dans `Camera.PopoverArrowDirection` *(nombre)*
+    
+            Camera.PopoverArrowDirection = {
+                ARROW_UP : 1,        // matches iOS UIPopoverArrowDirection constants
+                ARROW_DOWN : 2,
+                ARROW_LEFT : 4,
+                ARROW_RIGHT : 8,
+                ARROW_ANY : 15
+            };
+        
+
+Notez que la taille de la kangourou peut changer pour s'adapter à la direction de la flèche et l'orientation de l'écran. Assurez-vous que tenir compte des changements d'orientation lors de la spécification de l'emplacement d'élément d'ancrage.
+
+## Navigator.Camera.Cleanup
+
+Supprime les intermédiaires photos prises par la caméra de stockage temporaire.
+
+    navigator.camera.cleanup( cameraSuccess, cameraError );
+    
+
+### Description
+
+Supprime les intermédiaires les fichiers image qui sont gardées en dépôt temporaire après avoir appelé `camera.getPicture` . S'applique uniquement lorsque la valeur de `Camera.sourceType` est égale à `Camera.PictureSourceType.CAMERA` et le `Camera.destinationType` est égal à`Camera.DestinationType.FILE_URI`.
+
+### Plates-formes prises en charge
+
+*   iOS
+
+### Exemple
+
+    navigator.camera.cleanup(onSuccess, onFail);
+    
+    function onSuccess() {
+        console.log("Camera cleanup success.")
+    }
+    
+    function onFail(message) {
+        alert('Failed because: ' + message);
+    }

doc/index.md

@@ -33,7 +33,7 @@ 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 ] );
+    navigator.camera.getPicture( cameraSuccess, cameraError, cameraOptions );
 
 ### Description
 
@@ -78,12 +78,20 @@ than `DATA_URL`.
 - Amazon Fire OS
 - Android
 - BlackBerry 10
+- Browser
 - Firefox OS
 - iOS
 - Tizen
 - Windows Phone 7 and 8
 - Windows 8
 
+### 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 uses intents to launch the camera activity on the device to capture
@@ -92,17 +100,14 @@ scenario, the image may not appear when the cordova activity is restored.
 
 ### Android Quirks
 
-*Android 4.4 only*: Android 4.4 introduced a new [Storage Access Framework](https://developer.android.com/guide/topics/providers/document-provider.html) that makes it 
-easier for users to browse and open documents across all of their preferred document storage providers.
-Cordova has not yet been fully integrated with this new Storage Access Framework. Because of this, the `getPicture()`
-method will not correctly return pictures when the user selects from the "Recent", "Drive", "Images", or "External
-Storage" folders when the `destinationType` is `FILE_URI`. However, the user will be able to correctly select any pictures
-if they go through the "Gallery" app first. Potential workarounds for this issue are documented on [this StackOverflow question](http://stackoverflow.com/questions/19834842/android-gallery-on-kitkat-returns-different-uri-for-intent-action-get-content/20177611). Please see [CB-5398](https://issues.apache.org/jira/browse/CB-5398) to track this issue. 
-
 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.
 
+### Browser Quirks
+
+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/). 
@@ -176,9 +181,9 @@ Optional parameters to customize the camera settings.
 
 ### Options
 
-- __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. _(Number)_ (Note that information about the camera's resolution is unavailable.)
+- __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. Defined in `navigator.camera.DestinationType` _(Number)_
+- __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
@@ -186,7 +191,7 @@ Optional parameters to customize the camera settings.
             NATIVE_URI : 2     // Return image native URI (e.g., assets-library:// on iOS or content:// on Android)
         };
 
-- __sourceType__: Set the source of the picture.  Defined in `navigator.camera.PictureSourceType` _(Number)_
+- __sourceType__: Set the source of the picture. The default is CAMERA. Defined in `navigator.camera.PictureSourceType` _(Number)_
 
         Camera.PictureSourceType = {
             PHOTOLIBRARY : 0,
@@ -196,7 +201,7 @@ Optional parameters to customize the camera settings.
 
 - __allowEdit__: Allow simple editing of image before selection. _(Boolean)_
 
-- __encodingType__: Choose the  returned image file's encoding.  Defined in `navigator.camera.EncodingType` _(Number)_
+- __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
@@ -213,7 +218,7 @@ Optional parameters to customize the camera settings.
             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)_
 
@@ -221,14 +226,14 @@ Optional parameters to customize the camera settings.
 
 - __popoverOptions__: iOS-only options that specify popover location in iPad.  Defined in `CameraPopoverOptions`.
 
-- __cameraDirection__: Choose the camera to use (front- or back-facing).  Defined in `navigator.camera.Direction` _(Number)_
+- __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
         };
 
-### Amazon Fire OSQuirks
+### Amazon Fire OS Quirks
 
 - Any `cameraDirection` value results in a back-facing photo.
 
@@ -248,8 +253,6 @@ Optional parameters to customize the camera settings.
 
 - Ignores the `quality` parameter.
 
-- Ignores the `sourceType` parameter.
-
 - Ignores the `allowEdit` parameter.
 
 - `Camera.MediaType` is not supported.
@@ -282,7 +285,7 @@ Optional parameters to customize the camera settings.
 
 - 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.  You may delete the contents of this directory using the `navigator.fileMgr` APIs if storage space is a concern.
+- 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.
 
 ### Tizen Quirks
 
@@ -298,6 +301,9 @@ Optional parameters to customize the camera settings.
 
 - 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 `mediaType` property of `cameraOptions` as the Windows Phone SDK does not provide a way to choose videos from PHOTOLIBRARY.
 
 

doc/it/index.md

@@ -0,0 +1,409 @@
+<!---
+    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.
+-->
+
+# org.apache.cordova.camera
+
+Questo plugin fornisce un'API per scattare foto e per aver scelto immagini dalla libreria di immagini del sistema.
+
+    cordova plugin add org.apache.cordova.camera
+    
+
+## navigator.camera.getPicture
+
+Prende una foto utilizzando la fotocamera, o recupera una foto dalla galleria di immagini del dispositivo. L'immagine viene passata al metodo di callback successo come una codifica base64 `String` , o come l'URI per il file di immagine. Il metodo stesso restituisce un `CameraPopoverHandle` che può essere utilizzato per riposizionare il Muffin di selezione file.
+
+    navigator.camera.getPicture( cameraSuccess, cameraError, cameraOptions );
+    
+
+### Descrizione
+
+il `camera.getPicture` funzione apre predefinito fotocamera applicazione il dispositivo che consente agli utenti di scattare foto. Questo comportamento si verifica per impostazione predefinita, quando `Camera.sourceType` è uguale a `Camera.PictureSourceType.CAMERA` . Una volta che l'utente scatta la foto, si chiude l'applicazione fotocamera e l'applicazione viene ripristinato.
+
+Se `Camera.sourceType` è `Camera.PictureSourceType.PHOTOLIBRARY` o `Camera.PictureSourceType.SAVEDPHOTOALBUM` , quindi un display finestra di dialogo che consente agli utenti di selezionare un'immagine esistente. La `camera.getPicture` la funzione restituisce un `CameraPopoverHandle` oggetto, che può essere utilizzato per riposizionare la finestra di selezione immagine, ad esempio, quando l'orientamento del dispositivo.
+
+Il valore restituito viene inviato alla `cameraSuccess` funzione di callback, in uno dei seguenti formati, a seconda che l'oggetto specificato `cameraOptions` :
+
+*   A `String` contenente l'immagine della foto con codifica base64.
+
+*   A `String` che rappresenta il percorso del file di immagine su archiviazione locale (predefinito).
+
+Si può fare quello che vuoi con l'immagine codificata o URI, ad esempio:
+
+*   Il rendering dell'immagine in un `<img>` tag, come nell'esempio qui sotto
+
+*   Salvare i dati localmente ( `LocalStorage` , [Lawnchair][1], ecc.)
+
+*   Inviare i dati a un server remoto
+
+ [1]: http://brianleroux.github.com/lawnchair/
+
+**Nota**: risoluzione foto sui più recenti dispositivi è abbastanza buona. Foto selezionate dalla galleria del dispositivo non è percepiranno di qualità inferiore, anche se un `quality` è specificato il parametro. Per evitare problemi di memoria comune, impostare `Camera.destinationType` a `FILE_URI` piuttosto che`DATA_URL`.
+
+### Piattaforme supportate
+
+*   Amazon fuoco OS
+*   Android
+*   BlackBerry 10
+*   Browser
+*   Firefox OS
+*   iOS
+*   Tizen
+*   Windows Phone 7 e 8
+*   Windows 8
+
+### Preferenze (iOS)
+
+*   **CameraUsesGeolocation** (boolean, default è false). Per l'acquisizione di immagini JPEG, impostato su true per ottenere dati di geolocalizzazione nell'intestazione EXIF. Questo innescherà una richiesta per le autorizzazioni di geolocalizzazione, se impostato su true.
+    
+        <preference name="CameraUsesGeolocation" value="false" />
+        
+
+### Amazon fuoco OS stranezze
+
+Amazon fuoco OS utilizza intenti a lanciare l'attività della fotocamera sul dispositivo per catturare immagini e sui telefoni con poca memoria, l'attività di Cordova può essere ucciso. In questo scenario, l'immagine potrebbe non apparire quando viene ripristinata l'attività di cordova.
+
+### Stranezze Android
+
+Android utilizza intenti a lanciare l'attività della fotocamera sul dispositivo per catturare immagini e sui telefoni con poca memoria, l'attività di Cordova può essere ucciso. In questo scenario, l'immagine potrebbe non apparire quando viene ripristinata l'attività di Cordova.
+
+### Stranezze browser
+
+Può restituire solo la foto come immagine con codifica base64.
+
+### Firefox OS stranezze
+
+Fotocamera plugin è attualmente implementato mediante [Attività Web][2].
+
+ [2]: https://hacks.mozilla.org/2013/01/introducing-web-activities/
+
+### iOS stranezze
+
+Compreso un JavaScript `alert()` in entrambi il callback funzioni possono causare problemi. Avvolgere l'avviso all'interno di un `setTimeout()` per consentire la selezione immagine iOS o muffin per chiudere completamente la prima che viene visualizzato l'avviso:
+
+    setTimeout(function() {/ / fai la tua cosa qui!}, 0);
+    
+
+### Windows Phone 7 capricci
+
+Richiamando l'applicazione nativa fotocamera mentre il dispositivo è collegato tramite Zune non funziona e innesca un callback di errore.
+
+### Tizen stranezze
+
+Tizen supporta solo un `destinationType` di `Camera.DestinationType.FILE_URI` e un `sourceType` di`Camera.PictureSourceType.PHOTOLIBRARY`.
+
+### Esempio
+
+Scattare una foto e recuperarla come un'immagine con codifica base64:
+
+    navigator.camera.getPicture(onSuccess, onFail, { quality: 50,
+        destinationType: Camera.DestinationType.DATA_URL
+    });
+    
+    function onSuccess(imageData) {
+        var image = document.getElementById('myImage');
+        image.src = "data:image/jpeg;base64," + imageData;
+    }
+    
+    function onFail(message) {
+        alert('Failed because: ' + message);
+    }
+    
+
+Scattare una foto e recuperare il percorso del file dell'immagine:
+
+    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);
+    }
+    
+
+## CameraOptions
+
+Parametri opzionali per personalizzare le impostazioni della fotocamera.
+
+    {qualità: 75, destinationType: Camera.DestinationType.DATA_URL, sourceType: Camera.PictureSourceType.CAMERA, allowEdit: vero, encodingType: Camera.EncodingType.JPEG, targetWidth: 100, targetHeight: 100, popoverOptions: CameraPopoverOptions, saveToPhotoAlbum: false};
+    
+
+### Opzioni
+
+*   **qualità**: qualità dell'immagine salvata, espressa come un intervallo di 0-100, dove 100 è tipicamente piena risoluzione senza perdita di compressione file. Il valore predefinito è 50. *(Numero)* (Si noti che informazioni sulla risoluzione della fotocamera non sono disponibile).
+
+*   **destinationType**: Scegli il formato del valore restituito. Il valore predefinito è FILE_URI. Definito in `navigator.camera.DestinationType` *(numero)*
+    
+        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**: impostare l'origine dell'immagine. Il valore predefinito è la fotocamera. Definito in `navigator.camera.PictureSourceType` *(numero)*
+    
+        Camera.PictureSourceType = {
+            PHOTOLIBRARY : 0,
+            CAMERA : 1,
+            SAVEDPHOTOALBUM : 2
+        };
+        
+
+*   **Proprietà allowEdit**: consentire la semplice modifica dell'immagine prima di selezione. *(Booleano)*
+
+*   **encodingType**: scegliere il file immagine restituita di codifica. Predefinito è JPEG. Definito in `navigator.camera.EncodingType` *(numero)*
+    
+        Camera.EncodingType = {
+            JPEG : 0,               // Return JPEG encoded image
+            PNG : 1                 // Return PNG encoded image
+        };
+        
+
+*   **targetWidth**: larghezza in pixel all'immagine della scala. Deve essere usato con **targetHeight**. Proporzioni rimane costante. *(Numero)*
+
+*   **targetHeight**: altezza in pixel all'immagine della scala. Deve essere usato con **targetWidth**. Proporzioni rimane costante. *(Numero)*
+
+*   **mediaType**: impostare il tipo di supporto per scegliere da. Funziona solo quando `PictureSourceType` è `PHOTOLIBRARY` o `SAVEDPHOTOALBUM` . Definito in `nagivator.camera.MediaType` *(numero)*
+    
+        Camera.MediaType = {
+            PICTURE: 0,    // allow selection of still pictures only. PER IMPOSTAZIONE PREDEFINITA. 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**: ruotare l'immagine per correggere l'orientamento del dispositivo durante l'acquisizione. *(Booleano)*
+
+*   **saveToPhotoAlbum**: salvare l'immagine nell'album di foto sul dispositivo dopo la cattura. *(Booleano)*
+
+*   **popoverOptions**: solo iOS opzioni che specificano la posizione di muffin in iPad. Definito in`CameraPopoverOptions`.
+
+*   **cameraDirection**: scegliere la telecamera da utilizzare (o retro-frontale). Il valore predefinito è tornato. Definito in `navigator.camera.Direction` *(numero)*
+    
+        Camera.Direction = {
+            BACK : 0,      // Use the back-facing camera
+            FRONT : 1      // Use the front-facing camera
+        };
+        
+
+### Amazon fuoco OS stranezze
+
+*   Qualsiasi `cameraDirection` valore i risultati in una foto di lamatura.
+
+*   Ignora il `allowEdit` parametro.
+
+*   `Camera.PictureSourceType.PHOTOLIBRARY`e `Camera.PictureSourceType.SAVEDPHOTOALBUM` entrambi visualizzare l'album fotografico stesso.
+
+### Stranezze Android
+
+*   Qualsiasi `cameraDirection` valore i risultati in una foto di lamatura.
+
+*   Ignora il `allowEdit` parametro.
+
+*   `Camera.PictureSourceType.PHOTOLIBRARY`e `Camera.PictureSourceType.SAVEDPHOTOALBUM` entrambi visualizzare l'album fotografico stesso.
+
+### BlackBerry 10 capricci
+
+*   Ignora il `quality` parametro.
+
+*   Ignora il `allowEdit` parametro.
+
+*   `Camera.MediaType`non è supportato.
+
+*   Ignora il `correctOrientation` parametro.
+
+*   Ignora il `cameraDirection` parametro.
+
+### Firefox OS stranezze
+
+*   Ignora il `quality` parametro.
+
+*   `Camera.DestinationType`viene ignorato e corrisponde a `1` (URI del file di immagine)
+
+*   Ignora il `allowEdit` parametro.
+
+*   Ignora il `PictureSourceType` parametro (utente ne sceglie in una finestra di dialogo)
+
+*   Ignora il`encodingType`
+
+*   Ignora le `targetWidth` e`targetHeight`
+
+*   `Camera.MediaType`non è supportato.
+
+*   Ignora il `correctOrientation` parametro.
+
+*   Ignora il `cameraDirection` parametro.
+
+### iOS stranezze
+
+*   Impostare `quality` inferiore al 50 per evitare errori di memoria su alcuni dispositivi.
+
+*   Quando si utilizza `destinationType.FILE_URI` , foto vengono salvati nella directory temporanea dell'applicazione. Il contenuto della directory temporanea dell'applicazione viene eliminato quando l'applicazione termina.
+
+### Tizen stranezze
+
+*   opzioni non supportate
+
+*   restituisce sempre un URI del FILE
+
+### Windows Phone 7 e 8 stranezze
+
+*   Ignora il `allowEdit` parametro.
+
+*   Ignora il `correctOrientation` parametro.
+
+*   Ignora il `cameraDirection` parametro.
+
+*   Ignora il `saveToPhotoAlbum` parametro. IMPORTANTE: Tutte le immagini scattate con la fotocamera di cordova wp7/8 API vengono sempre copiate rotolo fotocamera del telefono cellulare. A seconda delle impostazioni dell'utente, questo potrebbe anche significare che l'immagine viene caricato in automatico a loro OneDrive. Questo potenzialmente potrebbe significare che l'immagine è disponibile a un pubblico più ampio di app destinate. Se questo un blocco dell'applicazione, sarà necessario implementare il CameraCaptureTask come documentato su msdn: <http://msdn.microsoft.com/en-us/library/windowsphone/develop/hh394006.aspx> si può anche commentare o up-voto la questione correlata nel [tracciatore di problemi][3]
+
+*   Ignora la `mediaType` proprietà di `cameraOptions` come il SDK di Windows Phone non fornisce un modo per scegliere il video da PHOTOLIBRARY.
+
+ [3]: https://issues.apache.org/jira/browse/CB-2083
+
+## CameraError
+
+funzione di callback onError che fornisce un messaggio di errore.
+
+    function(message) {
+        // Show a helpful message
+    }
+    
+
+### Parametri
+
+*   **messaggio**: il messaggio è fornito dal codice nativo del dispositivo. *(String)*
+
+## cameraSuccess
+
+funzione di callback onSuccess che fornisce i dati di immagine.
+
+    function(imageData) {
+        // Do something with the image
+    }
+    
+
+### Parametri
+
+*   **imageData**: Base64 codifica dei dati immagine, *o* il file di immagine URI, a seconda `cameraOptions` in vigore. *(String)*
+
+### Esempio
+
+    // Show image
+    //
+    function cameraCallback(imageData) {
+        var image = document.getElementById('myImage');
+        image.src = "data:image/jpeg;base64," + imageData;
+    }
+    
+
+## CameraPopoverHandle
+
+Un handle per la finestra di dialogo di muffin creato da`navigator.camera.getPicture`.
+
+### Metodi
+
+*   **setPosition**: impostare la posizione dei muffin.
+
+### Piattaforme supportate
+
+*   iOS
+
+### setPosition
+
+Impostare la posizione dei muffin.
+
+**Parametri**:
+
+*   `cameraPopoverOptions`: il `CameraPopoverOptions` che specificare la nuova posizione
+
+### Esempio
+
+     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)
+         });
+    
+     // 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);
+     }
+    
+
+## CameraPopoverOptions
+
+iOS solo parametri che specificano l'ancoraggio elemento posizione e freccia direzione il Muffin quando si selezionano le immagini dalla libreria un iPad o un album.
+
+    {x: 0, y: 32, larghezza: 320, altezza: 480, arrowDir: Camera.PopoverArrowDirection.ARROW_ANY};
+    
+
+### CameraPopoverOptions
+
+*   **x**: pixel coordinata x dell'elemento dello schermo su cui ancorare il muffin. *(Numero)*
+
+*   **y**: coordinata y di pixel dell'elemento dello schermo su cui ancorare il muffin. *(Numero)*
+
+*   **larghezza**: larghezza, in pixel, dell'elemento dello schermo su cui ancorare il muffin. *(Numero)*
+
+*   **altezza**: altezza, in pixel, dell'elemento dello schermo su cui ancorare il muffin. *(Numero)*
+
+*   **arrowDir**: direzione dovrebbe puntare la freccia il muffin. Definito in `Camera.PopoverArrowDirection` *(numero)*
+    
+            Camera.PopoverArrowDirection = {
+                ARROW_UP : 1,        // matches iOS UIPopoverArrowDirection constants
+                ARROW_DOWN : 2,
+                ARROW_LEFT : 4,
+                ARROW_RIGHT : 8,
+                ARROW_ANY : 15
+            };
+        
+
+Si noti che la dimensione del muffin possa cambiare per regolare la direzione della freccia e l'orientamento dello schermo. Assicurarsi che tenere conto di modifiche di orientamento quando si specifica la posizione di elemento di ancoraggio.
+
+## Navigator.camera.Cleanup
+
+Rimuove intermedio foto scattate con la fotocamera da deposito temporaneo.
+
+    navigator.camera.cleanup( cameraSuccess, cameraError );
+    
+
+### Descrizione
+
+Rimuove intermedio i file di immagine che vengono tenuti in custodia temporanea dopo la chiamata `camera.getPicture` . Si applica solo quando il valore di `Camera.sourceType` è uguale a `Camera.PictureSourceType.CAMERA` e il `Camera.destinationType` è uguale a`Camera.DestinationType.FILE_URI`.
+
+### Piattaforme supportate
+
+*   iOS
+
+### Esempio
+
+    navigator.camera.cleanup(onSuccess, onFail);
+    
+    function onSuccess() {
+        console.log("Camera cleanup success.")
+    }
+    
+    function onFail(message) {
+        alert('Failed because: ' + message);
+    }

doc/ja/index.md

@@ -0,0 +1,409 @@
+<!---
+    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.
+-->
+
+# org.apache.cordova.camera
+
+このプラグインは写真を撮るため、システムのイメージ ライブラリからイメージを選択するために API を提供します。
+
+    cordova plugin add org.apache.cordova.camera
+    
+
+## navigator.camera.getPicture
+
+カメラを使用して写真を取るか、デバイスの画像ギャラリーから写真を取得します。 イメージは base64 エンコードとして成功時のコールバックに渡される `String` 、またはイメージ ファイルの URI。 メソッド自体を返します、 `CameraPopoverHandle` オブジェクト ファイル選択ポップ オーバーの位置を変更するために使用することができます。
+
+    navigator.camera.getPicture( cameraSuccess, cameraError, cameraOptions );
+    
+
+### 説明
+
+`camera.getPicture`関数はデバイスのデフォルトのカメラ アプリケーションの写真をスナップするユーザーことができますを開きます。 既定では、この現象が発生したときに `Camera.sourceType` に等しい `Camera.PictureSourceType.CAMERA` 。 ユーザーは写真をスナップ、カメラ アプリケーションを閉じるし、アプリケーションが復元されます。
+
+場合 `Camera.sourceType` は、 `Camera.PictureSourceType.PHOTOLIBRARY` または `Camera.PictureSourceType.SAVEDPHOTOALBUM` 、その後、ダイアログが表示されますユーザーを既存のイメージを選択することができます。 `camera.getPicture`関数を返す、 `CameraPopoverHandle` オブジェクトは、たとえば、イメージの選択ダイアログには、デバイスの向きが変更されたときの位置を変更するために使用することができます。
+
+戻り値に送信されます、 `cameraSuccess` の指定によって、次の形式のいずれかのコールバック関数 `cameraOptions` :
+
+*   A `String` 写真の base64 でエンコードされたイメージを含んでいます。
+
+*   A `String` (既定値) のローカル記憶域上のイメージ ファイルの場所を表します。
+
+自由に変更、エンコードされたイメージ、または URI などを行うことができます。
+
+*   イメージをレンダリングする `<img>` 以下の例のように、タグ
+
+*   ローカル データの保存 ( `LocalStorage` 、 [Lawnchair][1]など)。
+
+*   リモート サーバーにデータを投稿します。
+
+ [1]: http://brianleroux.github.com/lawnchair/
+
+**注**: 新しいデバイス上の写真の解像度はかなり良いです。 デバイスのギャラリーから選択した写真が下方の品質に縮小しない場合でも、 `quality` パラメーターを指定します。 一般的なメモリの問題を回避する設定 `Camera.destinationType` を `FILE_URI` よりもむしろ`DATA_URL`.
+
+### サポートされているプラットフォーム
+
+*   アマゾン火 OS
+*   アンドロイド
+*   ブラックベリー 10
+*   ブラウザー
+*   Firefox の OS
+*   iOS
+*   Tizen
+*   Windows Phone 7 と 8
+*   Windows 8
+
+### 環境設定 （iOS）
+
+*   **CameraUsesGeolocation**(ブール値、デフォルトは false)。 Jpeg 画像をキャプチャするため EXIF ヘッダーで地理位置情報データを取得する場合は true に設定します。 これは、場合地理位置情報のアクセス許可に対する要求をトリガーする true に設定します。
+    
+        <preference name="CameraUsesGeolocation" value="false" />
+        
+
+### アマゾン火 OS 癖
+
+アマゾン火 OS イメージをキャプチャするデバイス上のカメラの活動を開始する意図を使用して、メモリの少ない携帯電話、コルドバ活動が殺されるかもしれない。 このシナリオでは、コルドバの活動が復元されるとき、画像が表示されません。
+
+### Android の癖
+
+アンドロイド、イメージをキャプチャするデバイス上でカメラのアクティビティを開始する意図を使用し、メモリの少ない携帯電話、コルドバ活動が殺されるかもしれない。 このシナリオではコルドバ活動が復元されると、イメージが表示されません。
+
+### ブラウザーの癖
+
+Base64 エンコード イメージとして写真を返すのみことができます。
+
+### Firefox OS 癖
+
+カメラのプラグインは現在、 [Web アクティビティ][2]を使用して実装されていた.
+
+ [2]: https://hacks.mozilla.org/2013/01/introducing-web-activities/
+
+### iOS の癖
+
+JavaScript を含む `alert()` 関数コールバックのいずれかの問題を引き起こすことができます。 内でアラートのラップ、 `setTimeout()` iOS イメージ ピッカーまたは完全が終了するまで、警告が表示されますポップ オーバーを許可します。
+
+    setTimeout(function() {//ここにあなたのことを行います ！}, 0);
+    
+
+### Windows Phone 7 の癖
+
+ネイティブ カメラ アプリケーションを呼び出すと、デバイスが Zune を介して接続されている動作しませんし、エラー コールバックをトリガーします。
+
+### Tizen の癖
+
+Tizen のみをサポートしている、 `destinationType` の `Camera.DestinationType.FILE_URI` と `sourceType` の`Camera.PictureSourceType.PHOTOLIBRARY`.
+
+### 例
+
+写真を撮るし、base64 エンコード イメージとして取得します。
+
+    navigator.camera.getPicture(onSuccess, onFail, { quality: 50,
+        destinationType: Camera.DestinationType.DATA_URL
+    });
+    
+    function onSuccess(imageData) {
+        var image = document.getElementById('myImage');
+        image.src = "data:image/jpeg;base64," + imageData;
+    }
+    
+    function onFail(message) {
+        alert('Failed because: ' + message);
+    }
+    
+
+写真を撮るし、イメージのファイルの場所を取得します。
+
+    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);
+    }
+    
+
+## CameraOptions
+
+カメラの設定をカスタマイズするオプションのパラメーター。
+
+    {品質： 75、destinationType: Camera.DestinationType.DATA_URL、sourceType: Camera.PictureSourceType.CAMERA、allowEdit: true の場合、encodingType: Camera.EncodingType.JPEG、targetWidth: 100、targetHeight: 100、popoverOptions： CameraPopoverOptions、saveToPhotoAlbum: false};
+    
+
+### オプション
+
+*   **品質**： 0-100、100 がファイルの圧縮から損失なしで通常のフル解像度の範囲で表される、保存されたイメージの品質。 既定値は 50 です。 *(数)*（カメラの解像度についての情報が利用できないことに注意してください)。
+
+*   **destinationType**: 戻り値の形式を選択します。既定値は FILE_URI です。定義されている `navigator.camera.DestinationType` *（番号）*
+    
+        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**: 画像のソースを設定します。既定値は、カメラです。定義されている `navigator.camera.PictureSourceType` *（番号）*
+    
+        Camera.PictureSourceType = {
+            PHOTOLIBRARY : 0,
+            CAMERA : 1,
+            SAVEDPHOTOALBUM : 2
+        };
+        
+
+*   **allowEdit**: 単純な選択の前に画像の編集を許可します。*(ブール値)*
+
+*   **encodingType**: 返されるイメージ ファイルのエンコーディングを選択します。デフォルトは JPEG です。定義されている `navigator.camera.EncodingType` *（番号）*
+    
+        Camera.EncodingType = {
+            JPEG : 0,               // Return JPEG encoded image
+            PNG : 1                 // Return PNG encoded image
+        };
+        
+
+*   **targetWidth**: スケール イメージにピクセル単位の幅。**TargetHeight**を使用する必要があります。縦横比は変わりません。*(数)*
+
+*   **targetHeight**: スケール イメージにピクセル単位の高さ。**TargetWidth**を使用する必要があります。縦横比は変わりません。*(数)*
+
+*   **mediaType**： から選択するメディアの種類を設定します。 場合にのみ働きます `PictureSourceType` は `PHOTOLIBRARY` または `SAVEDPHOTOALBUM` 。 定義されている `nagivator.camera.MediaType` *（番号）*
+    
+        Camera.MediaType = {
+            PICTURE: 0,    // allow selection of still pictures only. 既定値です。 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**: キャプチャ中に、デバイスの向きを修正する画像を回転させます。*(ブール値)*
+
+*   **saveToPhotoAlbum**: キャプチャ後、デバイス上のフォト アルバムに画像を保存します。*(ブール値)*
+
+*   **popoverOptions**: iPad のポップ オーバーの場所を指定する iOS のみのオプションです。定義されています。`CameraPopoverOptions`.
+
+*   **cameraDirection**： （前面または背面側） を使用するカメラを選択します。既定値は戻るです。定義されている `navigator.camera.Direction` *（番号）*
+    
+        Camera.Direction = {
+            BACK : 0,      // Use the back-facing camera
+            FRONT : 1      // Use the front-facing camera
+        };
+        
+
+### アマゾン火 OS 癖
+
+*   任意 `cameraDirection` 背面写真で結果の値します。
+
+*   無視、 `allowEdit` パラメーター。
+
+*   `Camera.PictureSourceType.PHOTOLIBRARY``Camera.PictureSourceType.SAVEDPHOTOALBUM`両方のアルバムが表示されます同じ写真。
+
+### Android の癖
+
+*   任意 `cameraDirection` 背面写真で結果の値します。
+
+*   無視、 `allowEdit` パラメーター。
+
+*   `Camera.PictureSourceType.PHOTOLIBRARY``Camera.PictureSourceType.SAVEDPHOTOALBUM`両方のアルバムが表示されます同じ写真。
+
+### ブラックベリー 10 癖
+
+*   無視、 `quality` パラメーター。
+
+*   無視、 `allowEdit` パラメーター。
+
+*   `Camera.MediaType`サポートされていません。
+
+*   無視、 `correctOrientation` パラメーター。
+
+*   無視、 `cameraDirection` パラメーター。
+
+### Firefox OS 癖
+
+*   無視、 `quality` パラメーター。
+
+*   `Camera.DestinationType`無視され、等しい `1` (イメージ ファイル URI)
+
+*   無視、 `allowEdit` パラメーター。
+
+*   無視、 `PictureSourceType` パラメーター (ユーザーが選択ダイアログ ウィンドウに)
+
+*   無視します、`encodingType`
+
+*   無視、 `targetWidth` と`targetHeight`
+
+*   `Camera.MediaType`サポートされていません。
+
+*   無視、 `correctOrientation` パラメーター。
+
+*   無視、 `cameraDirection` パラメーター。
+
+### iOS の癖
+
+*   設定 `quality` 一部のデバイスでメモリ不足エラーを避けるために 50 の下。
+
+*   使用する場合 `destinationType.FILE_URI` 、写真、アプリケーションの一時ディレクトリに保存されます。アプリケーションの一時ディレクトリの内容は、アプリケーションの終了時に削除されます。
+
+### Tizen の癖
+
+*   サポートされていないオプション
+
+*   常にファイルの URI を返す
+
+### Windows Phone 7 と 8 癖
+
+*   無視、 `allowEdit` パラメーター。
+
+*   無視、 `correctOrientation` パラメーター。
+
+*   無視、 `cameraDirection` パラメーター。
+
+*   無視、 `saveToPhotoAlbum` パラメーター。 重要: wp7/8 コルドバ カメラ API で撮影したすべての画像は携帯電話のカメラ巻き物に常にコピーします。 ユーザーの設定に応じて、これも、画像はその OneDrive に自動アップロードを意味できます。 イメージは意図したアプリより広い聴衆に利用できる可能性があります可能性があります。 場合は、このアプリケーションのブロッカー、msdn で説明されているように、CameraCaptureTask を実装する必要があります: <http://msdn.microsoft.com/en-us/library/windowsphone/develop/hh394006.aspx>コメントにすることがありますもかアップ投票関連の問題を[課題追跡システム][3]で
+
+*   無視、 `mediaType` のプロパティ `cameraOptions` として Windows Phone SDK には、フォト ライブラリからビデオを選択する方法は行いません。
+
+ [3]: https://issues.apache.org/jira/browse/CB-2083
+
+## CameraError
+
+エラー メッセージを提供する onError コールバック関数。
+
+    function(message) {
+        // Show a helpful message
+    }
+    
+
+### パラメーター
+
+*   **メッセージ**: メッセージは、デバイスのネイティブ コードによって提供されます。*(文字列)*
+
+## cameraSuccess
+
+画像データを提供する onSuccess コールバック関数。
+
+    function(imageData) {
+        // Do something with the image
+    }
+    
+
+### パラメーター
+
+*   **imagedata を扱う**: Base64 エンコード イメージのデータ、*または*画像ファイルによって URI の `cameraOptions` 効果。*(文字列)*
+
+### 例
+
+    // Show image
+    //
+    function cameraCallback(imageData) {
+        var image = document.getElementById('myImage');
+        image.src = "data:image/jpeg;base64," + imageData;
+    }
+    
+
+## CameraPopoverHandle
+
+によって作成されたポップオーバーパン ダイアログへのハンドル`navigator.camera.getPicture`.
+
+### メソッド
+
+*   **setPosition**: ポップ オーバーの位置を設定します。
+
+### サポートされているプラットフォーム
+
+*   iOS
+
+### setPosition
+
+ポップ オーバーの位置を設定します。
+
+**パラメーター**:
+
+*   `cameraPopoverOptions`:、 `CameraPopoverOptions` の新しい位置を指定します。
+
+### 例
+
+     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)
+         });
+    
+     // 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);
+     }
+    
+
+## CameraPopoverOptions
+
+iOS だけ指定パラメーターをポップ オーバーのアンカー要素の場所および矢印方向計算されたライブラリまたはアルバムから画像を選択するとき。
+
+    {x: 0, y: 32、幅： 320、高さ： 480、arrowDir: Camera.PopoverArrowDirection.ARROW_ANY};
+    
+
+### CameraPopoverOptions
+
+*   **x**: ピクセルの x 座標画面要素にポップ オーバーのアンカーになります。*(数)*
+
+*   **y**: y ピクセル座標の画面要素にポップ オーバーのアンカーになります。*(数)*
+
+*   **幅**: ポップ オーバーのアンカーになる上の画面要素のピクセル単位の幅。*(数)*
+
+*   **高さ**: ポップ オーバーのアンカーになる上の画面要素のピクセル単位の高さ。*(数)*
+
+*   **arrowDir**: 方向のポップ オーバーで矢印をポイントする必要があります。定義されている `Camera.PopoverArrowDirection` *（番号）*
+    
+            Camera.PopoverArrowDirection = {
+                ARROW_UP : 1,        // matches iOS UIPopoverArrowDirection constants
+                ARROW_DOWN : 2,
+                ARROW_LEFT : 4,
+                ARROW_RIGHT : 8,
+                ARROW_ANY : 15
+            };
+        
+
+矢印の方向と、画面の向きを調整するポップ オーバーのサイズを変更可能性がありますに注意してください。 アンカー要素の位置を指定するときの方向の変化を考慮することを確認します。
+
+## navigator.camera.cleanup
+
+削除中間一時ストレージからカメラで撮影した写真。
+
+    navigator.camera.cleanup( cameraSuccess, cameraError );
+    
+
+### 説明
+
+削除を呼び出した後に一時記憶域に保存されている画像ファイルを中間 `camera.getPicture` 。 場合にのみ適用されるの値 `Camera.sourceType` に等しい `Camera.PictureSourceType.CAMERA` と、 `Camera.destinationType` に等しい`Camera.DestinationType.FILE_URI`.
+
+### サポートされているプラットフォーム
+
+*   iOS
+
+### 例
+
+    navigator.camera.cleanup(onSuccess, onFail);
+    
+    function onSuccess() {
+        console.log("Camera cleanup success.")
+    }
+    
+    function onFail(message) {
+        alert('Failed because: ' + message);
+    }

doc/ko/index.md

@@ -0,0 +1,409 @@
+<!---
+    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.
+-->
+
+# org.apache.cordova.camera
+
+이 플러그인 사진 촬영을 위한 및 시스템의 이미지 라이브러리에서 이미지를 선택 하기 위한 API를 제공 합니다.
+
+    cordova plugin add org.apache.cordova.camera
+    
+
+## navigator.camera.getPicture
+
+카메라를 사용 하 여 사진을 걸립니다 또는 소자의 이미지 갤러리에서 사진을 검색 합니다. 이미지 base64 인코딩으로 성공 콜백에 전달 됩니다 `String` , 또는 이미지 파일에 대 한 URI로. 방법 자체는 반환 합니다 한 `CameraPopoverHandle` 개체 파일 선택 popover를 재배치 하는 데 사용할 수 있습니다.
+
+    navigator.camera.getPicture( cameraSuccess, cameraError, cameraOptions );
+    
+
+### 설명
+
+`camera.getPicture`기능 스냅 사진을 사용자가 디바이스의 기본 카메라 응용 프로그램을 엽니다. 이 동작은 기본적으로 발생 할 때 `Camera.sourceType` 와 `Camera.PictureSourceType.CAMERA` . 일단 사용자 스냅 사진, 카메라 응용 프로그램 종료 하 고 응용 프로그램 복원 됩니다.
+
+경우 `Camera.sourceType` 은 `Camera.PictureSourceType.PHOTOLIBRARY` 또는 `Camera.PictureSourceType.SAVEDPHOTOALBUM` , 사용자가 기존 이미지를 선택할 수 있도록 다음 대화 상자 표시. `camera.getPicture`반환 함수는 `CameraPopoverHandle` 장치 방향 변경 될 때 이미지 선택 대화 상자, 예를 들어, 위치를 변경 하려면 사용할 수 있는 개체.
+
+반환 값에 전송 되는 `cameraSuccess` 콜백 함수에 따라 지정 된 다음 형식 중 하나에 `cameraOptions` :
+
+*   A `String` base64 인코딩된 사진 이미지를 포함 합니다.
+
+*   A `String` 로컬 저장소 (기본값)의 이미지 파일 위치를 나타내는.
+
+할 수 있는 당신이 원하는대로 인코딩된 이미지 또는 URI, 예를 들면:
+
+*   렌더링 이미지는 `<img>` 아래 예제와 같이 태그
+
+*   로컬로 데이터를 저장 ( `LocalStorage` , [Lawnchair][1], 등.)
+
+*   원격 서버에 데이터 게시
+
+ [1]: http://brianleroux.github.com/lawnchair/
+
+**참고**: 더 새로운 장치에 사진 해상도 아주 좋은. 소자의 갤러리에서 선택 된 사진을 하지 낮은 품질에 관하여는 경우에는 `quality` 매개 변수를 지정 합니다. 일반적인 메모리 문제를 방지 하려면 설정 `Camera.destinationType` 을 `FILE_URI` 보다는`DATA_URL`.
+
+### 지원 되는 플랫폼
+
+*   아마존 화재 운영 체제
+*   안 드 로이드
+*   블랙베리 10
+*   브라우저
+*   Firefox 운영 체제
+*   iOS
+*   Tizen
+*   Windows Phone 7과 8
+*   윈도우 8
+
+### 환경 설정 (iOS)
+
+*   **CameraUsesGeolocation** (boolean, 기본값: false)입니다. 캡처 Jpeg, EXIF 헤더에 지리적 데이터를 true로 설정 합니다. 이 경우 위치 정보 사용 권한에 대 한 요청을 일으킬 것 이다 true로 설정 합니다.
+    
+        <preference name="CameraUsesGeolocation" value="false" />
+        
+
+### 아마존 화재 OS 단점
+
+아마존 화재 OS 의도 사용 하 여 이미지 캡처 장치에서 카메라 활동을 시작 하 고 낮은 메모리와 휴대 전화에 코르 도우 바 활동 살해 수 있습니다. 코르도바 활동 복원 되 면이 시나리오에서는 이미지가 나타나지 않을 수 있습니다.
+
+### 안 드 로이드 단점
+
+안 드 로이드 의도 사용 하 여 이미지 캡처 장치에서 카메라 활동을 시작 하 고 낮은 메모리와 휴대 전화에 코르 도우 바 활동 살해 수 있습니다. 코르도바 활동 복원 되 면이 시나리오에서는 이미지가 나타나지 않을 수 있습니다.
+
+### 브라우저 만지면
+
+수 base64 인코딩 이미지로 사진을 반환 합니다.
+
+### 파이어 폭스 OS 단점
+
+카메라 플러그인은 현재 [웹 활동][2] 를 사용 하 여 구현.
+
+ [2]: https://hacks.mozilla.org/2013/01/introducing-web-activities/
+
+### iOS 단점
+
+자바 스크립트를 포함 하 여 `alert()` 함수는 콜백 중에 문제를 일으킬 수 있습니다. 내 경고를 래핑하는 `setTimeout()` 허용 iOS 이미지 피커 또는 popover를 완벽 하 게 경고를 표시 하기 전에 닫습니다:
+
+    setTimeout(function() {/ / 여기 짓!}, 0);
+    
+
+### Windows Phone 7 단점
+
+장치 Zune 통해 연결 된 동안 네이티브 카메라 응용 프로그램을 호출 하면 작동 하지 않습니다 하 고 오류 콜백 트리거합니다.
+
+### Tizen 특수
+
+Tizen만 지원 한 `destinationType` 의 `Camera.DestinationType.FILE_URI` 와 `sourceType` 의`Camera.PictureSourceType.PHOTOLIBRARY`.
+
+### 예를 들어
+
+촬영 및 base64 인코딩 이미지로 검색:
+
+    navigator.camera.getPicture(onSuccess, onFail, { quality: 50,
+        destinationType: Camera.DestinationType.DATA_URL
+    });
+    
+    function onSuccess(imageData) {
+        var image = document.getElementById('myImage');
+        image.src = "data:image/jpeg;base64," + imageData;
+    }
+    
+    function onFail(message) {
+        alert('Failed because: ' + message);
+    }
+    
+
+촬영 하 고 이미지의 파일 위치를 검색:
+
+    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);
+    }
+    
+
+## CameraOptions
+
+카메라 설정을 사용자 지정 하는 선택적 매개 변수.
+
+    {품질: 75, destinationType: Camera.DestinationType.DATA_URL, sourceType: Camera.PictureSourceType.CAMERA, allowEdit: 사실, encodingType: Camera.EncodingType.JPEG, targetWidth: 100, targetHeight: 100, popoverOptions: CameraPopoverOptions, saveToPhotoAlbum: false};
+    
+
+### 옵션
+
+*   **품질**: 범위 0-100, 100은 파일 압축에서 손실 없이 일반적으로 전체 해상도 저장된 된 이미지의 품질. 기본값은 50입니다. *(수)* (Note 카메라의 해상도 대 한 정보는 사용할 수 없습니다.)
+
+*   **destinationType**: 반환 값의 형식을 선택 합니다. 기본값은 FILE_URI입니다. 에 정의 된 `navigator.camera.DestinationType` *(수)*
+    
+        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**: 그림의 소스를 설정 합니다. 기본값은 카메라입니다. 에 정의 된 `navigator.camera.PictureSourceType` *(수)*
+    
+        Camera.PictureSourceType = {
+            PHOTOLIBRARY : 0,
+            CAMERA : 1,
+            SAVEDPHOTOALBUM : 2
+        };
+        
+
+*   **allowEdit**: 선택 하기 전에 이미지의 간단한 편집을 허용 합니다. *(부울)*
+
+*   **encodingType**: 반환 된 이미지 파일의 인코딩을 선택 합니다. 기본값은 JPEG입니다. 에 정의 된 `navigator.camera.EncodingType` *(수)*
+    
+        Camera.EncodingType = {
+            JPEG : 0,               // Return JPEG encoded image
+            PNG : 1                 // Return PNG encoded image
+        };
+        
+
+*   **targetWidth**: 스케일 이미지를 픽셀 너비. **TargetHeight**와 함께 사용 해야 합니다. 가로 세로 비율이 일정 하 게 유지 합니다. *(수)*
+
+*   **targetHeight**: 스케일 이미지를 픽셀 단위로 높이. **TargetWidth**와 함께 사용 해야 합니다. 가로 세로 비율이 일정 하 게 유지 합니다. *(수)*
+
+*   **mediaType**:에서 선택 미디어 유형을 설정 합니다. 때에 작동 `PictureSourceType` 는 `PHOTOLIBRARY` 또는 `SAVEDPHOTOALBUM` . 에 정의 된 `nagivator.camera.MediaType` *(수)*
+    
+        Camera.MediaType = {
+            PICTURE: 0,    // allow selection of still pictures only. 기본입니다. 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**: 캡처 도중 장치의 방향에 대 한 해결 하기 위해 이미지를 회전 합니다. *(부울)*
+
+*   **saveToPhotoAlbum**: 캡처 후 장치에서 사진 앨범에 이미지를 저장 합니다. *(부울)*
+
+*   **popoverOptions**: iPad에 popover 위치를 지정 하는 iOS 전용 옵션. 에 정의 된`CameraPopoverOptions`.
+
+*   **cameraDirection**: (앞 이나 뒤로-연결)를 사용 하 여 카메라를 선택 하십시오. 기본값은 다시. 에 정의 된 `navigator.camera.Direction` *(수)*
+    
+        Camera.Direction = {
+            BACK : 0,      // Use the back-facing camera
+            FRONT : 1      // Use the front-facing camera
+        };
+        
+
+### 아마존 화재 OS 단점
+
+*   어떤 `cameraDirection` 다시 연결 사진에 결과 값.
+
+*   무시는 `allowEdit` 매개 변수.
+
+*   `Camera.PictureSourceType.PHOTOLIBRARY`그리고 `Camera.PictureSourceType.SAVEDPHOTOALBUM` 둘 다 동일한 사진 앨범을 표시 합니다.
+
+### 안 드 로이드 단점
+
+*   어떤 `cameraDirection` 다시 연결 사진에 결과 값.
+
+*   무시는 `allowEdit` 매개 변수.
+
+*   `Camera.PictureSourceType.PHOTOLIBRARY`그리고 `Camera.PictureSourceType.SAVEDPHOTOALBUM` 둘 다 동일한 사진 앨범을 표시 합니다.
+
+### 블랙베리 10 단점
+
+*   무시는 `quality` 매개 변수.
+
+*   무시는 `allowEdit` 매개 변수.
+
+*   `Camera.MediaType`지원 되지 않습니다.
+
+*   무시는 `correctOrientation` 매개 변수.
+
+*   무시는 `cameraDirection` 매개 변수.
+
+### 파이어 폭스 OS 단점
+
+*   무시는 `quality` 매개 변수.
+
+*   `Camera.DestinationType`무시 되 고 `1` (이미지 파일 URI)
+
+*   무시는 `allowEdit` 매개 변수.
+
+*   무시는 `PictureSourceType` 매개 변수 (사용자가 선택 그것 대화 창에서)
+
+*   무시 하는`encodingType`
+
+*   무시는 `targetWidth` 와`targetHeight`
+
+*   `Camera.MediaType`지원 되지 않습니다.
+
+*   무시는 `correctOrientation` 매개 변수.
+
+*   무시는 `cameraDirection` 매개 변수.
+
+### iOS 단점
+
+*   설정 `quality` 일부 장치 메모리 오류를 피하기 위해 50 아래.
+
+*   사용 하는 경우 `destinationType.FILE_URI` , 사진 응용 프로그램의 임시 디렉터리에 저장 됩니다. 응용 프로그램이 종료 될 때 응용 프로그램의 임시 디렉터리의 내용은 삭제 됩니다.
+
+### Tizen 특수
+
+*   지원 되지 않는 옵션
+
+*   항상 파일 URI를 반환 합니다.
+
+### Windows Phone 7, 8 특수
+
+*   무시는 `allowEdit` 매개 변수.
+
+*   무시는 `correctOrientation` 매개 변수.
+
+*   무시는 `cameraDirection` 매개 변수.
+
+*   무시는 `saveToPhotoAlbum` 매개 변수. 중요: 모든 이미지 API wp7/8 코르도바 카메라로 촬영 항상 복사 됩니다 휴대 전화의 카메라 롤에. 사용자의 설정에 따라이 또한 그들의 OneDrive에 자동 업로드 이미지는 의미. 이 잠재적으로 이미지는 당신의 애플 리 케이 션을 위한 보다 넓은 청중에 게 사용할 수 있는 의미. 이 경우 응용 프로그램에 대 한 차단, 당신은 msdn에 설명 대로 단말기를 구현 해야 합니다: <http://msdn.microsoft.com/en-us/library/windowsphone/develop/hh394006.aspx> 수 있습니다 또한 의견 또는 [이슈 트래커][3] 에서 업-투표 관련된 문제
+
+*   무시는 `mediaType` 속성을 `cameraOptions` 으로 Windows Phone SDK PHOTOLIBRARY에서 비디오를 선택 하는 방법을 제공 하지 않습니다.
+
+ [3]: https://issues.apache.org/jira/browse/CB-2083
+
+## CameraError
+
+오류 메시지를 제공 하는 onError 콜백 함수.
+
+    function(message) {
+        // Show a helpful message
+    }
+    
+
+### 매개 변수
+
+*   **메시지**: 메시지는 장치의 네이티브 코드에 의해 제공 됩니다. *(문자열)*
+
+## cameraSuccess
+
+이미지 데이터를 제공 하는 onSuccess 콜백 함수.
+
+    function(imageData) {
+        // Do something with the image
+    }
+    
+
+### 매개 변수
+
+*   **imageData**: Base64 인코딩은 이미지 데이터, *또는* 이미지 파일에 따라 URI의 `cameraOptions` 적용. *(문자열)*
+
+### 예를 들어
+
+    // Show image
+    //
+    function cameraCallback(imageData) {
+        var image = document.getElementById('myImage');
+        image.src = "data:image/jpeg;base64," + imageData;
+    }
+    
+
+## CameraPopoverHandle
+
+에 의해 만들어진 popover 대화에 대 한 핸들`navigator.camera.getPicture`.
+
+### 메서드
+
+*   **setPosition**:는 popover의 위치를 설정 합니다.
+
+### 지원 되는 플랫폼
+
+*   iOS
+
+### setPosition
+
+popover의 위치를 설정 합니다.
+
+**매개 변수**:
+
+*   `cameraPopoverOptions`:는 `CameraPopoverOptions` 새 위치를 지정 하는
+
+### 예를 들어
+
+     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)
+         });
+    
+     // 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);
+     }
+    
+
+## CameraPopoverOptions
+
+iOS 전용 매개 변수 iPad의 보관 함 또는 앨범에서 이미지를 선택 하면 앵커 요소 위치와 화살표의 방향으로 popover 지정 하는.
+
+    {x: 0, y: 32, 폭: 320, 높이: 480, arrowDir: Camera.PopoverArrowDirection.ARROW_ANY};
+    
+
+### CameraPopoverOptions
+
+*   **x**: x는 popover 앵커는 화면 요소의 픽셀 좌표. *(수)*
+
+*   **y**: y 픽셀 좌표는 popover 앵커는 화면 요소입니다. *(수)*
+
+*   **폭**: 폭 (픽셀)는 popover 앵커는 화면 요소. *(수)*
+
+*   **높이**: 높이 (픽셀)는 popover 앵커는 화면 요소. *(수)*
+
+*   **arrowDir**: 방향 화살표는 popover 가리켜야 합니다. 에 정의 된 `Camera.PopoverArrowDirection` *(수)*
+    
+            Camera.PopoverArrowDirection = {
+                ARROW_UP : 1,        // matches iOS UIPopoverArrowDirection constants
+                ARROW_DOWN : 2,
+                ARROW_LEFT : 4,
+                ARROW_RIGHT : 8,
+                ARROW_ANY : 15
+            };
+        
+
+참고는 popover의 크기 조정 화살표 방향 및 화면 방향 변경 될 수 있습니다. 앵커 요소 위치를 지정 하는 경우 방향 변경에 대 한 계정에 있는지 확인 합니다.
+
+## navigator.camera.cleanup
+
+제거 임시 저장소에서 카메라로 찍은 사진을 중간.
+
+    navigator.camera.cleanup( cameraSuccess, cameraError );
+    
+
+### 설명
+
+제거 중간 전화 후 임시 저장소에 보관 된 이미지 파일 `camera.getPicture` . 경우에만 적용의 값 `Camera.sourceType` 와 `Camera.PictureSourceType.CAMERA` 와 `Camera.destinationType` 같음`Camera.DestinationType.FILE_URI`.
+
+### 지원 되는 플랫폼
+
+*   iOS
+
+### 예를 들어
+
+    navigator.camera.cleanup(onSuccess, onFail);
+    
+    function onSuccess() {
+        console.log("Camera cleanup success.")
+    }
+    
+    function onFail(message) {
+        alert('Failed because: ' + message);
+    }

doc/pl/index.md

@@ -0,0 +1,424 @@
+<!---
+    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.
+-->
+
+# org.apache.cordova.camera
+
+Wtyczka dostarcza API do robienia zdjęć i wybór zdjęć z biblioteki obrazu systemu.
+
+    cordova plugin add org.apache.cordova.camera
+    
+
+## navigator.camera.getPicture
+
+Pobiera zdjęcia za pomocą aparatu lub z galerii zdjęć w urządzeniu. Obraz jest przekazywany do funkcji zwrotnej success jako `String` kodowany za pomocą base64 lub jako URI do pliku. Sama metoda zwraca obiekt `CameraPopoverHandle`, który może służyć do zmiany położenia wyskakującego okna wyboru pliku.
+
+    navigator.camera.getPicture( cameraSuccess, cameraError, cameraOptions );
+    
+
+### Opis
+
+Funkcja `camera.getPicture` otwiera na urządzeniu domyślną aplikację aparatu, która pozwala użytkownikowi zrobić zdjęcie. To zachowanie występuje domyślnie, gdy `Camera.sourceType` jest równe `Camera.PictureSourceType.CAMERA`. Gdy użytkownik wykona zdjęcie, aplikacja aparatu zakończy działanie i nastąpi powrót do głównej aplikacji.
+
+Jeśli `Camera.sourceType` jest równe `Camera.PictureSourceType.PHOTOLIBRARY` lub `Camera.PictureSourceType.SAVEDPHOTOALBUM`, wtedy zostanie wyświetlone okno dialogowe pozwalające użytkownikowi na wybór istniejącego obrazu. Funkcja `camera.getPicture` zwraca obiekt `CameraPopoverHandle`, który obsługuje zmianę położenia okna wyboru obrazu, np. po zmianie orientacji urządzenia.
+
+Zwracana wartość jest wysyłana do funkcji zwrotnej `cameraSuccess` w jednym z następujących formatów, w zależności od określonego parametru `cameraOptions`:
+
+*   Jako `String` zawierający obraz zakodowany przy użyciu base64.
+
+*   Jako `String` reprezentujący lokację pliku obrazu w lokalnym magazynie (domyślnie).
+
+Z zakodowanym obrazem lub URI możesz zrobić co zechcesz, na przykład:
+
+*   Przedstawia obraz w tagu `<img>`, jak w przykładzie poniżej
+
+*   Zapisuje dane lokalnie (`LocalStorage`, [Lawnchair][1], etc.)
+
+*   Wysyła dane na zdalny serwer
+
+ [1]: http://brianleroux.github.com/lawnchair/
+
+**Uwaga**: zdjęcie rozdzielczości na nowsze urządzenia jest bardzo dobry. Zdjęcia wybrane z galerii urządzenia nie są skalowane do niższej jakości, nawet jeśli określono parametr `quality`. Aby uniknąć typowych problemów z pamięcią lepiej ustawić`Camera.destinationType` na `FILE_URI` niż `DATA_URL`.
+
+### Obsługiwane platformy
+
+*   Amazon ogień OS
+*   Android
+*   Jeżyna 10
+*   Przeglądarka
+*   Firefox OS
+*   iOS
+*   Tizen
+*   Windows Phone 7 i 8
+*   Windows 8
+
+### Preferencje (iOS)
+
+*   **CameraUsesGeolocation** (boolean, wartość domyślna to false). Do przechwytywania JPEG, zestaw do true, aby uzyskać danych geolokalizacyjnych w nagłówku EXIF. To spowoduje wniosek o geolokalizacji uprawnienia, jeśli zestaw na wartość true.
+    
+        <preference name="CameraUsesGeolocation" value="false" />
+        
+
+### Amazon ogień OS dziwactwa
+
+Amazon ogień OS używa intencje do rozpoczęcia działalności aparatu na urządzenie do przechwytywania obrazów, i na telefony z pamięci, Cordova aktywność może zostać zabity. W takim scenariuszu obrazy mogą nie być wyświetlane po przywróceniu aktywności Cordovy.
+
+### Android dziwactwa
+
+Android używa intencje do rozpoczęcia działalności aparatu na urządzenie do przechwytywania obrazów, i na telefony z pamięci, Cordova aktywność może zostać zabity. W tym scenariuszu obraz mogą nie być wyświetlane po przywróceniu aktywności Cordova.
+
+### Quirks przeglądarki
+
+Może zwracać tylko zdjęcia jako obraz w formacie algorytmem base64.
+
+### Firefox OS dziwactwa
+
+Aparat plugin jest obecnie implementowane za pomocą [Działania sieci Web][2].
+
+ [2]: https://hacks.mozilla.org/2013/01/introducing-web-activities/
+
+### iOS dziwactwa
+
+Tym JavaScript `alert()` w jednej z wywołania zwrotnego funkcji może powodować problemy. Owinąć alert w `setTimeout()` umożliwia wybór obrazu iOS lub popover całkowicie zamknąć zanim wyświetli alert:
+
+    setTimeout(function() {
+        // do your thing here!
+    }, 0);
+    
+
+### Windows Phone 7 dziwactwa
+
+Wywoływanie aparat native aplikacji, podczas gdy urządzenie jest podłączone przez Zune nie działa i powoduje błąd wywołania zwrotnego.
+
+### Osobliwości Tizen
+
+Tizen obsługuje tylko `destinationType` z `Camera.DestinationType.FILE_URI` i `sourceType` z`Camera.PictureSourceType.PHOTOLIBRARY`.
+
+### Przykład
+
+Zrób zdjęcie i pobrać go jako kodowane algorytmem base64 obrazu:
+
+    navigator.camera.getPicture(onSuccess, onFail, { quality: 50,
+        destinationType: Camera.DestinationType.DATA_URL
+    });
+    
+    function onSuccess(imageData) {
+        var image = document.getElementById('myImage');
+        image.src = "data:image/jpeg;base64," + imageData;
+    }
+    
+    function onFail(message) {
+        alert('Failed because: ' + message);
+    }
+    
+
+Zrób zdjęcie i pobrać lokalizacji pliku obrazu:
+
+    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);
+    }
+    
+
+## CameraOptions
+
+Opcjonalne parametry, aby dostosować ustawienia aparatu.
+
+    { 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 };
+    
+
+### Opcje
+
+*   **jakość**: jakość zapisany obraz, wyrażona jako zakres od 0 do 100, gdzie 100 jest zazwyczaj pełnej rozdzielczości bez utraty z kompresji plików. Wartością domyślną jest 50. *(Liczba)* (Należy zauważyć, że informacje o rozdzielczość kamery jest niedostępny).
+
+*   **destinationType**: Wybierz format zwracanej wartości. Wartością domyślną jest FILE_URI. Zdefiniowane w `navigator.camera.DestinationType` *(numer)*
+    
+        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**: Ustaw źródło obrazu. Wartością domyślną jest aparat fotograficzny. Zdefiniowane w `navigator.camera.PictureSourceType` *(numer)*
+    
+        Camera.PictureSourceType = {
+            PHOTOLIBRARY : 0,
+            CAMERA : 1,
+            SAVEDPHOTOALBUM : 2
+        };
+        
+
+*   **allowEdit**: umożliwia łatwą edycję obrazu przed zaznaczeniem. *(Wartość logiczna)*
+
+*   **encodingType**: Wybierz plik obrazu zwracany jest kodowanie. Domyślnie jest JPEG. Zdefiniowane w `navigator.camera.EncodingType` *(numer)*
+    
+        Camera.EncodingType = {
+            JPEG : 0,               // Return JPEG encoded image
+            PNG : 1                 // Return PNG encoded image
+        };
+        
+
+*   **targetWidth**: szerokość w pikselach na obraz skali. Musi być używany z **targetHeight**. Współczynnik proporcji pozostaje stała. *(Liczba)*
+
+*   **targetHeight**: wysokość w pikselach na obraz skali. Musi być używany z **targetWidth**. Współczynnik proporcji pozostaje stała. *(Liczba)*
+
+*   **mediaType**: zestaw typ nośnika, do wyboru. Działa tylko, gdy `PictureSourceType` jest `PHOTOLIBRARY` lub `SAVEDPHOTOALBUM` . Zdefiniowane w `nagivator.camera.MediaType` *(numer)*
+    
+        Camera.MediaType = {
+            PICTURE: 0,    // allow selection of still pictures only. DOMYŚLNIE. 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**: obracanie obrazu dla orientacji urządzenia podczas przechwytywania. *(Wartość logiczna)*
+
+*   **saveToPhotoAlbum**: Zapisz obraz do albumu fotograficznego na urządzenie po przechwytywania. *(Wartość logiczna)*
+
+*   **popoverOptions**: tylko do iOS opcje, które określają położenie popover w iPad. Zdefiniowane w`CameraPopoverOptions`.
+
+*   **cameraDirection**: Wybierz aparat do korzystania (lub z powrotem przodem). Wartością domyślną jest z powrotem. Zdefiniowane w `navigator.camera.Direction` *(numer)*
+    
+        Camera.Direction = {
+            BACK : 0,      // Use the back-facing camera
+            FRONT : 1      // Use the front-facing camera
+        };
+        
+
+### Amazon ogień OS dziwactwa
+
+*   Wszelkie `cameraDirection` wartość wyników w zdjęcie tyłu do kierunku jazdy.
+
+*   Ignoruje `allowEdit` parametr.
+
+*   `Camera.PictureSourceType.PHOTOLIBRARY`i `Camera.PictureSourceType.SAVEDPHOTOALBUM` wyświetlać ten sam album zdjęć.
+
+### Android dziwactwa
+
+*   Wszelkie `cameraDirection` wartość wyników w zdjęcie tyłu do kierunku jazdy.
+
+*   Ignoruje `allowEdit` parametr.
+
+*   `Camera.PictureSourceType.PHOTOLIBRARY`i `Camera.PictureSourceType.SAVEDPHOTOALBUM` wyświetlać ten sam album zdjęć.
+
+### Jeżyna 10 dziwactwa
+
+*   Ignoruje `quality` parametr.
+
+*   Ignoruje `allowEdit` parametr.
+
+*   `Camera.MediaType`nie jest obsługiwane.
+
+*   Ignoruje `correctOrientation` parametr.
+
+*   Ignoruje `cameraDirection` parametr.
+
+### Firefox OS dziwactwa
+
+*   Ignoruje `quality` parametr.
+
+*   `Camera.DestinationType`jest ignorowane i jest równa `1` (plik obrazu URI)
+
+*   Ignoruje `allowEdit` parametr.
+
+*   Ignoruje `PictureSourceType` parametr (użytkownik wybiera go w oknie dialogowym)
+
+*   Ignoruje`encodingType`
+
+*   Ignoruje `targetWidth` i`targetHeight`
+
+*   `Camera.MediaType`nie jest obsługiwane.
+
+*   Ignoruje `correctOrientation` parametr.
+
+*   Ignoruje `cameraDirection` parametr.
+
+### iOS dziwactwa
+
+*   Zestaw `quality` poniżej 50 do uniknięcia błędy pamięci na niektóre urządzenia.
+
+*   Podczas korzystania z `destinationType.FILE_URI` , zdjęcia są zapisywane w katalogu tymczasowego stosowania. Zawartość katalogu tymczasowego stosowania jest usuwany po zakończeniu aplikacji.
+
+### Osobliwości Tizen
+
+*   opcje nie są obsługiwane
+
+*   zawsze zwraca identyfikator URI pliku
+
+### Windows Phone 7 i 8 dziwactwa
+
+*   Ignoruje `allowEdit` parametr.
+
+*   Ignoruje `correctOrientation` parametr.
+
+*   Ignoruje `cameraDirection` parametr.
+
+*   Ignoruje `saveToPhotoAlbum` parametr. Ważne: Wszystkie zdjęcia zrobione aparatem wp7/8 cordova API są zawsze kopiowane do telefonu w kamerze. W zależności od ustawień użytkownika może to też oznaczać że obraz jest automatycznie przesłane do ich OneDrive. Potencjalnie może to oznaczać, że obraz jest dostępne dla szerszego grona odbiorców niż Twoja aplikacja przeznaczona. Jeśli ten bloker aplikacji, trzeba będzie wdrożenie CameraCaptureTask, opisane na msdn: <http://msdn.microsoft.com/en-us/library/windowsphone/develop/hh394006.aspx> można także komentarz lub górę głosowanie powiązanych kwestii w [śledzenia błędów][3]
+
+*   Ignoruje `mediaType` Właściwość `cameraOptions` jako SDK Windows Phone nie umożliwiają wybór filmów z PHOTOLIBRARY.
+
+ [3]: https://issues.apache.org/jira/browse/CB-2083
+
+## CameraError
+
+funkcja wywołania zwrotnego PrzyBłędzie, która zawiera komunikat o błędzie.
+
+    function(message) {
+        // Show a helpful message
+    }
+    
+
+### Parametry
+
+*   **wiadomość**: wiadomość jest świadczone przez urządzenie w kodzie macierzystym. *(String)*
+
+## cameraSuccess
+
+onSuccess funkcji wywołania zwrotnego, który dostarcza dane obrazu.
+
+    function(imageData) {
+        // Do something with the image
+    }
+    
+
+### Parametry
+
+*   **imageData**: kodowanie Base64 danych obrazu, *lub* plik obrazu URI, w zależności od `cameraOptions` w życie. *(String)*
+
+### Przykład
+
+    // Show image
+    //
+    function cameraCallback(imageData) {
+        var image = document.getElementById('myImage');
+        image.src = "data:image/jpeg;base64," + imageData;
+    }
+    
+
+## CameraPopoverHandle
+
+Uchwyt do okna dialogowego popover, stworzony przez`navigator.camera.getPicture`.
+
+### Metody
+
+*   **setPosition**: Ustaw pozycję popover.
+
+### Obsługiwane platformy
+
+*   iOS
+
+### setPosition
+
+Ustaw pozycję popover.
+
+**Parametry**:
+
+*   `cameraPopoverOptions`: `CameraPopoverOptions` , określ nowe położenie
+
+### Przykład
+
+     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)
+         });
+    
+     // 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);
+     }
+    
+
+## CameraPopoverOptions
+
+tylko do iOS parametrami, które określić kotwicy element lokalizacji i strzałka kierunku popover, przy wyborze zdjęć z iPad biblioteki lub album.
+
+    { x : 0,
+      y :  32,
+      width : 320,
+      height : 480,
+      arrowDir : Camera.PopoverArrowDirection.ARROW_ANY
+    };
+    
+
+### CameraPopoverOptions
+
+*   **x**: x współrzędnych pikseli ekran element na którym kotwica popover. *(Liczba)*
+
+*   **y**: Współrzędna y pikseli ekran element na którym kotwica popover. *(Liczba)*
+
+*   **szerokość**: szerokość w pikselach, ekran element na którym kotwica popover. *(Liczba)*
+
+*   **wysokość**: wysokość w pikselach elementów ekranu na którym kotwica popover. *(Liczba)*
+
+*   **arrowDir**: kierunek strzałki na popover powinien wskazywać. Zdefiniowane w `Camera.PopoverArrowDirection` *(numer)*
+    
+            Camera.PopoverArrowDirection = {
+                ARROW_UP : 1,        // matches iOS UIPopoverArrowDirection constants
+                ARROW_DOWN : 2,
+                ARROW_LEFT : 4,
+                ARROW_RIGHT : 8,
+                ARROW_ANY : 15
+            };
+        
+
+Należy pamiętać, że rozmiar popover może zmienić aby zmienić kierunek strzałki i orientacji ekranu. Upewnij się uwzględnić zmiany orientacji podczas określania położenia elementu kotwicy.
+
+## Navigator.Camera.CleanUp
+
+Usuwa pośrednie zdjęcia zrobione przez aparat z czasowego składowania.
+
+    navigator.camera.cleanup( cameraSuccess, cameraError );
+    
+
+### Opis
+
+Usuwa pośrednie plików obrazów, które są przechowywane w pamięci tymczasowej po `camera.getPicture` . Stosuje się tylko wtedy, gdy wartość `Camera.sourceType` jest równa `Camera.PictureSourceType.CAMERA` i `Camera.destinationType` jest równa`Camera.DestinationType.FILE_URI`.
+
+### Obsługiwane platformy
+
+*   iOS
+
+### Przykład
+
+    navigator.camera.cleanup(onSuccess, onFail);
+    
+    function onSuccess() {
+        console.log("Camera cleanup success.")
+    }
+    
+    function onFail(message) {
+        alert('Failed because: ' + message);
+    }

doc/ru/index.md

@@ -0,0 +1,417 @@
+<!---
+    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.
+-->
+
+# org.apache.cordova.camera
+
+Этот плагин предоставляет API для съемки и для выбора изображения из библиотеки изображений системы.
+
+    cordova plugin add org.apache.cordova.camera
+    
+
+## navigator.camera.getPicture
+
+Снимает фотографию с помощью камеры, или получает фотографию из галереи изображений устройства. Изображение передается на функцию обратного вызова успешного завершения как `String` в base64-кодировке, или как URI указывающего на файл изображения. Метод возвращает объект `CameraPopoverHandle`, который может использоваться для перемещения инструмента выбора файла.
+
+    navigator.camera.getPicture( cameraSuccess, cameraError, cameraOptions );
+    
+
+### Описание
+
+Функция `camera.getPicture` открывает приложение камеры устройства, которое позволяет снимать фотографии. Это происходит по умолчанию, когда `Camera.sourceType` равно `Camera.PictureSourceType.CAMERA` . Как только пользователь делает снимок,приложение камеры закрывается и приложение восстанавливается.
+
+Если `Camera.sourceType` является `Camera.PictureSourceType.PHOTOLIBRARY` или `Camera.PictureSourceType.SAVEDPHOTOALBUM` , то показывается диалоговое окно, которое позволяет пользователям выбрать существующее изображение. Функция `camera.getPicture` возвращает объект `CameraPopoverHandle` объект, который может использоваться для перемещения диалога выбора изображения, например, при изменении ориентации устройства.
+
+Возвращаемое значение отправляется в функцию обратного вызова `cameraSuccess` в одном из следующих форматов, в зависимости от параметра `cameraOptions` :
+
+*   A объект `String` содержащий фото изображение в base64-кодировке.
+
+*   Объект `String` представляющий расположение файла изображения на локальном хранилище (по умолчанию).
+
+Вы можете сделать все, что угодно вы хотите с закодированным изображением или URI, например:
+
+*   Отобразить изображение с помощью тега `<img>`, как показано в примере ниже
+
+*   Сохранять данные локально (`LocalStorage`, [Lawnchair][1], и т.д.)
+
+*   Отправлять данные на удаленный сервер
+
+ [1]: http://brianleroux.github.com/lawnchair/
+
+**Примечание**: разрешение фото на более новых устройствах является достаточно хорошим. Фотографии из галереи устройства не масштабируются к более низкому качеству, даже если указан параметр `quality`. Чтобы избежать общих проблем с памятью, установите `Camera.destinationType` в `FILE_URI` вместо `DATA_URL`.
+
+### Поддерживаемые платформы
+
+*   Amazon Fire ОС
+*   Android
+*   BlackBerry 10
+*   Обозреватель
+*   Firefox OS
+*   iOS
+*   Tizen
+*   Windows Phone 7 и 8
+*   Windows 8
+
+### Предпочтения (iOS)
+
+*   **CameraUsesGeolocation** (логическое значение, по умолчанию false). Для захвата изображения JPEG, значение true, чтобы получить данные геопозиционирования в заголовке EXIF. Это вызовет запрос на разрешения геолокации, если задано значение true.
+    
+        <preference name="CameraUsesGeolocation" value="false" />
+        
+
+### Amazon Fire OS причуды
+
+Amazon Fire OS используют намерения для запуска активности камеры на устройстве для съемки фотографий, и на устройствах с низким объемам памяти, активность Cordova может быть завершена. В этом случае изображение может не появиться при восстановлении активности Cordova.
+
+### Android причуды
+
+Android использует намерения начать действие камеры на устройстве для захвата изображения, и на телефонах с низкой памяти, могут быть убиты Cordova деятельность. В этом случае изображение не может появиться, когда Кордова активность восстанавливается.
+
+### Браузер причуды
+
+Может возвращать только фотографии как изображения в кодировке base64.
+
+### Firefox OS причуды
+
+Модуль камеры в настоящее время реализуется с помощью [Веб деятельности][2].
+
+ [2]: https://hacks.mozilla.org/2013/01/introducing-web-activities/
+
+### iOS причуды
+
+Включая JavaScript `alert()` в любом из обратного вызова функции может вызвать проблемы. Оберните оповещение в `setTimeout()` выбора изображений iOS или пирог полностью закрыть прежде чем отображает оповещения:
+
+    setTimeout(function() {/ / ваши вещи!}, 0);
+    
+
+### Windows Phone 7 причуды
+
+Вызов приложения родной камеры, в то время как устройство подключается через Zune не работает и инициирует обратный вызов для ошибки.
+
+### Причуды Tizen
+
+Tizen поддерживает только `destinationType` из `Camera.DestinationType.FILE_URI` и `sourceType` из`Camera.PictureSourceType.PHOTOLIBRARY`.
+
+### Пример
+
+Сфотографироваться и получить его в виде изображения в кодировке base64:
+
+    navigator.camera.getPicture(onSuccess, onFail, { quality: 50,
+        destinationType: Camera.DestinationType.DATA_URL
+    });
+    
+    function onSuccess(imageData) {
+        var image = document.getElementById('myImage');
+        image.src = "data:image/jpeg;base64," + imageData;
+    }
+    
+    function onFail(message) {
+        alert('Failed because: ' + message);
+    }
+    
+
+Сфотографироваться и получить расположение файла изображения:
+
+    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);
+    }
+    
+
+## CameraOptions
+
+Необязательные параметры для настройки параметров камеры.
+
+    { 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 };
+    
+
+### Параметры
+
+*   **качество**: качество сохраняемого изображения, выражается в виде диапазона 0-100, где 100 является обычно полным разрешением без потери от сжатия файлов. Значение по умолчанию — 50. *(Число)* (Обратите внимание, что информация о разрешение камеры недоступна.)
+
+*   **параметр destinationType**: выберите формат возвращаемого значения. Значение по умолчанию — FILE_URI. Определяется в `navigator.camera.DestinationType` *(число)*
+    
+        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)
+        };
+        
+
+*   **тип источника**: установить источник рисунка. По умолчанию используется камера. Определяется в `navigator.camera.PictureSourceType` *(число)*
+    
+        Camera.PictureSourceType = {
+            PHOTOLIBRARY : 0,
+            CAMERA : 1,
+            SAVEDPHOTOALBUM : 2
+        };
+        
+
+*   **allowEdit**: позволяют простое редактирование изображения перед выбором. *(Логическое)*
+
+*   **Тип_шифрования**: выберите возвращенный файл в кодировку. Значение по умолчанию — JPEG. Определяется в `navigator.camera.EncodingType` *(число)*
+    
+        Camera.EncodingType = {
+            JPEG : 0,               // Return JPEG encoded image
+            PNG : 1                 // Return PNG encoded image
+        };
+        
+
+*   **targetWidth**: ширина до масштаба изображения в пикселях. Должен использоваться с **targetHeight**. Соотношение остается неизменным. *(Число)*
+
+*   **targetHeight**: высота до масштаба изображения в пикселях. Должен использоваться с **targetWidth**. Соотношение остается неизменным. *(Число)*
+
+*   **тип носителя**: задать тип носителя, чтобы выбрать из. Работает только если `PictureSourceType` является `PHOTOLIBRARY` или `SAVEDPHOTOALBUM` . Определяется в `nagivator.camera.MediaType` *(число)*
+    
+        Camera.MediaType = {
+            PICTURE: 0,    // allow selection of still pictures only. ПО УМОЛЧАНИЮ. 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**: поворот изображения исправить для ориентации устройства во время захвата. *(Логическое)*
+
+*   **saveToPhotoAlbum**: сохранить изображение в фотоальбом на устройстве после захвата. *(Логическое)*
+
+*   **popoverOptions**: только для iOS параметры, которые определяют местоположение инструмента в iPad. Определены в`CameraPopoverOptions`.
+
+*   **cameraDirection**: выбрать камеру для использования (передней или задней стороне). Значение по умолчанию — обратно. Определяется в `navigator.camera.Direction` *(число)*
+    
+        Camera.Direction = {
+            BACK : 0,      // Use the back-facing camera
+            FRONT : 1      // Use the front-facing camera
+        };
+        
+
+### Amazon Fire OS причуды
+
+*   Любой `cameraDirection` значение результатов на задней стороне фотографии.
+
+*   Игнорирует параметр `allowEdit`.
+
+*   Оба параметра `Camera.PictureSourceType.PHOTOLIBRARY` и `Camera.PictureSourceType.SAVEDPHOTOALBUM` отображают один и тот же фотоальбом.
+
+### Android причуды
+
+*   Любой `cameraDirection` значение результатов на задней стороне фотографии.
+
+*   Игнорирует `allowEdit` параметр.
+
+*   `Camera.PictureSourceType.PHOTOLIBRARY`и `Camera.PictureSourceType.SAVEDPHOTOALBUM` как отображение же фотоальбом.
+
+### Причуды blackBerry 10
+
+*   Игнорирует `quality` параметр.
+
+*   Игнорирует `allowEdit` параметр.
+
+*   `Camera.MediaType`не поддерживается.
+
+*   Игнорирует `correctOrientation` параметр.
+
+*   Игнорирует `cameraDirection` параметр.
+
+### Firefox OS причуды
+
+*   Игнорирует `quality` параметр.
+
+*   `Camera.DestinationType`игнорируется и равен `1` (URI файла изображения)
+
+*   Игнорирует `allowEdit` параметр.
+
+*   Игнорирует `PictureSourceType` параметр (пользователь выбирает его в диалоговом окне)
+
+*   Игнорирует`encodingType`
+
+*   Игнорирует `targetWidth` и`targetHeight`
+
+*   `Camera.MediaType`не поддерживается.
+
+*   Игнорирует `correctOrientation` параметр.
+
+*   Игнорирует `cameraDirection` параметр.
+
+### iOS причуды
+
+*   Задать `quality` ниже 50, чтобы избежать ошибок памяти на некоторых устройствах.
+
+*   При использовании `destinationType.FILE_URI` , фотографии сохраняются во временном каталоге приложения. Содержимое приложения временного каталога удаляется при завершении приложения.
+
+### Причуды Tizen
+
+*   параметры, не поддерживаемые
+
+*   всегда возвращает URI файла
+
+### Windows Phone 7 и 8 причуды
+
+*   Игнорирует `allowEdit` параметр.
+
+*   Игнорирует `correctOrientation` параметр.
+
+*   Игнорирует `cameraDirection` параметр.
+
+*   Игнорирует `saveToPhotoAlbum` параметр. Важно: Все изображения, снятые камерой wp7/8 cordova API всегда копируются в рулон камеры телефона. В зависимости от параметров пользователя это также может означать, что изображение автоматически загружены на их OneDrive. Потенциально это может означать, что этот образ доступен для более широкой аудитории, чем ваше приложение предназначено. Если этот блокатор для вашего приложения, вам нужно будет осуществить CameraCaptureTask, как описано на сайте msdn: <http://msdn.microsoft.com/en-us/library/windowsphone/develop/hh394006.aspx> вы можете также комментарий или вверх голосование связанный с этим вопрос [отслеживания][3]
+
+*   Игнорирует `mediaType` свойство `cameraOptions` как Windows Phone SDK не обеспечивает способ выбора видео от PHOTOLIBRARY.
+
+ [3]: https://issues.apache.org/jira/browse/CB-2083
+
+## CameraError
+
+Функция обратного вызова onError, который предоставляет сообщение об ошибке.
+
+    function(message) {
+        // Show a helpful message
+    }
+    
+
+### Параметры
+
+*   **сообщение**: сообщение обеспечивается устройства машинного кода. *(Строка)*
+
+## cameraSuccess
+
+onSuccess обратного вызова функция, которая предоставляет данные изображения.
+
+    function(imageData) {
+        // Do something with the image
+    }
+    
+
+### Параметры
+
+*   **imageData**: Base64 кодирование изображения данных, *или* файла изображения URI, в зависимости от `cameraOptions` в силу. *(Строка)*
+
+### Пример
+
+    // Show image
+    //
+    function cameraCallback(imageData) {
+        var image = document.getElementById('myImage');
+        image.src = "data:image/jpeg;base64," + imageData;
+    }
+    
+
+## CameraPopoverHandle
+
+Дескриптор диалогового окна инструмента, созданного`navigator.camera.getPicture`.
+
+### Методы
+
+*   **setPosition**: установить положение инструмента.
+
+### Поддерживаемые платформы
+
+*   iOS
+
+### setPosition
+
+Задайте положение инструмента.
+
+**Параметры**:
+
+*   `cameraPopoverOptions`: `CameraPopoverOptions` , укажите новое положение
+
+### Пример
+
+     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)
+         });
+    
+     // 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);
+     }
+    
+
+## CameraPopoverOptions
+
+только для iOS параметры, указывающие якорь элемент расположение и стрелкой направление инструмента при выборе изображений из библиотеки iPad или альбома.
+
+    {x: 0, y: 32, ширина: 320, высота: 480, arrowDir: Camera.PopoverArrowDirection.ARROW_ANY};
+    
+
+### CameraPopoverOptions
+
+*   **x**: x координата пикселя элемента экрана, на который для закрепления инструмента. *(Число)*
+
+*   **y**: y координата пикселя элемента экрана, на который для закрепления инструмента. *(Число)*
+
+*   **Ширина**: ширина в пикселях экрана элемента, на который для закрепления инструмента. *(Число)*
+
+*   **рост**: высота в пикселях экрана элемента, на который для закрепления инструмента. *(Число)*
+
+*   **arrowDir**: стрелка на пирог следует указывать направление. Определяется в `Camera.PopoverArrowDirection` *(число)*
+    
+            Camera.PopoverArrowDirection = {
+                ARROW_UP : 1,        // matches iOS UIPopoverArrowDirection constants
+                ARROW_DOWN : 2,
+                ARROW_LEFT : 4,
+                ARROW_RIGHT : 8,
+                ARROW_ANY : 15
+            };
+        
+
+Обратите внимание, что размер инструмента может измениться для регулировки в направлении стрелки и ориентации экрана. Убедитесь в том, что для учета изменения ориентации при указании расположения элемента привязки.
+
+## navigator.camera.cleanup
+
+Удаляет промежуточные фотографии, снятые на камеру от временного хранения.
+
+    navigator.camera.cleanup( cameraSuccess, cameraError );
+    
+
+### Описание
+
+Удаляет промежуточные файлы изображений, которые хранятся в временного хранения после вызова метода `camera.getPicture` . Применяется только тогда, когда значение `Camera.sourceType` равно `Camera.PictureSourceType.CAMERA` и `Camera.destinationType` равно`Camera.DestinationType.FILE_URI`.
+
+### Поддерживаемые платформы
+
+*   iOS
+
+### Пример
+
+    navigator.camera.cleanup(onSuccess, onFail);
+    
+    function onSuccess() {
+        console.log("Camera cleanup success.")
+    }
+    
+    function onFail(message) {
+        alert('Failed because: ' + message);
+    }

doc/zh/index.md

@@ -0,0 +1,410 @@
+<!---
+    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.
+-->
+
+# org.apache.cordova.camera
+
+這個外掛程式提供了一個 API，拍照，從系統的圖像庫中選擇圖像。
+
+    cordova plugin add org.apache.cordova.camera
+    
+
+## navigator.camera.getPicture
+
+需要使用的相機，一張照片或從設備的圖像庫檢索一張照片。 圖像作為 base64 編碼傳遞成功回檔到 `String` ，或作為影像檔的 URI。 該方法本身返回 `CameraPopoverHandle` 可以用於重新置放檔選擇彈出的物件。
+
+    navigator.camera.getPicture( cameraSuccess, cameraError, cameraOptions );
+    
+
+### 說明
+
+`camera.getPicture`函數將打開該設備的預設攝像頭應用程式，使使用者能夠對齊圖片。 預設情況下，會發生此行為時 `Camera.sourceType` 等於 `Camera.PictureSourceType.CAMERA` 。 一旦使用者快照照片、 攝像頭應用程式關閉，並恢復該應用程式。
+
+如果 `Camera.sourceType` 是 `Camera.PictureSourceType.PHOTOLIBRARY` 或 `Camera.PictureSourceType.SAVEDPHOTOALBUM` ，然後允許使用者選擇一個現有圖像對話方塊的顯示。 `camera.getPicture`函數返回 `CameraPopoverHandle` 物件，可用於設備方向更改時重新置放圖像選擇對話方塊，例如。
+
+傳回值發送到 `cameraSuccess` 回呼函數，根據指定的以下格式之一 `cameraOptions` ：
+
+*   A `String` 包含的 base64 編碼的照片圖像。
+
+*   A `String` 表示在本機存放區 （預設值） 上的影像檔位置。
+
+你可以做任何你想與編碼的圖像或 URI，例如：
+
+*   呈現在圖像 `<img>` 標記，如下面的示例所示
+
+*   保存本地的資料 （ `LocalStorage` ， [Lawnchair][1]，等等.)
+
+*   將資料發佈到遠端伺服器
+
+ [1]: http://brianleroux.github.com/lawnchair/
+
+**注**： 在較新的設備上的照片解析度是相當好。 從設備的庫選擇了照片不到較低的品質，壓縮螢幕使即使 `quality` 指定參數。 為了避免常見的記憶體問題，設置 `Camera.destinationType` 到 `FILE_URI` 而不是`DATA_URL`.
+
+### 支援的平臺
+
+*   亞馬遜火 OS
+*   Android 系統
+*   黑莓 10
+*   瀏覽器
+*   火狐瀏覽器的作業系統
+*   iOS
+*   泰
+*   Windows Phone 7 和 8
+*   Windows 8
+
+### 首選項 （iOS）
+
+*   **CameraUsesGeolocation**（布林值，預設值為 false）。 用於捕獲 jpeg 檔，設置為 true，以在 EXIF 頭資訊中獲取地理定位資料。 這將觸發請求的地理位置的許可權，如果設置為 true。
+    
+        <preference name="CameraUsesGeolocation" value="false" />
+        
+
+### 亞馬遜火 OS 怪癖
+
+亞馬遜火 OS 使用意向啟動捕獲圖像，在設備上的相機活動和與低記憶體手機，科爾多瓦活動可能被殺。 在此方案中，可能不會顯示圖像還原科爾多瓦活動時。
+
+### Android 的怪癖
+
+Android 使用意向啟動捕獲圖像，在設備上的相機活動和與低記憶體手機，科爾多瓦活動可能被殺。 在此方案中，可能不會顯示圖像還原科爾多瓦活動時。
+
+### 瀏覽器的怪癖
+
+可以只返回照片作為 base64 編碼的圖像。
+
+### 火狐瀏覽器作業系統的怪癖
+
+觀景窗外掛程式目前實施使用[Web 活動][2].
+
+ [2]: https://hacks.mozilla.org/2013/01/introducing-web-activities/
+
+### iOS 的怪癖
+
+包括 JavaScript `alert()` 在任何回呼函數可能會導致問題。 包裝內的警報 `setTimeout()` 允許 iOS 圖像選取器或氣泡框以完全關閉之前，警報將顯示：
+
+    setTimeout(function() {/ / 做你的事!}，0) ；
+    
+
+### Windows Phone 7 的怪癖
+
+調用本機攝像頭應用程式，而通過 Zune 所連接的設備不能工作，並且觸發錯誤回檔。
+
+### 泰怪癖
+
+泰僅支援 `destinationType` 的 `Camera.DestinationType.FILE_URI` 和 `sourceType` 的`Camera.PictureSourceType.PHOTOLIBRARY`.
+
+### 示例
+
+拍一張照片，並檢索它作為一個 base64 編碼的圖像：
+
+    navigator.camera.getPicture(onSuccess, onFail, { quality: 50,
+        destinationType: Camera.DestinationType.DATA_URL
+    });
+    
+    function onSuccess(imageData) {
+        var image = document.getElementById('myImage');
+        image.src = "data:image/jpeg;base64," + imageData;
+    }
+    
+    function onFail(message) {
+        alert('Failed because: ' + message);
+    }
+    
+
+拍一張照片和檢索圖像的檔位置：
+
+    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);
+    }
+    
+
+## CameraOptions
+
+要自訂相機設置的可選參數。
+
+    {品質： 75，destinationType： Camera.DestinationType.DATA_URL，sourceType： Camera.PictureSourceType.CAMERA，allowEdit： 為 true，encodingType： Camera.EncodingType.JPEG，targetWidth： 100，targetHeight： 100，popoverOptions： CameraPopoverOptions，saveToPhotoAlbum： 虛假} ；
+    
+
+### 選項
+
+*   **品質**： 保存的圖像，表示為範圍 0-100，100，是通常全解析度，無損失從檔案壓縮的品質。 預設值為 50。 *（人數）*（請注意相機的解析度有關的資訊是不可用）。
+
+*   **可**： 選擇傳回值的格式。預設值是 FILE_URI。定義在 `navigator.camera.DestinationType` *（人數）*
+    
+        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)
+        };
+        
+
+*   **時**： 設置圖片的來源。預設值是觀景窗。定義在 `navigator.camera.PictureSourceType` *（人數）*
+    
+        Camera.PictureSourceType = {
+            PHOTOLIBRARY : 0,
+            CAMERA : 1,
+            SAVEDPHOTOALBUM : 2
+        };
+        
+
+*   **allowEdit**： 允許簡單編輯前選擇圖像。*（布林）*
+
+*   **encodingType**： 選擇返回的影像檔的編碼。預設值為 JPEG。定義在 `navigator.camera.EncodingType` *（人數）*
+    
+        Camera.EncodingType = {
+            JPEG : 0,               // Return JPEG encoded image
+            PNG : 1                 // Return PNG encoded image
+        };
+        
+
+*   **targetWidth**： 向尺度圖像的圖元寬度。必須用**targetHeight**。縱橫比保持不變。*（人數）*
+
+*   **targetHeight**： 以圖元為單位向尺度圖像的高度。必須用**targetWidth**。縱橫比保持不變。*（人數）*
+
+*   **媒體類型**： 設置的媒體，從選擇類型。 時才起作用 `PictureSourceType` 是 `PHOTOLIBRARY` 或 `SAVEDPHOTOALBUM` 。 定義在 `nagivator.camera.MediaType` *（人數）*
+    
+        Camera.MediaType = {
+            PICTURE: 0,    // allow selection of still pictures only. 預設情況。 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**： 旋轉圖像，該設備時捕獲的定向的正確。*（布林）*
+
+*   **saveToPhotoAlbum**： 將圖像保存到相冊在設備上捕獲後。*（布林）*
+
+*   **popoverOptions**： 只有 iOS 在 iPad 中指定氣泡框位置的選項。在中定義`CameraPopoverOptions`.
+
+*   **cameraDirection**： 選擇相機以使用 （前面或後面-面向）。預設值是背。定義在 `navigator.camera.Direction` *（人數）*
+    
+        Camera.Direction = {
+            BACK : 0,      // Use the back-facing camera
+            FRONT : 1      // Use the front-facing camera
+        };
+        
+
+### 亞馬遜火 OS 怪癖
+
+*   任何 `cameraDirection` 值回朝的照片中的結果。
+
+*   忽略 `allowEdit` 參數。
+
+*   `Camera.PictureSourceType.PHOTOLIBRARY`和 `Camera.PictureSourceType.SAVEDPHOTOALBUM` 都顯示相同的相冊。
+
+### Android 的怪癖
+
+*   任何 `cameraDirection` 值結果在背面的照片。
+
+*   忽略 `allowEdit` 參數。
+
+*   `Camera.PictureSourceType.PHOTOLIBRARY`和 `Camera.PictureSourceType.SAVEDPHOTOALBUM` 都顯示相同的寫真集。
+
+### 黑莓 10 的怪癖
+
+*   忽略 `quality` 參數。
+
+*   忽略 `allowEdit` 參數。
+
+*   `Camera.MediaType`不受支援。
+
+*   忽略 `correctOrientation` 參數。
+
+*   忽略 `cameraDirection` 參數。
+
+### 火狐瀏覽器作業系統的怪癖
+
+*   忽略 `quality` 參數。
+
+*   `Camera.DestinationType`將被忽略並且等於 `1` （影像檔的 URI）
+
+*   忽略 `allowEdit` 參數。
+
+*   忽略 `PictureSourceType` 參數 （使用者選擇它在對話方塊視窗中)
+
+*   忽略`encodingType`
+
+*   忽略了 `targetWidth` 和`targetHeight`
+
+*   `Camera.MediaType`不受支援。
+
+*   忽略 `correctOrientation` 參數。
+
+*   忽略 `cameraDirection` 參數。
+
+### iOS 的怪癖
+
+*   設置 `quality` 低於 50，避免在某些設備上的記憶體不足錯誤。
+
+*   當使用 `destinationType.FILE_URI` ，照片都保存在應用程式的臨時目錄。應用程式結束時，將刪除該應用程式的臨時目錄中的內容。
+
+### 泰怪癖
+
+*   不支援的選項
+
+*   總是返回一個檔的 URI
+
+### Windows Phone 7 和 8 的怪癖
+
+*   忽略 `allowEdit` 參數。
+
+*   忽略 `correctOrientation` 參數。
+
+*   忽略 `cameraDirection` 參數。
+
+*   忽略 `saveToPhotoAlbum` 參數。 重要： 使用 wp7/8 科爾多瓦攝像頭 API 拍攝的所有圖像總是都複製到手機的相機膠捲。 根據使用者的設置，這可能也意味著圖像是自動上傳到他們另。 這有可能意味著的圖像，可以比你的應用程式的目的更多的觀眾。 如果此阻滯劑您的應用程式，您將需要實現 CameraCaptureTask 在 msdn 上記載： [HTTP://msdn.microsoft.com/en-us/library/windowsphone/develop/hh394006.aspx][3]你可能還評論或在[問題追蹤器][4]的向上投票的相關的問題
+
+*   忽略了 `mediaType` 屬性的 `cameraOptions` 作為 Windows Phone SDK 並不提供從 PHOTOLIBRARY 中選擇視頻的方法。
+
+ [3]: http://msdn.microsoft.com/en-us/library/windowsphone/develop/hh394006.aspx
+ [4]: https://issues.apache.org/jira/browse/CB-2083
+
+## CameraError
+
+onError 的回呼函數提供了一條錯誤訊息。
+
+    function(message) {
+        // Show a helpful message
+    }
+    
+
+### 參數
+
+*   **消息**： 消息提供的設備的本機代碼。*（字串）*
+
+## cameraSuccess
+
+提供的圖像資料的 onSuccess 回呼函數。
+
+    function(imageData) {
+        // Do something with the image
+    }
+    
+
+### 參數
+
+*   **圖像資料**： Base64 編碼進行編碼的圖像資料，*或*影像檔的 URI，取決於 `cameraOptions` 效果。*（字串）*
+
+### 示例
+
+    // Show image
+    //
+    function cameraCallback(imageData) {
+        var image = document.getElementById('myImage');
+        image.src = "data:image/jpeg;base64," + imageData;
+    }
+    
+
+## CameraPopoverHandle
+
+由創建的氣泡框對話方塊的控制碼`navigator.camera.getPicture`.
+
+### 方法
+
+*   **setPosition**： 設置氣泡框的位置。
+
+### 支援的平臺
+
+*   iOS
+
+### setPosition
+
+設置氣泡框的位置。
+
+**參數**：
+
+*   `cameraPopoverOptions`： `CameraPopoverOptions` ，指定新的位置
+
+### 示例
+
+     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)
+         });
+    
+     // 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);
+     }
+    
+
+## CameraPopoverOptions
+
+iOS 僅指定氣泡框的錨元素的位置和箭頭方向，從 iPad 庫或專輯選擇圖像時的參數。
+
+    {x: 0，y： 32，寬度： 320，高度： 480，arrowDir： Camera.PopoverArrowDirection.ARROW_ANY} ；
+    
+
+### CameraPopoverOptions
+
+*   **x**： x 螢幕元素到其錨定氣泡框上的圖元座標。*（人數）*
+
+*   **y**： 螢幕元素到其錨定氣泡框上的 y 圖元座標。*（人數）*
+
+*   **寬度**： 寬度以圖元為單位），到其錨定氣泡框上的螢幕元素。*（人數）*
+
+*   **高度**： 高度以圖元為單位），到其錨定氣泡框上的螢幕元素。*（人數）*
+
+*   **arrowDir**： 氣泡框上的箭頭應指向的方向。定義在 `Camera.PopoverArrowDirection` *（人數）*
+    
+            Camera.PopoverArrowDirection = {
+                ARROW_UP : 1,        // matches iOS UIPopoverArrowDirection constants
+                ARROW_DOWN : 2,
+                ARROW_LEFT : 4,
+                ARROW_RIGHT : 8,
+                ARROW_ANY : 15
+            };
+        
+
+請注意氣泡框的大小可能會更改箭頭的方向和螢幕的方向進行調整。 請確保帳戶方向更改時指定錨元素位置。
+
+## navigator.camera.cleanup
+
+刪除中間從臨時存儲攝像機所拍攝的照片。
+
+    navigator.camera.cleanup( cameraSuccess, cameraError );
+    
+
+### 描述
+
+刪除中間打完電話後保留在臨時存儲中的影像檔 `camera.getPicture` 。 只有當適用的價值 `Camera.sourceType` 等於 `Camera.PictureSourceType.CAMERA` 和 `Camera.destinationType` 等於`Camera.DestinationType.FILE_URI`.
+
+### 支援的平臺
+
+*   iOS
+
+### 示例
+
+    navigator.camera.cleanup(onSuccess, onFail);
+    
+    function onSuccess() {
+        console.log("Camera cleanup success.")
+    }
+    
+    function onFail(message) {
+        alert('Failed because: ' + message);
+    }

plugin.xml

@@ -22,7 +22,7 @@
     xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:rim="http://www.blackberry.com/ns/widgets"
     id="org.apache.cordova.camera"
-    version="0.2.10-dev">
+    version="0.3.2">
     <name>Camera</name>
     <description>Cordova Camera Plugin</description>
     <license>Apache 2.0</license>
@@ -56,7 +56,7 @@
           <runs />
         </js-module>
     </platform>  
-    
+
     <!-- android -->
     <platform name="android">
         <config-file target="res/xml/config.xml" parent="/*">
@@ -126,6 +126,7 @@
              <feature name="Camera">
                  <param name="ios-package" value="CDVCamera" />
              </feature>
+             <preference name="CameraUsesGeolocation" value="false" />
          </config-file>
 
          <js-module src="www/ios/CameraPopoverHandle.js" name="CameraPopoverHandle">
@@ -135,13 +136,19 @@
          <header-file src="src/ios/CDVCamera.h" />
          <source-file src="src/ios/CDVCamera.m" />
          <header-file src="src/ios/CDVJpegHeaderWriter.h" />
- 	     <source-file src="src/ios/CDVJpegHeaderWriter.m" />
- 	     <header-file src="src/ios/CDVExif.h" />
- 	     <framework src="ImageIO.framework" weak="true" />
- 	     <framework src="CoreLocation.framework" />
- 	     <framework src="CoreGraphics.framework" />
- 	     <framework src="AssetsLibrary.framework" />
+         <source-file src="src/ios/CDVJpegHeaderWriter.m" />
+         <header-file src="src/ios/CDVExif.h" />
+         <framework src="ImageIO.framework" weak="true" />
+         <framework src="CoreLocation.framework" />
+         <framework src="CoreGraphics.framework" />
+         <framework src="AssetsLibrary.framework" />
          <framework src="MobileCoreServices.framework" />
+         <framework src="CoreGraphics.framework" />
+         
+         <config-file target="*-Info.plist" parent="NSLocationWhenInUseUsageDescription">
+             <string></string>
+         </config-file>
+                  
      </platform>
 
     <!-- blackberry10 -->
@@ -152,10 +159,12 @@
         </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 -->
@@ -202,7 +211,6 @@
     <!-- windows8 -->
     <platform name="windows8">
 
-        <dependency id="org.apache.cordova.file" />
         <config-file target="package.appxmanifest" parent="/Package/Capabilities">
             <Capability Name="picturesLibrary" />
             <DeviceCapability Name="webcam" />
@@ -210,10 +218,47 @@
         <js-module src="www/CameraPopoverHandle.js" name="CameraPopoverHandle">
             <clobbers target="CameraPopoverHandle" />
         </js-module>
-        <js-module src="src/windows8/CameraProxy.js" name="CameraProxy">
+        <js-module src="src/windows/CameraProxy.js" name="CameraProxy">
             <merges target="" />
         </js-module>
 
     </platform>
 
+    <!-- browser -->
+    <platform name="browser">
+        <config-file target="config.xml" parent="/*">
+            <feature name="Camera">
+                <param name="browser-package" value="Camera" />
+            </feature>
+        </config-file>
+
+        <js-module src="src/browser/CameraProxy.js" name="CameraProxy">
+            <runs />
+        </js-module>
+    </platform>
+
+    <!-- windows -->
+    <platform name="windows">
+        <config-file target="package.windows.appxmanifest" parent="/Package/Capabilities">
+            <Capability Name="picturesLibrary" />
+            <DeviceCapability Name="webcam" />
+        </config-file>
+        <config-file target="package.windows80.appxmanifest" parent="/Package/Capabilities">
+            <Capability Name="picturesLibrary" />
+            <DeviceCapability Name="webcam" />
+        </config-file>
+        <config-file target="package.phone.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>
+
+
+
 </plugin>

src/android/CameraLauncher.java

@@ -34,16 +34,18 @@ import org.json.JSONArray;
 import org.json.JSONException;
 
 import android.app.Activity;
+import android.content.ActivityNotFoundException;
 import android.content.ContentValues;
 import android.content.Intent;
 import android.database.Cursor;
 import android.graphics.Bitmap;
+import android.graphics.Bitmap.CompressFormat;
 import android.graphics.BitmapFactory;
 import android.graphics.Matrix;
-import android.graphics.Bitmap.CompressFormat;
 import android.media.MediaScannerConnection;
 import android.media.MediaScannerConnection.MediaScannerConnectionClient;
 import android.net.Uri;
+import android.os.Bundle;
 import android.os.Environment;
 import android.provider.MediaStore;
 import android.util.Base64;
@@ -58,7 +60,7 @@ public class CameraLauncher extends CordovaPlugin implements MediaScannerConnect
 
     private static final int DATA_URL = 0;              // Return base64 encoded string
     private static final int FILE_URI = 1;              // Return file uri (content://media/external/images/media/2 for Android)
-    private static final int NATIVE_URI = 2;            // On Android, this is the same as FILE_URI
+    private static final int NATIVE_URI = 2;                    // On Android, this is the same as FILE_URI
 
     private static final int PHOTOLIBRARY = 0;          // Choose image from picture library (same as SAVEDPHOTOALBUM for Android)
     private static final int CAMERA = 1;                // Take picture from camera
@@ -75,6 +77,7 @@ public class CameraLauncher extends CordovaPlugin implements MediaScannerConnect
     private static final String GET_All = "Get All";
     
     private static final String LOG_TAG = "CameraLauncher";
+    private static final int CROP_CAMERA = 100;
 
     private int mQuality;                   // Compression quality hint (0-100: 0=low quality & high compression, 100=compress of max quality)
     private int targetWidth;                // desired width of the image
@@ -85,13 +88,14 @@ public class CameraLauncher extends CordovaPlugin implements MediaScannerConnect
     private boolean saveToPhotoAlbum;       // Should the picture be saved to the device's photo album
     private boolean correctOrientation;     // Should the pictures orientation be corrected
     private boolean orientationCorrected;   // Has the picture's orientation been corrected
-    //private boolean allowEdit;              // Should we allow the user to crop the image. UNUSED.
+    private boolean allowEdit;              // Should we allow the user to crop the image.
 
     public CallbackContext callbackContext;
     private int numPics;
 
     private MediaScannerConnection conn;    // Used to update gallery app with newly-written files
     private Uri scanMe;                     // Uri of image to be added to content store
+    private Uri croppedUri;
 
     /**
      * Executes the request and returns PluginResult.
@@ -121,7 +125,7 @@ public class CameraLauncher extends CordovaPlugin implements MediaScannerConnect
             this.targetHeight = args.getInt(4);
             this.encodingType = args.getInt(5);
             this.mediaType = args.getInt(6);
-            //this.allowEdit = args.getBoolean(7); // This field is unused.
+            this.allowEdit = args.getBoolean(7);
             this.correctOrientation = args.getBoolean(8);
             this.saveToPhotoAlbum = args.getBoolean(9);
 
@@ -139,7 +143,7 @@ public class CameraLauncher extends CordovaPlugin implements MediaScannerConnect
                     this.takePicture(destType, encodingType);
                 }
                 else if ((srcType == PHOTOLIBRARY) || (srcType == SAVEDPHOTOALBUM)) {
-                    this.getImage(srcType, destType);
+                    this.getImage(srcType, destType, encodingType);
                 }
             }
             catch (IllegalArgumentException e)
@@ -238,33 +242,93 @@ public class CameraLauncher extends CordovaPlugin implements MediaScannerConnect
      * @param quality           Compression quality hint (0-100: 0=low quality & high compression, 100=compress of max quality)
      * @param srcType           The album to get image from.
      * @param returnType        Set the type of image to return.
+     * @param encodingType 
      */
     // TODO: Images selected from SDCARD don't display correctly, but from CAMERA ALBUM do!
-    public void getImage(int srcType, int returnType) {
+    // TODO: Images from kitkat filechooser not going into crop function
+    public void getImage(int srcType, int returnType, int encodingType) {
         Intent intent = new Intent();
         String title = GET_PICTURE;
+        croppedUri = null;
         if (this.mediaType == PICTURE) {
             intent.setType("image/*");
+            if (this.allowEdit) {
+                intent.setAction(Intent.ACTION_PICK);
+                intent.putExtra("crop", "true");
+                if (targetWidth > 0) {
+                    intent.putExtra("outputX", targetWidth);
+                }
+                if (targetHeight > 0) {
+                    intent.putExtra("outputY", targetHeight);
+                }
+                if (targetHeight > 0 && targetWidth > 0 && targetWidth == targetHeight) {
+                    intent.putExtra("aspectX", 1);
+                    intent.putExtra("aspectY", 1);
+                }
+                File photo = createCaptureFile(encodingType);
+                croppedUri = Uri.fromFile(photo);
+                intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, croppedUri);
+            } else {
+                intent.setAction(Intent.ACTION_GET_CONTENT);
+                intent.addCategory(Intent.CATEGORY_OPENABLE);
+            }
+        } else if (this.mediaType == VIDEO) {
+                intent.setType("video/*");
+                title = GET_VIDEO;
+          intent.setAction(Intent.ACTION_GET_CONTENT);
+          intent.addCategory(Intent.CATEGORY_OPENABLE);
+        } else if (this.mediaType == ALLMEDIA) {
+                // I wanted to make the type 'image/*, video/*' but this does not work on all versions
+                // of android so I had to go with the wildcard search.
+                intent.setType("*/*");
+                title = GET_All;
+          intent.setAction(Intent.ACTION_GET_CONTENT);
+          intent.addCategory(Intent.CATEGORY_OPENABLE);
         }
-        else if (this.mediaType == VIDEO) {
-            intent.setType("video/*");
-            title = GET_VIDEO;
-        }
-        else if (this.mediaType == ALLMEDIA) {
-            // I wanted to make the type 'image/*, video/*' but this does not work on all versions
-            // of android so I had to go with the wildcard search.
-            intent.setType("*/*");
-            title = GET_All;
-        }
-
-        intent.setAction(Intent.ACTION_GET_CONTENT);
-        intent.addCategory(Intent.CATEGORY_OPENABLE);
         if (this.cordova != null) {
             this.cordova.startActivityForResult((CordovaPlugin) this, Intent.createChooser(intent,
                     new String(title)), (srcType + 1) * 16 + returnType + 1);
         }
     }
 
+  /**
+   * Brings up the UI to perform crop on passed image URI
+   * 
+   * @param picUri
+   */
+  private void performCrop(Uri picUri) {
+    try {
+      Intent cropIntent = new Intent("com.android.camera.action.CROP");
+      // indicate image type and Uri
+      cropIntent.setDataAndType(picUri, "image/*");
+      // set crop properties
+      cropIntent.putExtra("crop", "true");
+      // indicate output X and Y
+      if (targetWidth > 0) {
+          cropIntent.putExtra("outputX", targetWidth);
+      }
+      if (targetHeight > 0) {
+          cropIntent.putExtra("outputY", targetHeight);
+      }
+      if (targetHeight > 0 && targetWidth > 0 && targetWidth == targetHeight) {
+          cropIntent.putExtra("aspectX", 1);
+          cropIntent.putExtra("aspectY", 1);
+      }
+      // retrieve data on return
+      cropIntent.putExtra("return-data", true);
+      // start the activity - we handle returning in onActivityResult
+
+      if (this.cordova != null) {
+        this.cordova.startActivityForResult((CordovaPlugin) this,
+            cropIntent, CROP_CAMERA);
+      }
+    } catch (ActivityNotFoundException anfe) {
+      Log.e(LOG_TAG, "Crop operation not supported on this device");
+      // Send Uri back to JavaScript for viewing image
+      this.callbackContext.success(picUri.toString());
+    }
+  }
+
     /**
      * Applies all needed transformation to the image received from the camera.
      *
@@ -316,14 +380,19 @@ public class CameraLauncher extends CordovaPlugin implements MediaScannerConnect
         else if (destType == FILE_URI || destType == NATIVE_URI) {
             if (this.saveToPhotoAlbum) {
                 Uri inputUri = getUriFromMediaStore();
-                //Just because we have a media URI doesn't mean we have a real file, we need to make it
-                uri = Uri.fromFile(new File(FileHelper.getRealPath(inputUri, this.cordova)));
+                try {
+                    //Just because we have a media URI doesn't mean we have a real file, we need to make it
+                    uri = Uri.fromFile(new File(FileHelper.getRealPath(inputUri, this.cordova)));
+                } catch (NullPointerException e) {
+                    uri = null;
+                }
             } else {
                 uri = Uri.fromFile(new File(getTempDirectoryPath(), System.currentTimeMillis() + ".jpg"));
             }
 
             if (uri == null) {
                 this.failPicture("Error capturing image - no media storage found.");
+                return;
             }
 
             // If all this is true we shouldn't compress the image.
@@ -355,17 +424,22 @@ public class CameraLauncher extends CordovaPlugin implements MediaScannerConnect
                     exif.createOutFile(exifPath);
                     exif.writeExifData();
                 }
-
+                if (this.allowEdit) {
+                    performCrop(uri);
+                } else {
+                    // Send Uri back to JavaScript for viewing image
+                    this.callbackContext.success(uri.toString());
+                }
             }
-            // Send Uri back to JavaScript for viewing image
-            this.callbackContext.success(uri.toString());
+        } else {
+            throw new IllegalStateException();
         }
 
         this.cleanup(FILE_URI, this.imageUri, uri, bitmap);
         bitmap = null;
     }
-    
-    private String ouputModifiedBitmap(Bitmap bitmap, Uri uri) throws IOException {
+
+private String ouputModifiedBitmap(Bitmap bitmap, Uri uri) throws IOException {
         // Create an ExifHelper to save the exif data that is lost during compression
         String modifiedPath = getTempDirectoryPath() + "/modified.jpg";
 
@@ -392,7 +466,7 @@ public class CameraLauncher extends CordovaPlugin implements MediaScannerConnect
         return modifiedPath;
     }
 
-    /**
+/**
      * Applies all needed transformation to the image received from the gallery.
      *
      * @param destType          In which form should we return the image
@@ -400,6 +474,14 @@ public class CameraLauncher extends CordovaPlugin implements MediaScannerConnect
      */
     private void processResultFromGallery(int destType, Intent intent) {
         Uri uri = intent.getData();
+        if (uri == null) {
+            if (croppedUri != null) {
+                uri = croppedUri;
+            } else {
+                this.failPicture("null data from photo library");
+                return;
+            }
+        }
         int rotate = 0;
 
         // If you ask for video or all media type you will automatically get back a file URI
@@ -495,7 +577,50 @@ public class CameraLauncher extends CordovaPlugin implements MediaScannerConnect
         // Get src and dest types from request code
         int srcType = (requestCode / 16) - 1;
         int destType = (requestCode % 16) - 1;
+        // if camera crop
+    if (requestCode == CROP_CAMERA) {
+      if (resultCode == Activity.RESULT_OK) {
+        // // get the returned data
+        Bundle extras = intent.getExtras();
+        // get the cropped bitmap
+        Bitmap thePic = extras.getParcelable("data");
+                                if (thePic == null) {
+                                    this.failPicture("Crop returned no data.");
+                                    return;
+                                }
 
+        // now save the bitmap to a file
+        OutputStream fOut = null;
+        File temp_file = new File(getTempDirectoryPath(),
+            System.currentTimeMillis() + ".jpg");
+        try {
+          temp_file.createNewFile();
+          fOut = new FileOutputStream(temp_file);
+          thePic.compress(Bitmap.CompressFormat.JPEG, this.mQuality,
+              fOut);
+          fOut.flush();
+          fOut.close();
+        } catch (FileNotFoundException e) {
+          e.printStackTrace();
+        } catch (IOException e) {
+          e.printStackTrace();
+        }
+
+        // // Send Uri back to JavaScript for viewing image
+        this.callbackContext
+            .success(Uri.fromFile(temp_file).toString());
+
+      }// If cancelled
+      else if (resultCode == Activity.RESULT_CANCELED) {
+        this.failPicture("Camera cancelled.");
+      }
+
+      // If something else
+      else {
+        this.failPicture("Did not complete!");
+      }
+
+    }
         // If CAMERA
         if (srcType == CAMERA) {
             // If image available
@@ -521,7 +646,7 @@ public class CameraLauncher extends CordovaPlugin implements MediaScannerConnect
 
         // If retrieving photo from library
         else if ((srcType == PHOTOLIBRARY) || (srcType == SAVEDPHOTOALBUM)) {
-            if (resultCode == Activity.RESULT_OK) {
+            if (resultCode == Activity.RESULT_OK && intent != null) {
                 this.processResultFromGallery(destType, intent);
             }
             else if (resultCode == Activity.RESULT_CANCELED) {
@@ -615,11 +740,11 @@ public class CameraLauncher extends CordovaPlugin implements MediaScannerConnect
         Uri uri;
         try {
             uri = this.cordova.getActivity().getContentResolver().insert(android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);
-        } catch (UnsupportedOperationException e) {
+        } catch (RuntimeException e) {
             LOG.d(LOG_TAG, "Can't write to external media storage.");
             try {
                 uri = this.cordova.getActivity().getContentResolver().insert(android.provider.MediaStore.Images.Media.INTERNAL_CONTENT_URI, values);
-            } catch (UnsupportedOperationException ex) {
+            } catch (RuntimeException ex) {
                 LOG.d(LOG_TAG, "Can't write to internal media storage.");
                 return null;
             }

src/blackberry10/index.js

@@ -27,7 +27,98 @@ var PictureSourceType = {
         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] === 'org.apache.cordova.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
@@ -112,7 +203,11 @@ module.exports = {
 
         switch(sourceType) {
         case PictureSourceType.CAMERA:
-            window.qnx.webplatform.getApplication().cards.camera.open("photo", done, cancel, invoked);
+            if (invokeAvailable) {
+                window.qnx.webplatform.getApplication().cards.camera.open("photo", done, cancel, invoked);
+            } else {
+                showCameraDialog(done, cancel, fail);
+            }
             break;
 
         case PictureSourceType.PHOTOLIBRARY:

src/browser/CameraProxy.js

@@ -0,0 +1,102 @@
+/*
+ *
+ * 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) {
+    if (opts && opts[2] === 1) {
+        capture(success, error);
+    } else {
+        var input = document.createElement('input');
+        input.type = 'file';
+        input.name = 'files[]';
+
+        input.onchange = function(inputEvent) {
+            var canvas = document.createElement('canvas');
+
+            var reader = new FileReader();
+            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]);
+        };
+
+        document.body.appendChild(input);
+    }
+}
+
+function capture(success, errorCallback) {
+    var localMediaStream;
+
+    var video = document.createElement('video');
+    var button = document.createElement('button');
+
+    video.width = 320;
+    video.height = 240;
+    button.innerHTML = 'Capture!';
+
+    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);
+        
+        // convert image stored in canvas to base64 encoded image
+        var imageData = canvas.toDataURL('img/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);
+
+        return success(imageData);
+    }
+
+    navigator.getUserMedia = navigator.getUserMedia ||
+                             navigator.webkitGetUserMedia ||
+                             navigator.mozGetUserMedia ||
+                             navigator.msGetUserMedia;
+
+    var successCallback = function(stream) {
+        localMediaStream = stream;
+        video.src = window.URL.createObjectURL(localMediaStream);
+        video.play();
+
+        document.body.appendChild(video);
+        document.body.appendChild(button);
+    }
+
+    if (navigator.getUserMedia) {
+        navigator.getUserMedia({video: true, audio: true}, successCallback, errorCallback);
+    } else {
+        alert('Browser does not support camera :(');
+    }
+}
+
+module.exports = {
+    takePicture: takePicture,
+    cleanup: function(){}
+};
+
+require("cordova/exec/proxy").add("Camera",module.exports);

src/firefoxos/CameraProxy.js

@@ -48,4 +48,4 @@ module.exports = {
     cleanup: function(){}
 };
 
-require("cordova/firefoxos/commandProxy").add("Camera", module.exports);
+require("cordova/exec/proxy").add("Camera", module.exports);

src/ios/CDVCamera.h

@@ -55,8 +55,9 @@ typedef NSUInteger CDVMediaType;
 @property (assign) bool correctOrientation;
 @property (assign) bool saveToPhotoAlbum;
 @property (assign) bool cropToSize;
-@property (strong) UIWebView* webView;
+@property (strong) UIView* webView;
 @property (assign) BOOL popoverSupported;
+@property (assign) BOOL usesGeolocation;
 
 @end
 
@@ -84,7 +85,6 @@ typedef NSUInteger CDVMediaType;
  *	quality: integer between 1 and 100
  */
 - (void)takePicture:(CDVInvokedUrlCommand*)command;
-- (void)postImage:(UIImage*)anImage withFilename:(NSString*)filename toUrl:(NSURL*)url;
 - (void)cleanup:(CDVInvokedUrlCommand*)command;
 - (void)repositionPopover:(CDVInvokedUrlCommand*)command;
 

src/ios/CDVCamera.m

@@ -24,6 +24,7 @@
 #import <Cordova/NSDictionary+Extensions.h>
 #import <ImageIO/CGImageProperties.h>
 #import <AssetsLibrary/ALAssetRepresentation.h>
+#import <AssetsLibrary/AssetsLibrary.h>
 #import <ImageIO/CGImageSource.h>
 #import <ImageIO/CGImageProperties.h>
 #import <ImageIO/CGImageDestination.h>
@@ -48,6 +49,13 @@ static NSSet* org_apache_cordova_validArrowDirections;
 
 @synthesize hasPendingOperation, pickerController, locationManager;
 
+
+- (BOOL)usesGeolocation
+{
+    id useGeo = [self.commandDelegate.settings objectForKey:[@"CameraUsesGeolocation" lowercaseString]];
+    return [(NSNumber*)useGeo boolValue];
+}
+
 - (BOOL)popoverSupported
 {
     return (NSClassFromString(@"UIPopoverController") != nil) &&
@@ -74,7 +82,7 @@ static NSSet* org_apache_cordova_validArrowDirections;
     NSString* callbackId = command.callbackId;
     NSArray* arguments = command.arguments;
 
-    self.hasPendingOperation = NO;
+    self.hasPendingOperation = YES;
 
     NSString* sourceTypeString = [arguments objectAtIndex:2];
     UIImagePickerControllerSourceType sourceType = UIImagePickerControllerSourceTypeCamera; // default
@@ -120,6 +128,7 @@ static NSSet* org_apache_cordova_validArrowDirections;
     // we need to capture this state for memory warnings that dealloc this object
     cameraPicker.webView = self.webView;
     cameraPicker.popoverSupported = [self popoverSupported];
+    cameraPicker.usesGeolocation = [self usesGeolocation];
 
     cameraPicker.correctOrientation = [[arguments objectAtIndex:8] boolValue];
     cameraPicker.saveToPhotoAlbum = [[arguments objectAtIndex:9] boolValue];
@@ -150,15 +159,9 @@ static NSSet* org_apache_cordova_validArrowDirections;
         NSDictionary* options = [command.arguments objectAtIndex:10 withDefault:nil];
         [self displayPopover:options];
     } else {
-        SEL selector = NSSelectorFromString(@"presentViewController:animated:completion:");
-        if ([self.viewController respondsToSelector:selector]) {
-            [self.viewController presentViewController:cameraPicker animated:YES completion:nil];
-        } else {
-            // deprecated as of iOS >= 6.0
-            [self.viewController presentModalViewController:cameraPicker animated:YES];
-        }
+        [self.viewController presentViewController:cameraPicker animated:YES completion:nil];
     }
-    self.hasPendingOperation = YES;
+    self.hasPendingOperation = NO;
 }
 
 - (void)repositionPopover:(CDVInvokedUrlCommand*)command
@@ -265,11 +268,7 @@ static NSSet* org_apache_cordova_validArrowDirections;
         cameraPicker.popoverController.delegate = nil;
         cameraPicker.popoverController = nil;
     } else {
-        if ([cameraPicker respondsToSelector:@selector(presentingViewController)]) {
-            [[cameraPicker presentingViewController] dismissModalViewControllerAnimated:YES];
-        } else {
-            [[cameraPicker parentViewController] dismissModalViewControllerAnimated:YES];
-        }
+        [[cameraPicker presentingViewController] dismissViewControllerAnimated:YES completion:nil];
     }
 
     CDVPluginResult* result = nil;
@@ -315,17 +314,22 @@ static NSSet* org_apache_cordova_validArrowDirections;
                 data = UIImageJPEGRepresentation(returnedImage, 1.0);
             } else {
                 data = UIImageJPEGRepresentation(returnedImage, cameraPicker.quality / 100.0f);
-
-                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];
-                    
-                    [[self locationManager] startUpdatingLocation];
-                    return;
+                
+                if (cameraPicker.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];
+                        return;
+                    }
                 }
             }
             
@@ -385,14 +389,15 @@ static NSSet* org_apache_cordova_validArrowDirections;
 {
     CDVCameraPicker* cameraPicker = (CDVCameraPicker*)picker;
 
-    if ([cameraPicker respondsToSelector:@selector(presentingViewController)]) {
-        [[cameraPicker presentingViewController] dismissModalViewControllerAnimated:YES];
-    } else {
-        [[cameraPicker parentViewController] dismissModalViewControllerAnimated:YES];
-    }
-    // popoverControllerDidDismissPopover:(id)popoverController is called if popover is cancelled
+    [[cameraPicker presentingViewController] dismissViewControllerAnimated:YES completion:nil];
 
-    CDVPluginResult* result = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:@"no image selected"];   // error callback expects string ATM
+    CDVPluginResult* result;
+    if ([ALAssetsLibrary authorizationStatus] == ALAuthorizationStatusAuthorized) {
+        result = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:@"no image selected"];   // error callback expects string ATM
+    } else {
+        result = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:@"has no access to assets"];   // error callback expects string ATM
+    }
+    
     [self.commandDelegate sendPluginResult:result callbackId:cameraPicker.callbackId];
 
     self.hasPendingOperation = NO;
@@ -527,6 +532,10 @@ static NSSet* org_apache_cordova_validArrowDirections;
         scaledSize = CGSizeMake(MIN(width * scaleFactor, targetWidth), MIN(height * scaleFactor, targetHeight));
     }
 
+    // If the pixels are floats, it causes a white line in iOS8 and probably other versions too
+    scaledSize.width = (int)scaledSize.width;
+    scaledSize.height = (int)scaledSize.height;
+    
     UIGraphicsBeginImageContext(scaledSize); // this will resize
 
     [sourceImage drawInRect:CGRectMake(0, 0, scaledSize.width, scaledSize.height)];
@@ -541,48 +550,6 @@ static NSSet* org_apache_cordova_validArrowDirections;
     return newImage;
 }
 
-- (void)postImage:(UIImage*)anImage withFilename:(NSString*)filename toUrl:(NSURL*)url
-{
-    self.hasPendingOperation = YES;
-
-    NSString* boundary = @"----BOUNDARY_IS_I";
-
-    NSMutableURLRequest* req = [NSMutableURLRequest requestWithURL:url];
-    [req setHTTPMethod:@"POST"];
-
-    NSString* contentType = [NSString stringWithFormat:@"multipart/form-data; boundary=%@", boundary];
-    [req setValue:contentType forHTTPHeaderField:@"Content-type"];
-
-    NSData* imageData = UIImagePNGRepresentation(anImage);
-
-    // adding the body
-    NSMutableData* postBody = [NSMutableData data];
-
-    // first parameter an image
-    [postBody appendData:[[NSString stringWithFormat:@"\r\n--%@\r\n", boundary] dataUsingEncoding:NSUTF8StringEncoding]];
-    [postBody appendData:[[NSString stringWithFormat:@"Content-Disposition: form-data; name=\"upload\"; filename=\"%@\"\r\n", filename] dataUsingEncoding:NSUTF8StringEncoding]];
-    [postBody appendData:[@"Content-Type: image/png\r\n\r\n" dataUsingEncoding : NSUTF8StringEncoding]];
-    [postBody appendData:imageData];
-
-    //	// second parameter information
-    //	[postBody appendData:[[NSString stringWithFormat:@"\r\n--%@\r\n", boundary] dataUsingEncoding:NSUTF8StringEncoding]];
-    //	[postBody appendData:[@"Content-Disposition: form-data; name=\"some_other_name\"\r\n\r\n" dataUsingEncoding:NSUTF8StringEncoding]];
-    //	[postBody appendData:[@"some_other_value" dataUsingEncoding:NSUTF8StringEncoding]];
-    //	[postBody appendData:[[NSString stringWithFormat:@"\r\n--%@--\r \n",boundary] dataUsingEncoding:NSUTF8StringEncoding]];
-
-    [req setHTTPBody:postBody];
-
-    NSURLResponse* response;
-    NSError* error;
-    [NSURLConnection sendSynchronousRequest:req returningResponse:&response error:&error];
-
-    //  NSData* result = [NSURLConnection sendSynchronousRequest:req returningResponse:&response error:&error];
-    //	NSString * resultStr =  [[[NSString alloc] initWithData:result encoding:NSUTF8StringEncoding] autorelease];
-
-    self.hasPendingOperation = NO;
-}
-
-
 - (CLLocationManager *)locationManager {
     
 	if (locationManager != nil) {

src/ubuntu/CaptureWidget.qml

@@ -40,7 +40,6 @@ Rectangle {
             console.log(errorString);
         }
         videoRecorder.audioBitRate: 128000
-        videoRecorder.mediaContainer: "mp4"
         imageCapture {
             onImageSaved: {
                 root.exec("Camera", "onImageSaved", [path]);
@@ -100,7 +99,7 @@ Rectangle {
                 MouseArea {
                     anchors.fill: parent
                     onClicked: {
-                        camera.imageCapture.capture();
+                        camera.imageCapture.captureToLocation(ui.parent.plugin('Camera').generateLocation("jpg"));
                     }
                 }
             }

src/ubuntu/camera.cpp

@@ -38,7 +38,7 @@ function createObject() {                                               \
         component.statusChanged.connect(finishCreation);                \
 }                                                                       \
 function finishCreation() {                                             \
-    CordovaWrapper.object = component.createObject(root,                \
+    CordovaWrapper.global.cameraPluginWidget = component.createObject(root, \
         {root: root, cordova: cordova});                                \
 }                                                                       \
 createObject()";
@@ -68,18 +68,15 @@ bool Camera::preprocessImage(QString &path) {
 
     const char *type;
     if (convertToPNG) {
-        newImage.setFileTemplate("imgXXXXXX.png");
+        path = generateLocation("png");
         type = "png";
     } else {
-        newImage.setFileTemplate("imgXXXXXX.jpg");
+        path = generateLocation("jpg");
         type = "jpg";
     }
 
-    newImage.open();
-    newImage.setAutoRemove(false);
-    image.save(newImage.fileName(), type, quality);
+    image.save(path, type, quality);
 
-    path = newImage.fileName();
     oldImage.remove();
 
     return true;
@@ -98,7 +95,7 @@ void Camera::onImageSaved(QString path) {
             cbParams = QString("\"%1\"").arg(content.data());
             image.remove();
         } else {
-            cbParams = CordovaInternal::format(QUrl::fromLocalFile(absolutePath).toString());
+            cbParams = CordovaInternal::format(QString("file://localhost") + absolutePath);
         }
     }
 
@@ -136,7 +133,7 @@ void Camera::takePicture(int scId, int ecId, int quality, int destinationType, i
 }
 
 void Camera::cancel() {
-    m_cordova->execQML("CordovaWrapper.object.destroy()");
+    m_cordova->execQML("CordovaWrapper.global.cameraPluginWidget.destroy()");
     this->cb(_lastEcId, "canceled");
 
     _lastEcId = _lastScId = 0;

src/ubuntu/camera.h

@@ -54,6 +54,16 @@ public slots:
 
     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);
 

src/windows/CameraProxy.js

@@ -0,0 +1,441 @@
+/*
+ *
+ * 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.
+ *
+*/
+
+/*global Windows:true, URL:true */
+
+
+    var cordova = require('cordova'),
+        Camera = require('./Camera');
+
+module.exports = {
+
+    // args will contain :
+    //  ...  it is an array, so be careful
+    // 0 quality:50,
+    // 1 destinationType:Camera.DestinationType.FILE_URI,
+    // 2 sourceType:Camera.PictureSourceType.CAMERA,
+    // 3 targetWidth:-1,
+    // 4 targetHeight:-1,
+    // 5 encodingType:Camera.EncodingType.JPEG,
+    // 6 mediaType:Camera.MediaType.PICTURE,
+    // 7 allowEdit:false,
+    // 8 correctOrientation:false,
+    // 9 saveToPhotoAlbum:false,
+    // 10 popoverOptions:null
+    // 11 cameraDirection:0
+
+    takePicture: function (successCallback, errorCallback, args) {
+        var encodingType = args[5];
+        var targetWidth = args[3];
+        var targetHeight = args[4];
+        var sourceType = args[2];
+        var destinationType = args[1];
+        var mediaType = args[6];
+        var allowCrop = !!args[7];
+        var saveToPhotoAlbum = args[9];
+        var cameraDirection = args[11];
+
+        // resize method :)
+        var resizeImage = function (file) {
+            var tempPhotoFileName = "";
+            if (encodingType == Camera.EncodingType.PNG) {
+                tempPhotoFileName = "camera_cordova_temp_return.png";
+            } else {
+                tempPhotoFileName = "camera_cordova_temp_return.jpg";
+            }
+
+            var storageFolder = Windows.Storage.ApplicationData.current.localFolder;
+            file.copyAsync(storageFolder, file.name, Windows.Storage.NameCollisionOption.replaceExisting).then(function (storageFile) {
+                Windows.Storage.FileIO.readBufferAsync(storageFile).then(function(buffer) {
+                    var strBase64 = Windows.Security.Cryptography.CryptographicBuffer.encodeToBase64String(buffer);
+                    var imageData = "data:" + file.contentType + ";base64," + strBase64;
+                    var image = new Image();
+                    image.src = imageData;
+                    image.onload = function() {
+                        var imageWidth = targetWidth,
+                            imageHeight = targetHeight;
+                        var canvas = document.createElement('canvas');
+
+                        canvas.width = imageWidth;
+                        canvas.height = imageHeight;
+
+                        canvas.getContext("2d").drawImage(this, 0, 0, imageWidth, imageHeight);
+
+                        var fileContent = canvas.toDataURL(file.contentType).split(',')[1];
+
+                        var storageFolder = Windows.Storage.ApplicationData.current.localFolder;
+
+                        storageFolder.createFileAsync(tempPhotoFileName, Windows.Storage.CreationCollisionOption.generateUniqueName).done(function (storagefile) {
+                            var content = Windows.Security.Cryptography.CryptographicBuffer.decodeFromBase64String(fileContent);
+                            Windows.Storage.FileIO.writeBufferAsync(storagefile, content).then(function () {
+                                successCallback("ms-appdata:///local/" + storagefile.name);
+                            }, function () {
+                                errorCallback("Resize picture error.");
+                            });
+                        });
+                    };
+                });
+            }, function () {
+                errorCallback("Can't access localStorage folder");
+            });
+
+        };
+
+        // because of asynchronous method, so let the successCallback be called in it.
+        var resizeImageBase64 = function (file) {
+
+            Windows.Storage.FileIO.readBufferAsync(file).done( function(buffer) {
+                var strBase64 = Windows.Security.Cryptography.CryptographicBuffer.encodeToBase64String(buffer);
+                var imageData = "data:" + file.contentType + ";base64," + strBase64;
+
+                var image = new Image();
+                image.src = imageData;
+
+                image.onload = function() {
+                    var imageWidth = targetWidth,
+                        imageHeight = targetHeight;
+                    var canvas = document.createElement('canvas');
+
+                    canvas.width = imageWidth;
+                    canvas.height = imageHeight;
+
+                    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 newStr = finalFile.substr(arr[0].length + 1);
+                    successCallback(newStr);
+                };
+            });
+        };
+
+        if (sourceType != Camera.PictureSourceType.CAMERA) {
+
+            // TODO: Add WP8.1 support
+            // WP8.1 doesn't allow to use of pickSingleFileAsync method
+            // see http://msdn.microsoft.com/en-us/library/windows/apps/br207852.aspx for details
+            // replacement of pickSingleFileAsync - pickSingleFileAndContinue method
+            // will take application to suspended state and this require additional logic to wake application up
+            if (navigator.appVersion.indexOf('Windows Phone 8.1') >= 0 ) {
+                errorCallback('Not supported');
+                return;
+            }
+
+            var fileOpenPicker = new Windows.Storage.Pickers.FileOpenPicker();
+            fileOpenPicker.suggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.picturesLibrary;
+            if (mediaType == Camera.MediaType.PICTURE) {
+                fileOpenPicker.fileTypeFilter.replaceAll([".png", ".jpg", ".jpeg"]);
+            }
+            else if (mediaType == Camera.MediaType.VIDEO) {
+                fileOpenPicker.fileTypeFilter.replaceAll([".avi", ".flv", ".asx", ".asf", ".mov", ".mp4", ".mpg", ".rm", ".srt", ".swf", ".wmv", ".vob"]);
+            }
+            else {
+                fileOpenPicker.fileTypeFilter.replaceAll(["*"]);
+            }
+
+            fileOpenPicker.pickSingleFileAsync().done(function (file) {
+                if (file) {
+                    if (destinationType == Camera.DestinationType.FILE_URI || destinationType == Camera.DestinationType.NATIVE_URI) {
+                        if (targetHeight > 0 && targetWidth > 0) {
+                            resizeImage(file);
+                        }
+                        else {
+
+                            var storageFolder = Windows.Storage.ApplicationData.current.localFolder;
+                            file.copyAsync(storageFolder, file.name, Windows.Storage.NameCollisionOption.replaceExisting).then(function (storageFile) {
+                                successCallback(URL.createObjectURL(storageFile));
+                            }, function () {
+                                errorCallback("Can't access localStorage folder.");
+                            });
+
+                        }
+                    }
+                    else {
+                        if (targetHeight > 0 && targetWidth > 0) {
+                            resizeImageBase64(file);
+                        } else {
+                            Windows.Storage.FileIO.readBufferAsync(file).done(function (buffer) {
+                                var strBase64 = Windows.Security.Cryptography.CryptographicBuffer.encodeToBase64String(buffer);
+                                successCallback(strBase64);
+                            });
+                        }
+
+                    }
+
+                } else {
+                    errorCallback("User didn't choose a file.");
+                }
+            }, function () {
+                errorCallback("User didn't choose a file.");
+            });
+
+        } else {
+
+            var CaptureNS = Windows.Media.Capture;
+
+            // Check if necessary API available
+            if (!CaptureNS.CameraCaptureUI) {
+                // 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 capturePreview = null,
+                    captureCancelButton = null,
+                    capture = null,
+                    captureSettings = null;
+
+                var createCameraUI = function () {
+
+                    // Create fullscreen preview
+                    capturePreview = document.createElement("video");
+
+                    // z-order style element for capturePreview and captureCancelButton 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-order: 999";
+
+                    // Create cancel button
+                    captureCancelButton = document.createElement("button");
+                    captureCancelButton.innerText = "Cancel";
+                    captureCancelButton.style.cssText = "position: fixed; right: 0; bottom: 0; display: block; margin: 20px; z-order: 1000";
+
+                    capture = new CaptureNS.MediaCapture();
+
+                    captureSettings = new CaptureNS.MediaCaptureInitializationSettings();
+                    captureSettings.streamingCaptureMode = CaptureNS.StreamingCaptureMode.video;
+                };
+
+                var startCameraPreview = function () {
+
+                    // Search for available camera devices
+                    // This is necessary to detect which camera (front or back) we should use
+                    var expectedPanel = cameraDirection === 1 ? Windows.Devices.Enumeration.Panel.front : Windows.Devices.Enumeration.Panel.back;
+                    Windows.Devices.Enumeration.DeviceInformation.findAllAsync(Windows.Devices.Enumeration.DeviceClass.videoCapture)
+                    .done(function (devices) {
+                        if (devices.length > 0) {
+                            devices.forEach(function(currDev) {
+                                if (currDev.enclosureLocation.panel && currDev.enclosureLocation.panel == expectedPanel) {
+                                    captureSettings.videoDeviceId = currDev.id;
+                                }
+                            });
+
+                            capture.initializeAsync(captureSettings).done(function () {
+                                // This is necessary since WP8.1 MediaCapture outputs video stream rotated 90 degrees CCW
+                                // TODO: This can be not consistent across devices, need additional testing on various devices
+                                capture.setPreviewRotation(Windows.Media.Capture.VideoRotation.clockwise90Degrees);
+                                // msdn.microsoft.com/en-us/library/windows/apps/hh452807.aspx
+                                capturePreview.msZoom = true;
+                                capturePreview.src = URL.createObjectURL(capture);
+                                capturePreview.play();
+
+                                // Insert preview frame and controls into page
+                                document.body.appendChild(capturePreview);
+                                document.body.appendChild(captureCancelButton);
+
+                                // Bind events to controls
+                                capturePreview.addEventListener('click', captureAction);
+                                captureCancelButton.addEventListener('click', function () {
+                                    destroyCameraPreview();
+                                    errorCallback('Cancelled');
+                                }, false);
+                            }, function (err) {
+                                destroyCameraPreview();
+                                errorCallback('Camera intitialization error ' + err);
+                            });
+                        } else {
+                            destroyCameraPreview();
+                            errorCallback('Camera not found');
+                        }
+                    });
+                };
+
+                var destroyCameraPreview = function () {
+                    capturePreview.pause();
+                    capturePreview.src = null;
+                    [capturePreview, captureCancelButton].forEach(function(elem) {
+                        if (elem /* && elem in document.body.childNodes */) {
+                            document.body.removeChild(elem);
+                        }
+                    });
+                    if (capture) {
+                        capture.stopRecordAsync();
+                        capture = null;
+                    }
+                };
+
+                var captureAction = function () {
+
+                    var encodingProperties,
+                        fileName,
+                        generateUniqueCollisionOption = Windows.Storage.CreationCollisionOption.generateUniqueName,
+                        tempFolder = Windows.Storage.ApplicationData.current.temporaryFolder;
+
+                    if (encodingType == Camera.EncodingType.PNG) {
+                        fileName = 'photo.png';
+                        encodingProperties = Windows.Media.MediaProperties.ImageEncodingProperties.createPng();
+                    } else {
+                        fileName = 'photo.jpg';
+                        encodingProperties = Windows.Media.MediaProperties.ImageEncodingProperties.createJpeg();
+                    }
+
+                    tempFolder.createFileAsync(fileName, generateUniqueCollisionOption).done(function(capturedFile) {
+                        capture.capturePhotoToStorageFileAsync(encodingProperties, capturedFile).done(function() {
+
+                            destroyCameraPreview();
+
+                            // success callback for capture operation
+                            var success = function(capturedfile) {
+                                if (destinationType == Camera.DestinationType.FILE_URI || destinationType == Camera.DestinationType.NATIVE_URI) {
+                                    if (targetHeight > 0 && targetWidth > 0) {
+                                        resizeImage(capturedfile);
+                                    } else {
+                                        capturedfile.copyAsync(Windows.Storage.ApplicationData.current.localFolder, capturedfile.name, generateUniqueCollisionOption).done(function(copiedfile) {
+                                            successCallback("ms-appdata:///local/" + copiedfile.name);
+                                        }, errorCallback);
+                                    }
+                                } else {
+                                    if (targetHeight > 0 && targetWidth > 0) {
+                                        resizeImageBase64(capturedfile);
+                                    } else {
+                                        Windows.Storage.FileIO.readBufferAsync(capturedfile).done(function(buffer) {
+                                            var strBase64 = Windows.Security.Cryptography.CryptographicBuffer.encodeToBase64String(buffer);
+                                            capturedfile.deleteAsync().done(function() {
+                                                successCallback(strBase64);
+                                            }, function(err) {
+                                                console.error(err);
+                                                successCallback(strBase64);
+                                            });
+                                        }, errorCallback);
+                                    }
+                                }
+                            };
+
+                            if (saveToPhotoAlbum) {
+                                capturedFile.copyAsync(Windows.Storage.KnownFolders.picturesLibrary, capturedFile.name, generateUniqueCollisionOption)
+                                .done(function() {
+                                    success(capturedFile);
+                                }, errorCallback);
+                            } else {
+                                success(capturedFile);
+                            }
+
+
+                        }, function(err) {
+                            destroyCameraPreview();
+                            errorCallback(err);
+                        });
+                    }, function(err) {
+                        destroyCameraPreview();
+                        errorCallback(err);
+                    });
+                };
+
+                try {
+                    createCameraUI();
+                    startCameraPreview();
+                } catch (ex) {
+                    errorCallback(ex);
+                }
+
+            } else {
+
+                var cameraCaptureUI = new Windows.Media.Capture.CameraCaptureUI();
+                cameraCaptureUI.photoSettings.allowCropping = allowCrop;
+
+                if (encodingType == Camera.EncodingType.PNG) {
+                    cameraCaptureUI.photoSettings.format = Windows.Media.Capture.CameraCaptureUIPhotoFormat.png;
+                } else {
+                    cameraCaptureUI.photoSettings.format = Windows.Media.Capture.CameraCaptureUIPhotoFormat.jpeg;
+                }
+
+                // decide which max pixels should be supported by targetWidth or targetHeight.
+                if (targetWidth >= 1280 || targetHeight >= 960) {
+                    cameraCaptureUI.photoSettings.maxResolution = Windows.Media.Capture.CameraCaptureUIMaxPhotoResolution.large3M;
+                } else if (targetWidth >= 1024 || targetHeight >= 768) {
+                    cameraCaptureUI.photoSettings.maxResolution = Windows.Media.Capture.CameraCaptureUIMaxPhotoResolution.mediumXga;
+                } else if (targetWidth >= 800 || targetHeight >= 600) {
+                    cameraCaptureUI.photoSettings.maxResolution = Windows.Media.Capture.CameraCaptureUIMaxPhotoResolution.mediumXga;
+                } else if (targetWidth >= 640 || targetHeight >= 480) {
+                    cameraCaptureUI.photoSettings.maxResolution = Windows.Media.Capture.CameraCaptureUIMaxPhotoResolution.smallVga;
+                } else if (targetWidth >= 320 || targetHeight >= 240) {
+                    cameraCaptureUI.photoSettings.maxResolution = Windows.Media.Capture.CameraCaptureUIMaxPhotoResolution.verySmallQvga;
+                } else {
+                    cameraCaptureUI.photoSettings.maxResolution = Windows.Media.Capture.CameraCaptureUIMaxPhotoResolution.highestAvailable;
+                }
+
+                cameraCaptureUI.captureFileAsync(Windows.Media.Capture.CameraCaptureUIMode.photo).then(function(picture) {
+                    if (picture) {
+                        // save to photo album successCallback
+                        var success = function() {
+                            if (destinationType == Camera.DestinationType.FILE_URI) {
+                                if (targetHeight > 0 && targetWidth > 0) {
+                                    resizeImage(picture);
+                                } else {
+
+                                    var storageFolder = Windows.Storage.ApplicationData.current.localFolder;
+                                    picture.copyAsync(storageFolder, picture.name, Windows.Storage.NameCollisionOption.replaceExisting).then(function(storageFile) {
+                                        successCallback("ms-appdata:///local/" + storageFile.name);
+                                    }, function() {
+                                        errorCallback("Can't access localStorage folder.");
+                                    });
+                                }
+                            } else {
+                                if (targetHeight > 0 && targetWidth > 0) {
+                                    resizeImageBase64(picture);
+                                } else {
+                                    Windows.Storage.FileIO.readBufferAsync(picture).done(function(buffer) {
+                                        var strBase64 = Windows.Security.Cryptography.CryptographicBuffer.encodeToBase64String(buffer);
+                                        successCallback(strBase64);
+                                    });
+                                }
+                            }
+                        };
+                        // save to photo album errorCallback
+                        var fail = function() {
+                            //errorCallback("FileError, code:" + fileError.code);
+                            errorCallback("Save fail.");
+                        };
+
+                        if (saveToPhotoAlbum) {
+                            Windows.Storage.StorageFile.getFileFromPathAsync(picture.path).then(function(storageFile) {
+                                storageFile.copyAsync(Windows.Storage.KnownFolders.picturesLibrary, picture.name, Windows.Storage.NameCollisionOption.generateUniqueName).then(function(storageFile) {
+                                    success();
+                                }, function() {
+                                    fail();
+                                });
+                            });
+                        } else {
+                            success();
+                        }
+                    } else {
+                        errorCallback("User didn't capture a photo.");
+                    }
+                }, function() {
+                    errorCallback("Fail to capture a photo.");
+                });
+            }
+        }
+    }
+};
+
+require("cordova/exec/proxy").add("Camera",module.exports);

src/windows8/CameraProxy.js

@@ -1,354 +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.
- *
-*/
-
-/*global Windows:true, URL:true */
-
-
-
-var cordova = require('cordova'),
-    Camera = require('./Camera'),
-    FileEntry = require('org.apache.cordova.file.FileEntry'),
-    FileError = require('org.apache.cordova.file.FileError'),
-    FileReader = require('org.apache.cordova.file.FileReader');
-
-module.exports = {
-
-    // args will contain :
-    //  ...  it is an array, so be careful
-    // 0 quality:50,
-    // 1 destinationType:Camera.DestinationType.FILE_URI,
-    // 2 sourceType:Camera.PictureSourceType.CAMERA,
-    // 3 targetWidth:-1,
-    // 4 targetHeight:-1,
-    // 5 encodingType:Camera.EncodingType.JPEG,
-    // 6 mediaType:Camera.MediaType.PICTURE,
-    // 7 allowEdit:false,
-    // 8 correctOrientation:false,
-    // 9 saveToPhotoAlbum:false,
-    // 10 popoverOptions:null
-
-    takePicture: function (successCallback, errorCallback, args) {
-        var encodingType = args[5];
-        var targetWidth = args[3];
-        var targetHeight = args[4];
-        var sourceType = args[2];
-        var destinationType = args[1];
-        var mediaType = args[6];
-        var saveToPhotoAlbum = args[9];
-
-        var pkg = Windows.ApplicationModel.Package.current;
-        var packageId = pkg.installedLocation;
-
-        var fail = function (fileError) {
-            errorCallback("FileError, code:" + fileError.code);
-        };
-
-        // resize method :)
-        var resizeImage = function (file) {
-            var tempPhotoFileName = "";
-            if (encodingType == Camera.EncodingType.PNG) {
-                tempPhotoFileName = "camera_cordova_temp_return.png";
-            } else {
-                tempPhotoFileName = "camera_cordova_temp_return.jpg";
-            }
-            var imgObj = new Image();
-            var success = function (fileEntry) {
-                var successCB = function (filePhoto) {
-                    var fileType = file.contentType,
-                        reader = new FileReader();
-                    reader.onloadend = function () {
-                        var image = new Image();
-                        image.src = reader.result;
-                        image.onload = function () {
-                            var imageWidth = targetWidth,
-                                imageHeight = targetHeight;
-                            var canvas = document.createElement('canvas');
-
-                            canvas.width = imageWidth;
-                            canvas.height = imageHeight;
-
-                            var ctx = canvas.getContext("2d");
-                            ctx.drawImage(this, 0, 0, imageWidth, imageHeight);
-
-                            // The resized file ready for upload
-                            var _blob = canvas.msToBlob();
-                            var _stream = _blob.msDetachStream();
-
-                            var storageFolder = Windows.Storage.ApplicationData.current.localFolder;
-                            storageFolder.createFileAsync(tempPhotoFileName, Windows.Storage.CreationCollisionOption.generateUniqueName).done(function (file) {
-                                file.openAsync(Windows.Storage.FileAccessMode.readWrite).done(function (fileStream) {
-                                    Windows.Storage.Streams.RandomAccessStream.copyAndCloseAsync(_stream, fileStream).done(function () {
-                                        var _imageUrl = URL.createObjectURL(file);
-                                        successCallback(_imageUrl);
-                                    }, function () {
-                                        errorCallback("Resize picture error.");
-                                    });
-                                }, function () {
-                                    errorCallback("Resize picture error.");
-                                });
-                            }, function () {
-                                errorCallback("Resize picture error.");
-                            });
-
-                        };
-                    };
-
-                    reader.readAsDataURL(filePhoto);
-                };
-
-                var failCB = function () {
-                    errorCallback("File not found.");
-                };
-                fileEntry.file(successCB, failCB);
-            };
-
-            var storageFolder = Windows.Storage.ApplicationData.current.localFolder;
-            file.copyAsync(storageFolder, file.name, Windows.Storage.NameCollisionOption.replaceExisting).then(function (storageFile) {
-                success(new FileEntry(storageFile.name, storageFile.path));
-            }, function () {
-                fail(FileError.INVALID_MODIFICATION_ERR);
-            }, function () {
-                errorCallback("Folder not access.");
-            });
-
-        };
-
-        // because of asynchronous method, so let the successCallback be called in it.
-        var resizeImageBase64 = function (file) {
-            var imgObj = new Image();
-            var success = function (fileEntry) {
-                var successCB = function (filePhoto) {
-                    var fileType = file.contentType,
-                        reader = new FileReader();
-                    reader.onloadend = function () {
-                        var image = new Image();
-                        image.src = reader.result;
-
-                        image.onload = function () {
-                            var imageWidth = targetWidth,
-                                imageHeight = targetHeight;
-                            var canvas = document.createElement('canvas');
-
-                            canvas.width = imageWidth;
-                            canvas.height = imageHeight;
-
-                            var ctx = canvas.getContext("2d");
-                            ctx.drawImage(this, 0, 0, imageWidth, imageHeight);
-
-                            // The resized file ready for upload
-                            var finalFile = canvas.toDataURL(fileType);
-
-                            // Remove the prefix such as "data:" + contentType + ";base64," , in order to meet the Cordova API.
-                            var arr = finalFile.split(",");
-                            var newStr = finalFile.substr(arr[0].length + 1);
-                            successCallback(newStr);
-                        };
-                    };
-
-                    reader.readAsDataURL(filePhoto);
-
-                };
-                var failCB = function () {
-                    errorCallback("File not found.");
-                };
-                fileEntry.file(successCB, failCB);
-            };
-
-            var storageFolder = Windows.Storage.ApplicationData.current.localFolder;
-            file.copyAsync(storageFolder, file.name, Windows.Storage.NameCollisionOption.replaceExisting).then(function (storageFile) {
-                success(new FileEntry(storageFile.name, "ms-appdata:///local/" + storageFile.name));
-            }, function () {
-                fail(FileError.INVALID_MODIFICATION_ERR);
-            }, function () {
-                errorCallback("Folder not access.");
-            });
-
-
-        };
-
-        if (sourceType != Camera.PictureSourceType.CAMERA) {
-            var fileOpenPicker = new Windows.Storage.Pickers.FileOpenPicker();
-            fileOpenPicker.suggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.picturesLibrary;
-            if (mediaType == Camera.MediaType.PICTURE) {
-                fileOpenPicker.fileTypeFilter.replaceAll([".png", ".jpg", ".jpeg"]);
-            }
-            else if (mediaType == Camera.MediaType.VIDEO) {
-                fileOpenPicker.fileTypeFilter.replaceAll([".avi", ".flv", ".asx", ".asf", ".mov", ".mp4", ".mpg", ".rm", ".srt", ".swf", ".wmv", ".vob"]);
-            }
-            else {
-                fileOpenPicker.fileTypeFilter.replaceAll(["*"]);
-            }
-
-            fileOpenPicker.pickSingleFileAsync().then(function (file) {
-                if (file) {
-                    if (destinationType == Camera.DestinationType.FILE_URI) {
-                        if (targetHeight > 0 && targetWidth > 0) {
-                            resizeImage(file);
-                        }
-                        else {
-
-                            var storageFolder = Windows.Storage.ApplicationData.current.localFolder;
-                            file.copyAsync(storageFolder, file.name, Windows.Storage.NameCollisionOption.replaceExisting).then(function (storageFile) {
-                                successCallback(URL.createObjectURL(storageFile));
-                            }, function () {
-                                fail(FileError.INVALID_MODIFICATION_ERR);
-                            }, function () {
-                                errorCallback("Folder not access.");
-                            });
-
-                        }
-                    }
-                    else {
-                        if (targetHeight > 0 && targetWidth > 0) {
-                            resizeImageBase64(file);
-                        } else {
-                            Windows.Storage.FileIO.readBufferAsync(file).done(function (buffer) {
-                                var strBase64 = Windows.Security.Cryptography.CryptographicBuffer.encodeToBase64String(buffer);
-                                successCallback(strBase64);
-                            });
-                        }
-
-                    }
-
-                } else {
-                    errorCallback("User didn't choose a file.");
-                }
-            }, function () {
-                errorCallback("User didn't choose a file.");
-            });
-        }
-        else {
-
-            var cameraCaptureUI = new Windows.Media.Capture.CameraCaptureUI();
-            cameraCaptureUI.photoSettings.allowCropping = true;
-            var allowCrop = !!args[7];
-            if (!allowCrop) {
-                cameraCaptureUI.photoSettings.allowCropping = false;
-            }
-
-            if (encodingType == Camera.EncodingType.PNG) {
-                cameraCaptureUI.photoSettings.format = Windows.Media.Capture.CameraCaptureUIPhotoFormat.png;
-            } else {
-                cameraCaptureUI.photoSettings.format = Windows.Media.Capture.CameraCaptureUIPhotoFormat.jpeg;
-            }
-
-            // decide which max pixels should be supported by targetWidth or targetHeight.
-            if (targetWidth >= 1280 || targetHeight >= 960) {
-                cameraCaptureUI.photoSettings.maxResolution = Windows.Media.Capture.CameraCaptureUIMaxPhotoResolution.large3M;
-            }
-            else if (targetWidth >= 1024 || targetHeight >= 768) {
-                cameraCaptureUI.photoSettings.maxResolution = Windows.Media.Capture.CameraCaptureUIMaxPhotoResolution.mediumXga;
-            }
-            else if (targetWidth >= 800 || targetHeight >= 600) {
-                cameraCaptureUI.photoSettings.maxResolution = Windows.Media.Capture.CameraCaptureUIMaxPhotoResolution.mediumXga;
-            }
-            else if (targetWidth >= 640 || targetHeight >= 480) {
-                cameraCaptureUI.photoSettings.maxResolution = Windows.Media.Capture.CameraCaptureUIMaxPhotoResolution.smallVga;
-            }
-            else if (targetWidth >= 320 || targetHeight >= 240) {
-                cameraCaptureUI.photoSettings.maxResolution = Windows.Media.Capture.CameraCaptureUIMaxPhotoResolution.verySmallQvga;
-            }
-            else {
-                cameraCaptureUI.photoSettings.maxResolution = Windows.Media.Capture.CameraCaptureUIMaxPhotoResolution.highestAvailable;
-            }
-
-            cameraCaptureUI.captureFileAsync(Windows.Media.Capture.CameraCaptureUIMode.photo).then(function (picture) {
-                if (picture) {
-                    // save to photo album successCallback
-                    var success = function (fileEntry) {
-                        if (destinationType == Camera.DestinationType.FILE_URI) {
-                            if (targetHeight > 0 && targetWidth > 0) {
-                                resizeImage(picture);
-                            } else {
-
-                                var storageFolder = Windows.Storage.ApplicationData.current.localFolder;
-                                picture.copyAsync(storageFolder, picture.name, Windows.Storage.NameCollisionOption.replaceExisting).then(function (storageFile) {
-                                    successCallback("ms-appdata:///local/" + storageFile.name);
-                                }, function () {
-                                    fail(FileError.INVALID_MODIFICATION_ERR);
-                                }, function () {
-                                    errorCallback("Folder not access.");
-                                });
-                            }
-                        } else {
-                            if (targetHeight > 0 && targetWidth > 0) {
-                                resizeImageBase64(picture);
-                            } else {
-                                Windows.Storage.FileIO.readBufferAsync(picture).done(function (buffer) {
-                                    var strBase64 = Windows.Security.Cryptography.CryptographicBuffer.encodeToBase64String(buffer);
-                                    successCallback(strBase64);
-                                });
-                            }
-                        }
-                    };
-                    // save to photo album errorCallback
-                    var fail = function () {
-                        //errorCallback("FileError, code:" + fileError.code);
-                        errorCallback("Save fail.");
-                    };
-
-                    if (saveToPhotoAlbum) {
-                        Windows.Storage.StorageFile.getFileFromPathAsync(picture.path).then(function (storageFile) {
-                            storageFile.copyAsync(Windows.Storage.KnownFolders.picturesLibrary, picture.name, Windows.Storage.NameCollisionOption.generateUniqueName).then(function (storageFile) {
-                                success(storageFile);
-                            }, function () {
-                                fail();
-                            });
-                        });
-                        //var directory = new DirectoryEntry("Pictures", parentPath);
-                        //new FileEntry(picture.name, picture.path).copyTo(directory, null, success, fail);
-                    } else {
-                        if (destinationType == Camera.DestinationType.FILE_URI) {
-                            if (targetHeight > 0 && targetWidth > 0) {
-                                resizeImage(picture);
-                            } else {
-
-                                var storageFolder = Windows.Storage.ApplicationData.current.localFolder;
-                                picture.copyAsync(storageFolder, picture.name, Windows.Storage.NameCollisionOption.replaceExisting).then(function (storageFile) {
-                                    successCallback("ms-appdata:///local/" + storageFile.name);
-                                }, function () {
-                                    fail(FileError.INVALID_MODIFICATION_ERR);
-                                }, function () {
-                                    errorCallback("Folder not access.");
-                                });
-                            }
-                        } else {
-                            if (targetHeight > 0 && targetWidth > 0) {
-                                resizeImageBase64(picture);
-                            } else {
-                                Windows.Storage.FileIO.readBufferAsync(picture).done(function (buffer) {
-                                    var strBase64 = Windows.Security.Cryptography.CryptographicBuffer.encodeToBase64String(buffer);
-                                    successCallback(strBase64);
-                                });
-                            }
-                        }
-                    }
-                } else {
-                    errorCallback("User didn't capture a photo.");
-                }
-            }, function () {
-                errorCallback("Fail to capture a photo.");
-            });
-        }
-    }
-};
-
-require("cordova/exec/proxy").add("Camera",module.exports);

src/wp/Camera.cs

@@ -343,18 +343,8 @@ namespace WPCordovaClassLib.Cordova.Commands
 
             try
             {
-                //use photo's actual width & height if user doesn't provide width & height
-                if (cameraOptions.TargetWidth < 0 && cameraOptions.TargetHeight < 0)
-                {
-                    int streamLength = (int)stream.Length;
-                    imageContent = new byte[streamLength + 1];
-                    stream.Read(imageContent, 0, streamLength);
-                }
-                else
-                {
-                    // resize photo
-                    imageContent = ResizePhoto(stream);
-                }
+                // Resize photo and convert to JPEG
+                imageContent = ResizePhoto(stream);
             }
             finally
             {
@@ -368,7 +358,6 @@ namespace WPCordovaClassLib.Cordova.Commands
         /// Resize image
         /// </summary>
         /// <param name="stream">Image stream</param>
-        /// <param name="fileData">File data</param>
         /// <returns>resized image</returns>
         private byte[] ResizePhoto(Stream stream)
         {
@@ -382,10 +371,22 @@ namespace WPCordovaClassLib.Cordova.Commands
             WriteableBitmap objWB = new WriteableBitmap(objBitmap);
             objBitmap.UriSource = null;
 
-            //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);
+            // 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())

tests/plugin.xml

@@ -0,0 +1,33 @@
+<?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.
+-->
+
+<plugin xmlns="http://apache.org/cordova/ns/plugins/1.0"
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:rim="http://www.blackberry.com/ns/widgets"
+    id="org.apache.cordova.camera.tests"
+    version="0.3.2">
+    <name>Cordova Camera Plugin Tests</name>
+    <license>Apache 2.0</license>
+    
+    <dependency id="org.apache.cordova.file" version=">=1.0.1" />
+
+    <js-module src="tests.js" name="tests">
+    </js-module>
+</plugin>

tests/tests.js

@@ -0,0 +1,504 @@
+/*
+ *
+ * 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.
+ *
+*/
+
+exports.defineAutoTests = function () {
+    describe('Camera (navigator.camera)', function () {
+        it("should exist", function () {
+            expect(navigator.camera).toBeDefined();
+        });
+
+        it("should contain a getPicture function", function () {
+            expect(navigator.camera.getPicture).toBeDefined();
+            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 () {
+            expect(window.Camera).toBeDefined();
+        });
+
+        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);
+            expect(navigator.camera.DestinationType.DATA_URL).toBe(0);
+            expect(navigator.camera.DestinationType.FILE_URI).toBe(1);
+            expect(navigator.camera.DestinationType.NATIVE_URI).toBe(2);
+        });
+
+        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 () {
+            expect(Camera.MediaType.PICTURE).toBe(0);
+            expect(Camera.MediaType.VIDEO).toBe(1);
+            expect(Camera.MediaType.ALLMEDIA).toBe(2);
+            expect(navigator.camera.MediaType.PICTURE).toBe(0);
+            expect(navigator.camera.MediaType.VIDEO).toBe(1);
+            expect(navigator.camera.MediaType.ALLMEDIA).toBe(2);
+        });
+
+        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);
+            expect(navigator.camera.PictureSourceType.PHOTOLIBRARY).toBe(0);
+            expect(navigator.camera.PictureSourceType.CAMERA).toBe(1);
+            expect(navigator.camera.PictureSourceType.SAVEDPHOTOALBUM).toBe(2);
+        });
+    });
+};
+
+
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+
+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
+    var camQualityDefault = ['50', 50];
+    var camDestinationTypeDefault = ['FILE_URI', 1];
+    var camPictureSourceTypeDefault = ['CAMERA', 1];
+    var camAllowEditDefault = ['allowEdit', false];
+    var camEncodingTypeDefault = ['JPEG', 0];
+    var camMediaTypeDefault = ['mediaType', 0];
+    var camCorrectOrientationDefault = ['correctOrientation', false];
+    var camSaveToPhotoAlbumDefault = ['saveToPhotoAlbum', true];
+
+    var clearLog = function () {
+        var log = document.getElementById('info');
+        log.innerHTML = "";
+    }
+
+    function log(value) {
+        console.log(value);
+        document.getElementById('camera_status').textContent += (new Date() - pageStartTime) / 1000 + ': ' + value + '\n';
+    }
+
+    function clearStatus() {
+        document.getElementById('camera_status').innerHTML = '';
+        document.getElementById('camera_image').src = 'about:blank';
+        var canvas = document.getElementById('canvas');
+        canvas.width = canvas.height = 1;
+        pictureUrl = null;
+        fileObj = null;
+        fileEntry = null;
+    }
+
+    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;
+        } catch (e) {
+            // not DATA_URL
+            log('URL: ' + url.slice(0, 100));
+        }
+
+        pictureUrl = url;
+        var img = document.getElementById('camera_image');
+        var startTime = new Date();
+        img.src = url;
+        img.onloadend = function () {
+            log('Image tag load time: ' + (new Date() - startTime));
+            callback && callback();
+        };
+    }
+
+    function onGetPictureError(e) {
+        log('Error getting picture: ' + e.code);
+    }
+
+    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) {
+                fileEntry = e;
+                logCallback('resolveLocalFileSystemURI()', true)(e.toURL());
+            }, logCallback('resolveLocalFileSystemURI()', false));
+        } else if (pictureUrl.indexOf('data:image/jpeg;base64') == 0) {
+            // do nothing
+        } else {
+            var path = pictureUrl.replace(/^file:\/\/(localhost)?/, '').replace(/%20/g, ' ');
+            fileEntry = new FileEntry('image_name.png', path);
+        }
+    }
+
+    function getPicture() {
+        clearStatus();
+        var options = extractOptions();
+        log('Getting picture with options: ' + JSON.stringify(options));
+        var popoverHandle = navigator.camera.getPicture(getPictureWin, onGetPictureError, options);
+
+        // Reposition the popover if the orientation changes.
+        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";
+        options.fileName = 'test.jpg';
+        options.mimeType = "image/jpeg";
+        ft.onprogress = function (progressEvent) {
+            console.log('progress: ' + progressEvent.loaded + ' of ' + progressEvent.total);
+        };
+        var server = "http://cordova-filetransfer.jitsu.com";
+
+        ft.upload(pictureUrl, server + '/upload', win, fail, options);
+        function win(information_back) {
+            log('upload complete');
+        }
+        function fail(message) {
+            log('upload failed: ' + JSON.stringify(message));
+        }
+    }
+
+    function logCallback(apiName, success) {
+        return function () {
+            log('Call to ' + apiName + (success ? ' success: ' : ' failed: ') + JSON.stringify([].slice.call(arguments)));
+        };
+    }
+
+    /**
+     * 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) {
+            var img = document.getElementById('camera_image');
+            img.style.visibility = "visible";
+            img.style.display = "block";
+            img.src = evt.target.result;
+            log("FileReader.readAsDataURL success");
+        };
+
+        function onFileReceived(file) {
+            log('Got file: ' + JSON.stringify(file));
+            fileObj = file;
+
+            var reader = new FileReader();
+            reader.onload = function () {
+                log('FileReader.readAsDataURL() - length = ' + reader.result.length);
+            };
+            reader.onerror = logCallback('FileReader.readAsDataURL', false);
+            reader.readAsDataURL(file);
+        };
+        // Test out onFileReceived when the file object was set via a native <input> elements.
+        if (fileObj) {
+            onFileReceived(fileObj);
+        } else {
+            fileEntry.file(onFileReceived, logCallback('FileEntry.file', false));
+        }
+    }
+    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.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() {
+        var onFileSystemReceived = function (fileSystem) {
+            var destDirEntry = fileSystem.root;
+            var origName = fileEntry.name;
+
+            // Test FileEntry API here.
+            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) {
+                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) {
+                fileEntry.remove(logCallback('FileEntry.remove', true), logCallback('FileEntry.remove', false));
+                console.log('Cleanup: successfully removed copied file');
+            }, function () {
+                console.log('Cleanup: failed to remove copied file');
+            });
+        };
+
+        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() {
+        var onFileWriterReceived = function (fileWriter) {
+            fileWriter.onwrite = logCallback('FileWriter.write', true);
+            fileWriter.onerror = logCallback('FileWriter.write', false);
+            fileWriter.write("some text!");
+        };
+
+        var onFileTruncateWriterReceived = function (fileWriter) {
+            fileWriter.onwrite = logCallback('FileWriter.truncate', true);
+            fileWriter.onerror = logCallback('FileWriter.truncate', false);
+            fileWriter.truncate(10);
+        };
+
+        fileEntry.createWriter(onFileWriterReceived, logCallback('FileEntry.createWriter', false));
+        fileEntry.createWriter(onFileTruncateWriterReceived, null);
+    };
+
+    function displayImageUsingCanvas() {
+        var canvas = document.getElementById('canvas');
+        var img = document.getElementById('camera_image');
+        var w = img.width;
+        var h = img.height;
+        h = 100 / w * h;
+        w = 100;
+        canvas.width = w;
+        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() {
+        fileEntry.remove(logCallback('FileEntry.remove', true), logCallback('FileEntry.remove', false));
+    };
+
+    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) {
+        if (!inputEl.value) {
+            alert('No file selected.');
+            return;
+        }
+        fileObj = inputEl.files[0];
+        if (!fileObj) {
+            alert('Got value but no file.');
+            return;
+        }
+        var URLApi = window.URL || window.webkitURL;
+        if (URLApi) {
+            var blobURL = URLApi.createObjectURL(fileObj);
+            if (blobURL) {
+                setPicture(blobURL, function () {
+                    URLApi.revokeObjectURL(blobURL);
+                });
+            } else {
+                log('URL.createObjectURL returned null');
+            }
+        } else {
+            log('URL.createObjectURL() not supported.');
+        }
+    }
+
+    function extractOptions() {
+        var els = document.querySelectorAll('#image-options select');
+        var ret = {};
+        for (var i = 0, el; el = els[i]; ++i) {
+            var value = el.value;
+            if (value === '') continue;
+            if (el.isBool) {
+                ret[el.getAttribute("name")] = !!+value;
+            } else {
+                ret[el.getAttribute("name")] = +value;
+            }
+        }
+        return ret;
+    }
+
+    function createOptionsEl(name, values, selectionDefault) {
+        var openDiv = '<div style="display: inline-block">' + name + ': ';
+        var select = '<select name=' + name + '>';
+
+        var defaultOption = '';
+        if (selectionDefault == undefined) {
+            defaultOption = '<option value="">default</option>';
+        }
+
+        var options = '';
+        if (typeof values == 'boolean') {
+            values = { 'true': 1, 'false': 0 };
+        }
+        for (var k in values) {
+            var isSelected = '';
+            if (selectionDefault) {
+                if (selectionDefault[0] == k) {
+                    isSelected = 'selected';
+                }
+            }
+            options += '<option value="' + values[k] + '" ' + isSelected + '>' + k + '</option>';
+        }
+
+        var closeDiv = '</select></div>';
+
+        return openDiv + select + defaultOption + options + closeDiv;
+    }
+
+    /******************************************************************************/
+
+    var info_div = '<h1>Camera</h1>' +
+            '<div id="info">' +
+            '<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 id="image-options">' +
+            createOptionsEl('sourceType', Camera.PictureSourceType, camPictureSourceTypeDefault) +
+            createOptionsEl('destinationType', Camera.DestinationType, camDestinationTypeDefault) +
+            createOptionsEl('encodingType', Camera.EncodingType, camEncodingTypeDefault) +
+            createOptionsEl('mediaType', Camera.MediaType, camMediaTypeDefault) +
+            createOptionsEl('quality', { '0': 0, '50': 50, '80': 80, '100': 100 }, camQualityDefault) +
+            createOptionsEl('targetWidth', { '50': 50, '200': 200, '800': 800, '2048': 2048 }) +
+            createOptionsEl('targetHeight', { '50': 50, '200': 200, '800': 800, '2048': 2048 }) +
+            createOptionsEl('allowEdit', true, camAllowEditDefault) +
+            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>' +
+            '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">' +
+            '<ol> <li>All default options. Should be able to edit once picture is taken and will be saved to library.</li>' +
+            '</p><li>sourceType=PHOTOLIBRARY<br>Should be able to see picture that was just taken in previous test and edit when selected</li>' +
+            '</p><li>sourceType=Camera<br>allowEdit=false<br>saveToPhotoAlbum=false<br>Should not be able to edit when taken and will not save to library</li>' +
+            '</p><li>encodingType=PNG<br>allowEdit=true<br>saveToPhotoAlbum=true<br>cameraDirection=FRONT<br>Should bring up front camera. Verify in status box info URL that image is encoded as PNG.</li>' +
+            '</p><li>sourceType=SAVEDPHOTOALBUM<br>mediaType=VIDEO<br>Should only be able to select a video</li>' +
+            '</p><li>sourceType=SAVEDPHOTOALBUM<br>mediaType=PICTURE<br>allowEdit=false<br>Should only be able to select a picture and not edit</li>' +
+            '</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>' +
+            '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>' +
+            '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"' +
+            '</p><div id="reader"></div>' +
+            'Expected result: Read contents of file.<br>Status box will show "Got file: {some metadata}, FileReader.readAsDataURL() - length = someNumber"' +
+            '</p><div id="copy"></div>' +
+            'Expected result: Copy image to new location and move file to different location.<br>Status box will show "Call to FileEntry.copyTo success:{some metadata}, Call to FileEntry.moveTo success:{some metadata}"' +
+            '</p><div id="write"></div>' +
+            'Expected result: Write image to library.<br>Status box will show "Call to FileWriter.write success:{some metadata}, Call to FileWriter.truncate success:{some metadata}"' +
+            '</p><div id="upload"></div>' +
+            'Expected result: Upload image to server.<br>Status box may print out progress. Once finished will show "upload complete"' +
+            '</p><div id="draw_canvas"></div>' +
+            'Expected result: Display image using canvas.<br>Image will be displayed in status box under "canvas:"' +
+            '</p><div id="remove"></div>' +
+            'Expected result: Remove image from library.<br>Status box will show "FileEntry.remove success:["OK"]';
+
+    // 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() {
+            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 listener = function (e) {
+        testInputTag(e.target);
+    }
+    for (var i = 0; i < elements.length; ++i) {
+        var item = elements[i];
+        item.addEventListener("change", listener, false);
+    }
+
+    createActionButton('Get picture', function () {
+        getPicture();
+    }, 'getpicture');
+
+    createActionButton('Clear Status', function () {
+        clearStatus();
+    }, 'getpicture');
+
+    createActionButton('Get File Metadata', function () {
+        getFileInfo();
+    }, 'metadata');
+
+    createActionButton('Read with FileReader', function () {
+        readFile();
+    }, 'reader');
+
+    createActionButton('Copy Image', function () {
+        copyImage();
+    }, 'copy');
+
+    createActionButton('Write Image', function () {
+        writeImage();
+    }, 'write');
+
+    createActionButton('Upload Image', function () {
+        uploadImage();
+    }, 'upload');
+
+    createActionButton('Draw Using Canvas', function () {
+        displayImageUsingCanvas();
+    }, 'draw_canvas');
+
+    createActionButton('Remove Image', function () {
+        removeImage();
+    }, 'remove');
+};

www/blackberry10/assets/camera.html

@@ -0,0 +1,82 @@
+<!--
+ 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

@@ -0,0 +1,46 @@
+/*
+ * 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('org.apache.cordova.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('org.apache.cordova.camera', canvas.toDataURL('img/png'));
+            };
+        },
+        function () {
+            window.qnx.callExtensionMethod('org.apache.cordova.camera', 'error', 'getUserMedia failed');
+        }
+    );
+});