Merge lp:~dbarth/cordova-ubuntu/3.4-core-platform-plugins into lp:cordova-ubuntu/container

[David Barth]

Add missing core plugins

[lp:~dbarth/cordova-ubuntu/3.4-core-platform-plugins]

19. By David Barth on 2014-02-18

sync with trunk

20. By David Barth on 2014-02-19

add missing plugin javascript files & assets

21. By David Barth on 2014-02-19

rules file update, but doesn't manage to copy the 2 directories i need

22. By David Barth on 2014-02-19

it worked\!

[Alexandre Abreu (abreu-alexandre)]

works fine for me

review: Approve

=== modified file 'apparmor.json'
--- apparmor.json	2014-02-06 00:00:42 +0000
+++ apparmor.json	2014-02-19 16:53:58 +0000
@@ -1,1 +1,1 @@
-{"policy_groups":["networking","audio"],"policy_version":1}
\ No newline at end of file
+{"policy_groups":["networking","audio","camera","sensors","location","microphone","video","audio","camera","microphone"],"policy_version":1}
\ No newline at end of file

=== modified file 'build/src/coreplugins.cpp'
--- build/src/coreplugins.cpp	2014-02-05 23:42:31 +0000
+++ build/src/coreplugins.cpp	2014-02-19 16:53:58 +0000
@@ -19,6 +19,22 @@
 #include <QtCore>
 #include "cplugin.h"
 #include "coreplugins.h"
+#include "plugins/org.apache.cordova.camera/camera.h"
+#include "plugins/org.apache.cordova.console/console.h"
+#include "plugins/org.apache.cordova.device/device.h"
+#include "plugins/org.apache.cordova.device-motion/accelerometer.h"
+#include "plugins/org.apache.cordova.device-orientation/compass.h"
+#include "plugins/org.apache.cordova.file/file.h"
+#include "plugins/org.apache.cordova.media-capture/capture.h"
+#include "plugins/org.apache.cordova.media/media.h"
+#include "plugins/org.apache.cordova.inappbrowser/inappbrowser.h"
+#include "plugins/org.apache.cordova.splashscreen/splashscreen.h"
+#include "plugins/org.apache.cordova.vibration/vibration.h"
+#include "plugins/org.apache.cordova.geolocation/geolocation.h"
+#include "plugins/org.apache.cordova.globalization/globalization.h"
+#include "plugins/org.apache.cordova.battery-status/battery.h"
+#include "plugins/org.apache.cordova.file-transfer/file-transfer.h"
+#include "plugins/org.apache.cordova.dialogs/notification.h"
 INSERT_HEADER_HERE
 
 #define INIT_PLUGIN(class) \
@@ -29,7 +45,7 @@
 Q_DECL_EXPORT QList<QSharedPointer<CPlugin>> cordovaGetPluginInstances(Cordova *cordova) {
     QList<QSharedPointer<CPlugin>> res;
 
-    INSERT_PLUGIN_HERE
+    INIT_PLUGIN(Camera);INIT_PLUGIN(Console);INIT_PLUGIN(Device);INIT_PLUGIN(DeviceMotion);INIT_PLUGIN(DeviceOrientation);INIT_PLUGIN(File);INIT_PLUGIN(MediaCapture);INIT_PLUGIN(Media);INIT_PLUGIN(Inappbrowser);INIT_PLUGIN(Splashscreen);INIT_PLUGIN(Vibration);INIT_PLUGIN(Geolocation);INIT_PLUGIN(Globalization);INIT_PLUGIN(BatteryStatus);INIT_PLUGIN(FileTransfer);INIT_PLUGIN(Dialogs);INSERT_PLUGIN_HERE
 
     return res;
 }

=== added directory 'build/src/plugins/org.apache.cordova.battery-status'
=== added file 'build/src/plugins/org.apache.cordova.battery-status/battery.cpp'
--- build/src/plugins/org.apache.cordova.battery-status/battery.cpp	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.battery-status/battery.cpp	2014-02-19 16:53:58 +0000
@@ -0,0 +1,78 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+
+#include <QtCore>
+
+#include "battery.h"
+
+BatteryStatus::BatteryStatus(Cordova *cordova) : CPlugin(cordova) {
+    _scId = 0;
+
+    connect(&_batteryInfo, SIGNAL(remainingCapacityChanged(int,int)), this, SLOT(remainingCapacityChanged(int,int)));
+    connect(&_batteryInfo, SIGNAL(chargerTypeChanged(QBatteryInfo::ChargerType)), this, SLOT(chargerTypeChanged(QBatteryInfo::ChargerType)));
+}
+
+void BatteryStatus::remainingCapacityChanged(int battery, int capacity) {
+    Q_UNUSED(battery);
+    Q_UNUSED(capacity);
+
+    fireEvents();
+}
+
+void BatteryStatus::chargerTypeChanged(QBatteryInfo::ChargerType type) {
+    Q_UNUSED(type);
+
+    fireEvents();
+}
+
+void BatteryStatus::fireEvents() {
+    int fullCount = 0;
+    bool isPlugged = false;
+
+    int remaining = 0, total = 0;
+    for (int i = 0; i < _batteryInfo.batteryCount(); i++) {
+        isPlugged = (_batteryInfo.chargingState(i) == QBatteryInfo::Charging) || isPlugged;
+        fullCount += _batteryInfo.chargingState(i) == QBatteryInfo::Full;
+
+        remaining += _batteryInfo.remainingCapacity(i);
+        total += _batteryInfo.maximumCapacity(i);
+    }
+
+    isPlugged = isPlugged || (_batteryInfo.batteryCount() == fullCount);
+
+    if (_scId) {
+        QVariantMap obj;
+        obj.insert("isPlugged", (int)isPlugged);
+        if (total != 0)
+          obj.insert("level", remaining * 100 / total);
+        else
+          obj.insert("level", 100);
+
+        this->callbackWithoutRemove(_scId, CordovaInternal::format(obj));
+    }
+}
+
+void BatteryStatus::start(int scId, int) {
+    _scId = scId;
+}
+
+void BatteryStatus::stop(int, int) {
+    _scId = 0;
+}

=== added file 'build/src/plugins/org.apache.cordova.battery-status/battery.h'
--- build/src/plugins/org.apache.cordova.battery-status/battery.h	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.battery-status/battery.h	2014-02-19 16:53:58 +0000
@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+
+#ifndef BATTERY_H_AAAAAAAA
+#define BATTERY_H_AAAAAAAA
+
+#include <QBatteryInfo>
+
+#include <cplugin.h>
+
+class BatteryStatus: public CPlugin {
+    Q_OBJECT
+public:
+    explicit BatteryStatus(Cordova *cordova);
+
+    virtual const QString fullName() override {
+        return BatteryStatus::fullID();
+    }
+
+    virtual const QString shortName() override {
+        return "Battery";
+    }
+
+    static const QString fullID() {
+        return "Battery";
+    }
+
+public slots:
+    void start(int scId, int ecId);
+    void stop(int scId, int ecId);
+
+private slots:
+    void remainingCapacityChanged(int battery, int capacity);
+    void chargerTypeChanged(QBatteryInfo::ChargerType type);
+    void onlineStatusChanged(bool isOnline);
+
+private:
+    void fireEvents();
+
+    QBatteryInfo _batteryInfo;
+
+    int _scId;
+};
+
+#endif

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

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

=== added directory 'build/src/plugins/org.apache.cordova.console'
=== added file 'build/src/plugins/org.apache.cordova.console/console.cpp'
--- build/src/plugins/org.apache.cordova.console/console.cpp	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.console/console.cpp	2014-02-19 16:53:58 +0000
@@ -0,0 +1,29 @@
+/*
+ *  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.
+ */
+
+#include "console.h"
+
+#include <iostream>
+
+Console::Console(Cordova *cordova) : CPlugin(cordova) {
+}
+
+void Console::logLevel(int scId, int ecId, QString level, QString message) {
+    Q_UNUSED(scId)
+    Q_UNUSED(ecId)
+
+    if (level != "LOG")
+      std::cout << "[" << level.toStdString() << "] ";
+    std::cout << message.toStdString() << std::endl;
+}

=== added file 'build/src/plugins/org.apache.cordova.console/console.h'
--- build/src/plugins/org.apache.cordova.console/console.h	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.console/console.h	2014-02-19 16:53:58 +0000
@@ -0,0 +1,43 @@
+/*
+ *  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.
+ */
+
+#ifndef CONSOLE_H_FDSVCXGFRS
+#define CONSOLE_H_FDSVCXGFRS
+
+#include <cplugin.h>
+
+#include <QtCore>
+
+class Console : public CPlugin {
+    Q_OBJECT
+public:
+    explicit Console(Cordova *cordova);
+
+    virtual const QString fullName() override {
+        return Console::fullID();
+    }
+
+    virtual const QString shortName() override {
+        return "Console";
+    }
+
+    static const QString fullID() {
+        return "Console";
+    }
+
+public slots:
+    void logLevel(int scId, int ecId, QString level, QString message);
+};
+
+#endif

=== added directory 'build/src/plugins/org.apache.cordova.device'
=== added directory 'build/src/plugins/org.apache.cordova.device-motion'
=== added file 'build/src/plugins/org.apache.cordova.device-motion/accelerometer.cpp'
--- build/src/plugins/org.apache.cordova.device-motion/accelerometer.cpp	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.device-motion/accelerometer.cpp	2014-02-19 16:53:58 +0000
@@ -0,0 +1,58 @@
+/*
+ *
+ * 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.
+ *
+*/
+
+#include <cassert>
+#include "accelerometer.h"
+
+DeviceMotion::DeviceMotion(Cordova *cordova): CPlugin(cordova), _scId(0), _ecId(0) {
+    _accelerometerSource = QSharedPointer<QAccelerometer>(new QAccelerometer());
+    _sensorAvaliable = _accelerometerSource->start();
+    connect(_accelerometerSource.data(), SIGNAL(readingChanged()), SLOT(updateSensor()));
+}
+
+void DeviceMotion::start(int scId, int ecId) {
+    assert(_ecId == 0);
+    assert(_scId == 0);
+
+    _ecId = ecId;
+    _scId = scId;
+
+    if (!_sensorAvaliable) {
+        this->cb(ecId);
+        return;
+    }
+}
+
+void DeviceMotion::stop(int, int) {
+    _scId = 0;
+    _ecId = 0;
+}
+
+void DeviceMotion::updateSensor() {
+    QAccelerometerReading *accelerometer = _accelerometerSource->reading();
+
+    QVariantMap obj;
+    obj.insert("x", accelerometer->x());
+    obj.insert("y", accelerometer->y());
+    obj.insert("z", accelerometer->z());
+    // accelerometer->timestamp() is not sutiable.
+    // Timestamps values are microseconds since _a_ fixed point(depend on backend).
+    obj.insert("timestamp", QDateTime::currentDateTime().toMSecsSinceEpoch());
+
+    if (_scId)
+        this->cb(_scId, obj);
+}

=== added file 'build/src/plugins/org.apache.cordova.device-motion/accelerometer.h'
--- build/src/plugins/org.apache.cordova.device-motion/accelerometer.h	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.device-motion/accelerometer.h	2014-02-19 16:53:58 +0000
@@ -0,0 +1,55 @@
+/*
+ *
+ * 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.
+ *
+*/
+
+#ifndef ACCELEROMETER_H
+#define ACCELEROMETER_H
+
+#include <cplugin.h>
+#include <QAccelerometer>
+#include <QtCore>
+
+class DeviceMotion: public CPlugin {
+    Q_OBJECT
+public:
+    explicit DeviceMotion(Cordova *cordova);
+
+    virtual const QString fullName() override {
+        return DeviceMotion::fullID();
+    }
+
+    virtual const QString shortName() override {
+        return "Accelerometer";
+    }
+
+    static const QString fullID() {
+        return "Accelerometer";
+    }
+
+public slots:
+    void start(int scId, int ecId);
+    void stop(int scId, int ecId);
+
+protected slots:
+    void updateSensor();
+
+private:
+    int _scId, _ecId;
+    bool _sensorAvaliable;
+    QSharedPointer<QAccelerometer> _accelerometerSource;
+};
+
+#endif

=== added directory 'build/src/plugins/org.apache.cordova.device-orientation'
=== added file 'build/src/plugins/org.apache.cordova.device-orientation/compass.cpp'
--- build/src/plugins/org.apache.cordova.device-orientation/compass.cpp	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.device-orientation/compass.cpp	2014-02-19 16:53:58 +0000
@@ -0,0 +1,75 @@
+/*
+ *  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.
+ */
+
+#include "compass.h"
+
+DeviceOrientation::DeviceOrientation(Cordova *cordova): CPlugin(cordova), _validData(false) {
+    _compass.connectToBackend();
+    connect(&_compass, SIGNAL(readingChanged()), SLOT(updateSensor()));
+    connect(&_compass, SIGNAL(sensorError(int)), SLOT(sensorError(int)));
+}
+
+void DeviceOrientation::getHeading(int scId, int ecId, QVariantMap options) {
+    Q_UNUSED(options);
+    if (_compass.isConnectedToBackend() || !_compass.start()) {
+        this->callback(ecId, "CompassError.COMPASS_NOT_SUPPORTED");
+        return;
+    }
+
+    _successCallbacks << scId;
+    _errorCallbacks << ecId;
+
+    if (_validData) {
+        reportResult();
+        return;
+    }
+}
+
+void DeviceOrientation::sensorError(int error) {
+    Q_UNUSED(error);
+
+    for (int ecId: _errorCallbacks) {
+        this->callback(ecId, "CompassError.COMPASS_INTERNAL_ERR");
+    }
+
+    _errorCallbacks.clear();
+    _successCallbacks.clear();
+    _validData = false;
+}
+
+void DeviceOrientation::reportResult() {
+    QVariantMap obj;
+
+    obj.insert("magneticHeading", _azymuth);
+    obj.insert("trueHeading", _azymuth);
+    obj.insert("headingAccuracy", _accuracy);
+    obj.insert("timestamp", _timestamp);
+
+    for (int scId: _successCallbacks) {
+        this->cb(scId, obj);
+    }
+
+    _errorCallbacks.clear();
+    _successCallbacks.clear();
+}
+
+void DeviceOrientation::updateSensor(){
+    QCompassReading *heading = _compass.reading();
+    _azymuth = heading->azimuth();
+    _accuracy = heading->calibrationLevel();
+    _timestamp = QDateTime::currentDateTime().toMSecsSinceEpoch();
+
+    _validData = true;
+    reportResult();
+}

=== added file 'build/src/plugins/org.apache.cordova.device-orientation/compass.h'
--- build/src/plugins/org.apache.cordova.device-orientation/compass.h	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.device-orientation/compass.h	2014-02-19 16:53:58 +0000
@@ -0,0 +1,58 @@
+/*
+ *  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.
+ */
+
+#ifndef COMPASS_H_HKFSAHKDFAS
+#define COMPASS_H_HKFSAHKDFAS
+
+#include <cplugin.h>
+#include <QCompass>
+#include <QtCore>
+
+class DeviceOrientation: public CPlugin {
+    Q_OBJECT
+public:
+    explicit DeviceOrientation(Cordova *cordova);
+
+    virtual const QString fullName() override {
+        return DeviceOrientation::fullID();
+    }
+
+    virtual const QString shortName() override {
+        return "Compass";
+    }
+
+    static const QString fullID() {
+        return "Compass";
+    }
+
+public slots:
+    void getHeading(int scId, int ecId, QVariantMap options);
+
+protected slots:
+    void updateSensor();
+    void sensorError(int error);
+
+private:
+    void reportResult();
+    QCompass _compass;
+    QList<int> _successCallbacks;
+    QList<int> _errorCallbacks;
+
+    double _azymuth;
+    double _accuracy;
+    qtimestamp _timestamp;
+    bool _validData;
+};
+
+#endif

=== added file 'build/src/plugins/org.apache.cordova.device/device.cpp'
--- build/src/plugins/org.apache.cordova.device/device.cpp	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.device/device.cpp	2014-02-19 16:53:58 +0000
@@ -0,0 +1,64 @@
+/*
+ *  Copyright 2011 Wolfgang Koller - http://www.gofg.at/
+ *
+ *  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.
+ */
+
+#include <QDeviceInfo>
+#include <QtSystemInfo>
+
+#include"device.h"
+
+#define CORDOVA "3.0.0"
+
+Device::Device(Cordova *cordova) : CPlugin(cordova) {
+}
+
+static QString getOSName() {
+#ifdef Q_OS_SYMBIAN
+    QString platform = "Symbian";
+#endif
+#ifdef Q_OS_WIN
+    QString platform = "Windows";
+#endif
+#ifdef Q_OS_WINCE
+    QString platform = "Windows CE";
+#endif
+#ifdef Q_OS_LINUX
+    QString platform = "Linux";
+#endif
+    return platform;
+}
+
+void Device::getInfo(int scId, int ecId) {
+    Q_UNUSED(ecId)
+
+    QDeviceInfo systemDeviceInfo;
+    QDeviceInfo systemInfo;
+
+    QString platform = getOSName();
+
+    QString uuid = systemDeviceInfo.uniqueDeviceID();
+    if (uuid.isEmpty()) {
+        QString deviceDescription = systemInfo.imei(0) + ";" + systemInfo.manufacturer() + ";" + systemInfo.model() + ";" + systemInfo.productName() + ";" + platform;
+        QString user = qgetenv("USER");
+        if (user.isEmpty()) {
+            user = qgetenv("USERNAME");
+            if (user.isEmpty())
+                user = QDir::homePath();
+        }
+        uuid = QString(QCryptographicHash::hash((deviceDescription + ";" + user).toUtf8(), QCryptographicHash::Md5).toHex());
+    }
+
+    this->cb(scId, systemDeviceInfo.model(), CORDOVA, platform, uuid, systemInfo.version(QDeviceInfo::Os));
+}

=== added file 'build/src/plugins/org.apache.cordova.device/device.h'
--- build/src/plugins/org.apache.cordova.device/device.h	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.device/device.h	2014-02-19 16:53:58 +0000
@@ -0,0 +1,47 @@
+/*
+ *  Copyright 2011 Wolfgang Koller - http://www.gofg.at/
+ *
+ *  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.
+ */
+
+#ifndef DEVICE_H_FDSAFAS
+#define DEVICE_H_FDSAFAS
+
+#include <QtCore>
+
+#include <cplugin.h>
+
+class Device: public CPlugin {
+    Q_OBJECT
+public:
+    explicit Device(Cordova *cordova);
+
+    virtual const QString fullName() override {
+        return Device::fullID();
+    }
+
+    virtual const QString shortName() override {
+        return "Device";
+    }
+
+    static const QString fullID() {
+        return "com.cordova.Device";
+    }
+
+signals:
+
+public slots:
+    void getInfo(int scId, int ecId);
+};
+
+#endif

=== added directory 'build/src/plugins/org.apache.cordova.dialogs'
=== added file 'build/src/plugins/org.apache.cordova.dialogs/notification.cpp'
--- build/src/plugins/org.apache.cordova.dialogs/notification.cpp	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.dialogs/notification.cpp	2014-02-19 16:53:58 +0000
@@ -0,0 +1,81 @@
+/*
+ *
+ *  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.
+ */
+
+#include "notification.h"
+
+#include <QApplication>
+
+#include <QMediaPlayer>
+#include <QMessageBox>
+
+void Dialogs::beep(int scId, int ecId, int times) {
+    Q_UNUSED(scId)
+    Q_UNUSED(ecId)
+    Q_UNUSED(times)
+    QMediaPlayer* player = new QMediaPlayer;
+    player->setVolume(100);
+    player->setMedia(QUrl::fromLocalFile("/usr/share/sounds/ubuntu/stereo/bell.ogg"));
+    player->play();
+}
+
+void Dialogs::alert(int scId, int ecId, const QString &message, const QString &title, const QString &buttonLabel) {
+    QStringList list;
+    list.append(buttonLabel);
+
+    confirm(scId, ecId, message, title, list);
+}
+
+void Dialogs::confirm(int scId, int ecId, const QString &message, const QString &title, const QStringList &buttonLabels) {
+    Q_UNUSED(ecId);
+
+    //FIXME:
+    assert(!_alertCallback);
+    _alertCallback = scId;
+
+    QString s1, s2, s3;
+    if (buttonLabels.size() > 0)
+        s1 = buttonLabels[0];
+    if (buttonLabels.size() > 1)
+        s2 = buttonLabels[1];
+    if (buttonLabels.size() > 2)
+        s3 = buttonLabels[2];
+
+    QString path = m_cordova->get_app_dir() + "/../qml/notification.qml";
+    //FIXME:
+    QString qml = QString("PopupUtils.open(\"%1\", root, { root: root, cordova: cordova, title: \"%2\", text: \"%3\", promptVisible: false, button1Text: \"%4\", button2Text: \"%5\", button3Text: \"%6\" })")
+                      .arg(path).arg(title).arg(message).arg(s1).arg(s2).arg(s3);
+    m_cordova->execQML(qml);
+}
+
+void Dialogs::prompt(int scId, int ecId, const QString &message, const QString &title, const QStringList &buttonLabels, const QString &defaultText) {
+    Q_UNUSED(ecId)
+
+    assert(!_alertCallback);
+    _alertCallback = scId;
+
+    QString s1, s2, s3;
+    if (buttonLabels.size() > 0)
+        s1 = buttonLabels[0];
+    if (buttonLabels.size() > 1)
+        s2 = buttonLabels[1];
+    if (buttonLabels.size() > 2)
+        s3 = buttonLabels[2];
+    QString path = m_cordova->get_app_dir() + "/../qml/notification.qml";
+    QString qml = QString("PopupUtils.open(\"%1\", root, { root: root, cordova: cordova, title: \"%2\", text: \"%3\", promptVisible: true, defaultPromptText: \"%7\", button1Text: \"%4\", button2Text: \"%5\", button3Text: \"%6\" })")
+                      .arg(path).arg(title).arg(message).arg(s1).arg(s2).arg(s3).arg(defaultText);
+
+    qDebug() << qml;
+    m_cordova->execQML(qml);
+}

=== added file 'build/src/plugins/org.apache.cordova.dialogs/notification.h'
--- build/src/plugins/org.apache.cordova.dialogs/notification.h	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.dialogs/notification.h	2014-02-19 16:53:58 +0000
@@ -0,0 +1,63 @@
+/*
+ *
+ *  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.
+ */
+
+#ifndef NOTIFICATION_H
+#define NOTIFICATION_H
+
+#include <QtQuick>
+#include <cplugin.h>
+#include <cordova.h>
+
+class Dialogs: public CPlugin {
+    Q_OBJECT
+public:
+    explicit Dialogs(Cordova *cordova): CPlugin(cordova), _alertCallback(0) {
+    }
+
+    virtual const QString fullName() override {
+        return Dialogs::fullID();
+    }
+
+    virtual const QString shortName() override {
+        return "Notification";
+    }
+
+    static const QString fullID() {
+        return "Notification";
+    }
+public slots:
+    void beep(int scId, int ecId, int times);
+    void alert(int scId, int ecId, const QString &message, const QString &title, const QString &buttonLabel);
+    void confirm(int scId, int ecId, const QString &message, const QString &title, const QStringList &buttonLabels);
+    void prompt(int scId, int ecId, const QString &message, const QString &title, const QStringList &buttonLabels, const QString &defaultText);
+
+    void notificationDialogButtonPressed(int buttonId, const QString &text) {
+        if (text.size()) {
+            QVariantMap res;
+            res.insert("buttonIndex", buttonId);
+            res.insert("input1", text);
+            this->cb(_alertCallback, res);
+        } else {
+            this->cb(_alertCallback, buttonId);
+        }
+        _alertCallback = 0;
+    }
+
+private:
+    QQmlComponent *_component;
+    int _alertCallback;
+};
+
+#endif

=== added directory 'build/src/plugins/org.apache.cordova.file'
=== added directory 'build/src/plugins/org.apache.cordova.file-transfer'
=== added file 'build/src/plugins/org.apache.cordova.file-transfer/file-transfer.cpp'
--- build/src/plugins/org.apache.cordova.file-transfer/file-transfer.cpp	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.file-transfer/file-transfer.cpp	2014-02-19 16:53:58 +0000
@@ -0,0 +1,247 @@
+/*
+ *
+ * Copyright 2013 Canonical Ltd.
+ *
+ * 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.
+ *
+*/
+
+#include "file-transfer.h"
+#include <cassert>
+
+void FileTransfer::download(int scId, int ecId, const QString& url, const QString &target, bool /*trustAllHost*/, int id, const QVariantMap &/*headers*/) {
+    QSharedPointer<FileTransferRequest> request(new FileTransferRequest(_manager, scId, ecId, id, this));
+
+    assert(_id2request.find(id) == _id2request.end());
+
+    _id2request.insert(id, request);
+
+    request->connect(request.data(), &FileTransferRequest::done, [&]() {
+        auto it = _id2request.find(id);
+        while (it != _id2request.end() && it.key() == id) {
+            if (it.value().data() == request.data()) {
+                _id2request.erase(it);
+                break;
+            }
+            it++;
+        }
+    });
+    request->download(url, target);
+}
+
+void FileTransfer::upload(int scId, int ecId, const QString &filePath, const QString& url, const QString& fileKey, const QString& fileName, const QString& mimeType,
+                          const QVariantMap & params, bool /*trustAllHosts*/, bool /*chunkedMode*/, const QVariantMap &headers, int id, const QString &httpMethod) {
+    QSharedPointer<FileTransferRequest> request(new FileTransferRequest(_manager, scId, ecId, id, this));
+
+    assert(_id2request.find(id) == _id2request.end());
+
+    _id2request.insert(id, request);
+
+    request->connect(request.data(), &FileTransferRequest::done, [&]() {
+        auto it = _id2request.find(id);
+        while (it != _id2request.end() && it.key() == id) {
+            if (it.value().data() == request.data()) {
+                _id2request.erase(it);
+                break;
+            }
+            it++;
+        }
+    });
+    request->upload(url, filePath, fileKey, fileName, mimeType, params, headers);
+}
+
+void FileTransfer::abort(int scId, int ecId, int id) {
+    Q_UNUSED(scId)
+    Q_UNUSED(ecId)
+
+    auto it = _id2request.find(id);
+    while (it != _id2request.end() && it.key() == id) {
+        (*it)->abort();
+        it++;
+    }
+}
+
+void FileTransferRequest::download(const QString& uri, const QString &target) {
+    QUrl url(uri);
+    QNetworkRequest request;
+
+    if (!url.isValid()) {
+        QVariantMap map;
+        map.insert("code", INVALID_URL_ERR);
+        map.insert("source", uri);
+        map.insert("target", target);
+        _plugin->cb(_ecId, map);
+        emit done();
+        return;
+    }
+
+    request.setUrl(url);
+    if (url.password().size() || url.userName().size()) {
+        QString headerData = "Basic " + (url.userName() + ":" + url.password()).toLocal8Bit().toBase64();
+        request.setRawHeader("Authorization", headerData.toLocal8Bit());
+    }
+    _reply = QSharedPointer<QNetworkReply>(_manager.get(request));
+
+    _reply->connect(_reply.data(), &QNetworkReply::finished, [this, target, uri]() {
+        if (!_scId || _reply->error() != QNetworkReply::NoError)
+            return;
+
+        QFile res(target);
+        qCritical() << target;
+        if (target[0] != '/' || !res.open(QIODevice::WriteOnly)) {
+            QVariantMap map;
+            map.insert("code", INVALID_URL_ERR);
+            map.insert("source", uri);
+            map.insert("target", target);
+            _plugin->cb(_ecId, map);
+            emit done();
+            return;
+        }
+        res.write(_reply->readAll());
+
+        QFileInfo info(target);
+        QVariantMap map;
+        map.insert("isFile", true);
+        map.insert("isDirectory", false);
+        map.insert("name", info.fileName());
+        map.insert("fullPath", info.absoluteFilePath());
+
+        _plugin->cb(_scId, map);
+
+        emit done();
+    });
+    _reply->connect(_reply.data(), SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(error(QNetworkReply::NetworkError)));
+    _reply->connect(_reply.data(), SIGNAL(downloadProgress(qint64, qint64)), this, SLOT(progress(qint64, qint64)));
+}
+
+void FileTransferRequest::upload(const QString& _url, const QString& filePath, QString fileKey, QString fileName, QString mimeType, const QVariantMap &params, const QVariantMap &headers) {
+    QUrl url(_url);
+    QNetworkRequest request;
+
+    if (!url.isValid()) {
+        QVariantMap map;
+        map.insert("code", INVALID_URL_ERR);
+        map.insert("source", filePath);
+        map.insert("target", _url);
+        _plugin->cb(_ecId, map);
+        emit done();
+        return;
+    }
+
+    QFile file(filePath);
+    if (filePath[0] != '/' || !file.open(QIODevice::ReadOnly)) {
+        QVariantMap map;
+        map.insert("code", FILE_NOT_FOUND_ERR);
+        map.insert("source", filePath);
+        map.insert("target", _url);
+        _plugin->cb(_ecId, map);
+        emit done();
+        return;
+    }
+    QString content{file.readAll()};
+
+    request.setUrl(url);
+    if (url.password().size() || url.userName().size()) {
+        QString headerData = "Basic " + (url.userName() + ":" + url.password()).toLocal8Bit().toBase64();
+        request.setRawHeader("Authorization", headerData.toLocal8Bit());
+    }
+
+    for (const QString &key: headers.keys()) {
+        const QString &value = headers.find(key)->toString();
+        request.setRawHeader(key.toUtf8(), value.toUtf8());
+    }
+
+    QString boundary = QString("CORDOVA-QT-%1A").arg(qrand());
+    while (content.contains(boundary)) {
+        boundary += QString("B%1A").arg(qrand());
+    }
+
+    request.setHeader(QNetworkRequest::ContentTypeHeader, QString("multipart/form-data; boundary=") + boundary);
+
+    fileKey.replace("\"", "");
+    fileName.replace("\"", "");
+    mimeType.replace("\"", "");
+    QString part = "--" + boundary + "\r\n";
+
+    part += "Content-Disposition: form-data; name=\"" + fileKey +"\"; filename=\"" + fileName + "\"\r\n";
+    part += "Content-Type: " + mimeType + "\r\n\r\n";
+    part += content + "\r\n";
+
+    for (QString key: params.keys()) {
+        part += "--" + boundary + "\r\n";
+        part += "Content-Disposition: form-data; name=\"" +  key + "\";\r\n\r\n";
+        part += params.find(key)->toString();
+        part += "\r\n";
+    }
+
+    part += QString("--") + boundary + "--" + "\r\n";
+
+    _reply = QSharedPointer<QNetworkReply>(_manager.post(request, QByteArray(part.toUtf8())));
+
+    _reply->connect(_reply.data(), &QNetworkReply::finished, [this, content]() {
+        if (_reply->error() != QNetworkReply::NoError)
+            return;
+        int status = 200;
+        QVariant statusCode = _reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
+
+        if (statusCode.isValid()) {
+            status = statusCode.toInt();
+        }
+
+        QVariantMap map;
+        map.insert("responseCode", status);
+        map.insert("response", QString(_reply->readAll()));
+        map.insert("bytesSent", content.size());
+        _plugin->cb(_scId, map);
+        emit done();
+    });
+    _reply->connect(_reply.data(), SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(error(QNetworkReply::NetworkError)));
+    _reply->connect(_reply.data(), SIGNAL(uploadProgress(qint64, qint64)), this, SLOT(progress(qint64, qint64)));
+}
+
+void FileTransferRequest::abort() {
+    QVariantMap map;
+    map.insert("code", ABORT_ERR);
+    _plugin->cb(_ecId, map);
+    _scId = 0;
+    emit done();
+}
+
+void FileTransferRequest::error(QNetworkReply::NetworkError code) {
+    Q_UNUSED(code);
+
+    int status = 404;
+    QVariant statusCode = _reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
+
+    if (statusCode.isValid()) {
+        status = statusCode.toInt();
+    }
+
+    QVariantMap map;
+    map.insert("http_status", status);
+    map.insert("body", QString(_reply->readAll()));
+    map.insert("code", CONNECTION_ERR);
+    _plugin->cb(_ecId, map);
+    emit done();
+}
+
+void FileTransferRequest::progress(qint64 bytesReceived, qint64 bytesTotal) {
+    QVariantMap map;
+    map.insert("lengthComputable", true);
+    map.insert("total", bytesTotal);
+    map.insert("loaded", bytesReceived);
+
+    if (bytesReceived && bytesTotal && _scId)
+        _plugin->callbackWithoutRemove(_scId, CordovaInternal::format(map));
+}

=== added file 'build/src/plugins/org.apache.cordova.file-transfer/file-transfer.h'
--- build/src/plugins/org.apache.cordova.file-transfer/file-transfer.h	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.file-transfer/file-transfer.h	2014-02-19 16:53:58 +0000
@@ -0,0 +1,97 @@
+/*
+ *
+ * Copyright 2013 Canonical Ltd.
+ *
+ * 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.
+ *
+*/
+
+#ifndef FILE_TRANSFER_H_SDASDASDAS
+#define FILE_TRANSFER_H_SDASDASDAS
+
+#include <QtCore>
+#include <QtNetwork>
+
+#include <cplugin.h>
+
+class FileTransferRequest: public QObject {
+    Q_OBJECT
+
+    QNetworkAccessManager &_manager;
+    int _scId, _ecId;
+    int _id;
+    QSharedPointer<QNetworkReply> _reply;
+
+    enum FileTransferError {
+        FILE_NOT_FOUND_ERR = 1,
+        INVALID_URL_ERR = 2,
+        CONNECTION_ERR = 3,
+        ABORT_ERR = 4
+    };
+
+public:
+    FileTransferRequest(QNetworkAccessManager &manager, int scId, int ecId, int id, CPlugin *plugin):
+        _manager(manager),
+        _scId(scId),
+        _ecId(ecId),
+        _id(id),
+        _plugin(plugin) {
+    }
+
+    void download(const QString& url, const QString &target);
+    void upload(const QString& _url, const QString& filePath, QString fileKey, QString fileName, QString mimeType, const QVariantMap &params, const QVariantMap &headers);
+    void abort();
+
+signals:
+    void done();
+
+private slots:
+    void progress(qint64 bytesReceived, qint64 bytesTotal);
+    void error(QNetworkReply::NetworkError code);
+private:
+    CPlugin *_plugin;
+    Q_DISABLE_COPY(FileTransferRequest);
+};
+
+class FileTransfer : public CPlugin {
+    Q_OBJECT
+public:
+    explicit FileTransfer(Cordova *cordova): CPlugin(cordova) {
+    }
+
+    virtual const QString fullName() override {
+        return FileTransfer::fullID();
+    }
+
+    virtual const QString shortName() override {
+        return "FileTransfer";
+    }
+
+    static const QString fullID() {
+        return "FileTransfer";
+    }
+
+public slots:
+    void abort(int scId, int ecId, int id);
+    void download(int scId, int ecId, const QString& url, const QString &target, bool /*trustAllHost*/, int id, const QVariantMap &/*headers*/);
+    void upload(int scId, int ecId, const QString &filePath, const QString& url, const QString& fileKey, const QString& fileName, const QString& mimeType,
+                const QVariantMap & params, bool /*trustAllHosts*/, bool /*chunkedMode*/, const QVariantMap &headers, int id, const QString &httpMethod);
+
+private:
+    QNetworkAccessManager _manager;
+    QMultiMap<int, QSharedPointer<FileTransferRequest> > _id2request;
+    int lastRequestId;
+};
+
+#endif

=== added file 'build/src/plugins/org.apache.cordova.file/file.cpp'
--- build/src/plugins/org.apache.cordova.file/file.cpp	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.file/file.cpp	2014-02-19 16:53:58 +0000
@@ -0,0 +1,773 @@
+/*
+ *  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.
+ */
+
+#include "file.h"
+
+#include <QApplication>
+
+namespace {
+    class FileError {
+    public:
+        static const QString kEncodingErr;
+        static const QString kTypeMismatchErr;
+        static const QString kNotFoundErr;
+        static const QString kSecurityErr;
+        static const QString kAbortErr;
+        static const QString kNotReadableErr;
+        static const QString kNoModificationAllowedErr;
+        static const QString kInvalidStateErr;
+        static const QString kSyntaxErr;
+        static const QString kInvalidModificationErr;
+        static const QString kQuotaExceededErr;
+        static const QString kPathExistsErr;
+    };
+
+    QVariantMap file2map(const QFileInfo &fileInfo) {
+        QVariantMap res;
+
+        res.insert("name", fileInfo.fileName());
+        res.insert("fullPath", fileInfo.isDir() ? QDir::cleanPath(fileInfo.absoluteFilePath()) : fileInfo.absoluteFilePath());
+        res.insert("isDirectory", (int)fileInfo.isDir());
+        res.insert("isFile", (int)fileInfo.isFile());
+
+        return res;
+    }
+    QVariantMap dir2map(const QDir &dir) {
+        return file2map(QFileInfo(dir.absolutePath()));
+    }
+};
+
+const QString FileError::kEncodingErr("FileError.ENCODING_ERR");
+const QString FileError::kTypeMismatchErr("FileError.TYPE_MISMATCH_ERR");
+const QString FileError::kNotFoundErr("FileError.NOT_FOUND_ERR");
+const QString FileError::kSecurityErr("FileError.SECURITY_ERR");
+const QString FileError::kAbortErr("FileError.ABORT_ERR");
+const QString FileError::kNotReadableErr("FileError.NOT_READABLE_ERR");
+const QString FileError::kNoModificationAllowedErr("FileError.NO_MODIFICATION_ALLOWED_ERR");
+const QString FileError::kInvalidStateErr("FileError.INVALID_STATE_ERR");
+const QString FileError::kSyntaxErr("FileError.SYNTAX_ERR");
+const QString FileError::kInvalidModificationErr("FileError.INVALID_MODIFICATION_ERR");
+const QString FileError::kQuotaExceededErr("FileError.QUOTA_EXCEEDED_ERR");
+const QString FileError::kPathExistsErr("FileError.PATH_EXISTS_ERR");
+
+File::File(Cordova *cordova) :
+    CPlugin(cordova),
+    _persistentDir(QString("%1/.local/share/%2/persistent").arg(QDir::homePath()).arg(QCoreApplication::applicationName())) {
+    QDir::root().mkpath(QDir(_persistentDir).absolutePath());
+}
+
+void File::requestFileSystem(int scId, int ecId, unsigned short type, unsigned long long size) {
+    QDir dir;
+
+    //FIXEME,what is quota value
+    if (size >= 10000){
+        this->callback(ecId, FileError::kQuotaExceededErr);
+        return;
+    }
+
+    if (type == 0)
+        dir = QDir::temp();
+    else
+        dir = QDir(_persistentDir);
+
+    if (type > 1) {
+        this->callback(ecId, FileError::kSyntaxErr);
+        return;
+    } else {
+        QVariantMap res;
+        res.insert("root", dir2map(dir));
+        if (type == 0)
+            res.insert("name", "temporary");
+        else
+            res.insert("name", "persistent");
+
+        this->cb(scId, res);
+    }
+}
+
+void File::resolveLocalFileSystemURI(int scId, int ecId, QString uri) {
+    QUrl url = QUrl::fromUserInput(uri);
+
+    if (!url.isValid() || uri[0] == '/' || uri[0] == '.') {
+        this->callback(ecId, FileError::kEncodingErr);
+        return;
+    }
+
+    if (url.scheme() != "file") {
+        this->callback(ecId, FileError::kTypeMismatchErr);
+        return;
+    }
+
+    QFileInfo fileInfo(url.path());
+
+    if (!fileInfo.exists()) {
+        this->callback(ecId, FileError::kNotFoundErr);
+        return;
+    }
+
+    this->cb(scId, file2map(fileInfo));
+}
+
+void File::getFile(int scId, int ecId, const QString &parentPath, const QString &rpath, const QVariantMap &options) {
+    QString path(rpath);
+
+    if (rpath[0] != '/') {
+        if (!parentPath.size() || !QFileInfo(parentPath).isDir())
+            path = _persistentDir + "/" + rpath;
+        else
+            path = parentPath + "/" + rpath;
+    }
+
+    //NOTE: colon is not safe in url, it is not a valid path in Win and Mac, simple disable it here.
+    if (path.contains(":")){
+        this->callback(ecId, FileError::kEncodingErr);
+        return;
+    }
+
+    QUrl url = QUrl::fromUserInput(path);
+    if (!url.isValid()) {
+        this->callback(ecId, FileError::kEncodingErr);
+        return;
+    }
+
+    if (url.scheme() != "file") {
+        this->callback(ecId, FileError::kTypeMismatchErr);
+        return;
+    }
+
+    bool create = options.value("create").toBool();
+    bool exclusive = options.value("exclusive").toBool();
+    QFile file(path);
+
+    // if create is false and the path represents a directory, return error
+    QFileInfo fileInfo(url.path());
+    if ((!create) && fileInfo.isDir()) {
+        this->callback(ecId, FileError::kTypeMismatchErr);
+        return;
+    }
+
+    // if file does exist, and create is true and exclusive is true, return error
+    if (file.exists()) {
+        if (create && exclusive) {
+            this->callback(ecId, FileError::kPathExistsErr);
+            return;
+        }
+    }
+    else {
+        // if file does not exist and create is false, return error
+        if (!create) {
+            this->callback(ecId, FileError::kNotFoundErr);
+            return;
+        }
+
+        file.open(QIODevice::WriteOnly);
+        file.close();
+
+        // Check if creation was successfull
+        if (!file.exists()) {
+            this->callback(ecId, FileError::kNoModificationAllowedErr);
+            return;
+        }
+    }
+
+    this->cb(scId, file2map(QFileInfo(file)));
+}
+
+void File::getDirectory(int scId, int ecId, QString parentPath, QString rpath, QVariantMap options) {
+    QString path(rpath);
+    if (rpath[0] != '/') {
+        path = parentPath + "/" + rpath;
+    }
+
+    //NOTE: colon is not safe in url, it is not a valid path in Win and Mac, simple disable it here.
+    if (path.contains(":")){
+        this->callback(ecId, FileError::kEncodingErr);
+        return;
+    }
+
+    QUrl url = QUrl::fromUserInput(path);
+    if (!url.isValid()) {
+        this->callback(ecId, FileError::kEncodingErr);
+        return;
+    }
+
+    if (url.scheme() != "file") {
+        this->callback(ecId, FileError::kTypeMismatchErr);
+        return;
+    }
+
+    bool create = options.value("create").toBool();
+    bool exclusive = options.value("exclusive").toBool();
+    QDir dir(path);
+
+    //  if create is false and the path represents a file, return error
+    QFileInfo fileInfo(url.path());
+    if ((!create) && fileInfo.isFile()) {
+        this->callback(ecId, FileError::kTypeMismatchErr);
+        return;
+    }
+
+    //  if directory does exist and create is true and exclusive is true, return error
+    if (dir.exists()) {
+        if (create && exclusive) {
+            this->callback(ecId, FileError::kPathExistsErr);
+            return;
+        }
+    }
+    else {
+        //  if directory does not exist and create is false and directory does not exist, return error
+        if (!create) {
+            this->callback(ecId, FileError::kNotFoundErr);
+            return;
+        }
+
+        //  if directory does not exist and create is false and directory does not exist, return error
+        QString folderName = dir.dirName();
+        dir.cdUp();
+        dir.mkdir(folderName);
+        dir.cd(folderName);
+
+        if (!dir.exists()) {
+            this->callback(ecId, FileError::kNoModificationAllowedErr);
+            return;
+        }
+    }
+
+    QVariantMap res;
+    res.insert("name", dir.dirName());
+    res.insert("fullPath", dir.absolutePath());
+    this->cb(scId, res);
+}
+
+void File::removeRecursively(int scId, int ecId, QString path) {
+    QDir dir(path);
+    if (File::rmDir(dir))
+        this->cb(scId);
+    else
+        this->callback(ecId, FileError::kNoModificationAllowedErr);
+}
+
+void File::write(int scId, int ecId, const QString &path, const QString &_data, unsigned long long position, bool binary) {
+    QFile file(path);
+
+    file.open(QIODevice::WriteOnly);
+    file.close();
+
+    if (!file.exists()) {
+        this->callback(ecId, FileError::kNotFoundErr);
+        return;
+    }
+
+    QFileInfo fileInfo(file);
+    if (!file.open(QIODevice::ReadWrite)) {
+        this->callback(ecId, FileError::kNoModificationAllowedErr);
+        return;
+    }
+
+    if (!binary) {
+        QTextStream textStream(&file);
+        textStream.setCodec("UTF-8");
+        textStream.setAutoDetectUnicode(true);
+
+        if (!textStream.seek(position)) {
+            file.close();
+            fileInfo.refresh();
+
+            this->callback(ecId, FileError::kInvalidModificationErr);
+            return;
+        }
+
+        textStream << _data;
+        textStream.flush();
+    } else {
+        QByteArray data(_data.toUtf8());
+        if (!file.seek(position)) {
+            file.close();
+            fileInfo.refresh();
+
+            this->callback(ecId, FileError::kInvalidModificationErr);
+            return;
+        }
+
+        file.write(data.data(), data.length());
+    }
+
+    file.flush();
+    file.close();
+    fileInfo.refresh();
+
+    this->cb(scId, fileInfo.size() - position);
+}
+
+void File::truncate(int scId, int ecId, const QString &path, unsigned long long size) {
+    QFile file(path);
+
+    if (!file.exists()) {
+        this->callback(ecId, FileError::kNotFoundErr);
+        return;
+    }
+
+    if (!file.resize(size)) {
+        this->callback(ecId, FileError::kNoModificationAllowedErr);
+        return;
+    }
+
+    this->cb(scId, size);
+}
+
+void File::getParent(int scId, int ecId, QString path) {
+    QDir dir(path);
+
+    //can't cdup more than app's root
+    // Try to change into upper directory
+    if (path != _persistentDir){
+        if (!dir.cdUp()) {
+            this->callback(ecId, FileError::kNotFoundErr);
+            return;
+        }
+
+    }
+    this->cb(scId, dir2map(dir));
+}
+
+void File::remove(int scId, int ecId, QString path) {
+    QFileInfo fileInfo(path);
+    if (!fileInfo.exists() || (path == _persistentDir)) {
+        this->callback(ecId, FileError::kNoModificationAllowedErr);
+        return;
+    }
+
+    if (fileInfo.isDir()) {
+        QDir dir(path);
+        if (dir.rmdir(dir.absolutePath())) {
+            this->cb(scId);
+            return;
+        }
+    } else {
+        QFile file(path);
+        if (file.remove()) {
+            this->cb(scId);
+            return;
+        }
+    }
+
+    this->callback(ecId, FileError::kInvalidModificationErr);
+}
+
+void File::getFileMetadata(int scId, int ecId, const QString &path) {
+    QFileInfo fileInfo(path);
+
+    if (!fileInfo.exists()) {
+        this->callback(ecId, FileError::kNotFoundErr);
+    } else {
+        QMimeType mime = _db.mimeTypeForFile(fileInfo.fileName());
+
+        QString args = QString("{name: %1, fullPath: %2, type: %3, lastModifiedDate: new Date(%4), size: %5}")
+            .arg(CordovaInternal::format(fileInfo.fileName())).arg(CordovaInternal::format(fileInfo.absoluteFilePath()))
+            .arg(CordovaInternal::format(mime.name())).arg(fileInfo.lastModified().toMSecsSinceEpoch())
+            .arg(fileInfo.size());
+
+        this->callback(scId, args);
+    }
+}
+
+void File::getMetadata(int scId, int ecId, const QString &path) {
+    QFileInfo fileInfo(path);
+
+    if (!fileInfo.exists())
+        this->callback(ecId, FileError::kNotFoundErr);
+    else
+        this->cb(scId, fileInfo.lastModified().toMSecsSinceEpoch());
+}
+
+void File::readEntries(int scId, int ecId, QString path) {
+    QDir dir(path);
+    QString entriesList;
+
+    if (!dir.exists()) {
+        this->callback(ecId, FileError::kNotFoundErr);
+        return;
+    }
+
+    for (const QFileInfo &fileInfo: dir.entryInfoList(QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot)) {
+        entriesList += CordovaInternal::format(file2map(fileInfo)) + ",";
+    }
+
+    // Remove trailing comma
+    if (entriesList.size() > 0)
+        entriesList.remove(entriesList.size()-1, 1);
+    entriesList = "new Array(" + entriesList + ")";
+
+    this->callback(scId, entriesList);
+}
+
+void File::readAsText(int scId, int ecId, const QString &path, const QString &encoding, int sliceStart, int sliceEnd) {
+    QFile file(path);
+
+    if (!file.exists()) {
+        this->callback(ecId, FileError::kNotFoundErr);
+        return;
+    }
+
+    if (!file.open(QIODevice::ReadOnly)) {
+        this->callback(ecId, FileError::kNotReadableErr);
+        return;
+    }
+
+    QByteArray content = file.readAll();
+
+    if (sliceEnd == -1)
+        sliceEnd = content.size();
+    if (sliceEnd < 0) {
+        sliceEnd++;
+        sliceEnd = std::max(0, content.size() + sliceEnd);
+    }
+    if (sliceEnd > content.size())
+        sliceEnd = content.size();
+
+    if (sliceStart < 0)
+        sliceStart = std::max(0, content.size() + sliceStart);
+    if (sliceStart > content.size())
+        sliceStart = content.size();
+
+    if (sliceStart > sliceEnd)
+        sliceEnd = sliceStart;
+
+    //FIXME: encoding
+    content = content.mid(sliceStart, sliceEnd - sliceStart);
+
+    this->cb(scId, content);
+}
+
+void File::readAsArrayBuffer(int scId, int ecId, const QString &path, int sliceStart, int sliceEnd) {
+    const QString str2array("\
+    (function strToArray(str) {                 \
+        var res = new Uint8Array(str.length);   \
+        for (var i = 0; i < str.length; i++) {  \
+            res[i] = str.charCodeAt(i);         \
+        }                                       \
+        return res;                             \
+    })(\"%1\")");
+    QFile file(path);
+
+    if (!file.exists()) {
+        this->callback(ecId, FileError::kNotFoundErr);
+        return;
+    }
+
+    if (!file.open(QIODevice::ReadOnly)) {
+        this->callback(ecId, FileError::kNotReadableErr);
+        return;
+    }
+    QString res;
+    QByteArray content = file.readAll();
+
+    if (sliceEnd == -1)
+        sliceEnd = content.size();
+    if (sliceEnd < 0) {
+        sliceEnd++;
+        sliceEnd = std::max(0, content.size() + sliceEnd);
+    }
+    if (sliceEnd > content.size())
+        sliceEnd = content.size();
+
+    if (sliceStart < 0)
+        sliceStart = std::max(0, content.size() + sliceStart);
+    if (sliceStart > content.size())
+        sliceStart = content.size();
+
+    if (sliceStart > sliceEnd)
+        sliceEnd = sliceStart;
+
+    content = content.mid(sliceStart, sliceEnd - sliceStart);
+
+    res.reserve(content.length() * 6);
+    for (uchar c: content) {
+        res += "\\x";
+        res += QString::number(c, 16).rightJustified(2, '0').toUpper();
+    }
+
+    this->callback(scId, str2array.arg(res));
+}
+
+void File::readAsBinaryString(int scId, int ecId, const QString &path, int sliceStart, int sliceEnd) {
+    QFile file(path);
+
+    if (!file.exists()) {
+        this->callback(ecId, FileError::kNotFoundErr);
+        return;
+    }
+
+    if (!file.open(QIODevice::ReadOnly)) {
+        this->callback(ecId, FileError::kNotReadableErr);
+        return;
+    }
+    QString res;
+    QByteArray content = file.readAll();
+
+    if (sliceEnd == -1)
+        sliceEnd = content.size();
+    if (sliceEnd < 0) {
+        sliceEnd++;
+        sliceEnd = std::max(0, content.size() + sliceEnd);
+    }
+    if (sliceEnd > content.size())
+        sliceEnd = content.size();
+
+    if (sliceStart < 0)
+        sliceStart = std::max(0, content.size() + sliceStart);
+    if (sliceStart > content.size())
+        sliceStart = content.size();
+
+    if (sliceStart > sliceEnd)
+        sliceEnd = sliceStart;
+
+    content = content.mid(sliceStart, sliceEnd - sliceStart);
+
+    res.reserve(content.length() * 6);
+    for (uchar c: content) {
+        res += "\\x";
+        res += QString::number(c, 16).rightJustified(2, '0').toUpper();
+    }
+    this->callback(scId, "\"" + res + "\"");
+}
+
+void File::readAsDataURL(int scId, int ecId, const QString &path, int sliceStart, int sliceEnd) {
+    QFile file(path);
+    QFileInfo fileInfo(path);
+
+    if (path.startsWith("content:")){
+        this->callback(ecId, FileError::kNotReadableErr);
+        return;
+    }
+
+    if (!file.exists()) {
+        this->callback(ecId, FileError::kNotReadableErr);
+        return;
+    }
+    // Try to open file for reading
+    if (!file.open(QIODevice::ReadOnly)) {
+        this->callback(ecId, FileError::kNotReadableErr);
+        return;
+    }
+    // Read the file content
+    QByteArray content = file.readAll();
+    QString contentType(_db.mimeTypeForFile(fileInfo.fileName()).name());
+
+    if (sliceEnd == -1)
+        sliceEnd = content.size();
+    if (sliceEnd < 0) {
+        sliceEnd++;
+        sliceEnd = std::max(0, content.size() + sliceEnd);
+    }
+    if (sliceEnd > content.size())
+        sliceEnd = content.size();
+
+    if (sliceStart < 0)
+        sliceStart = std::max(0, content.size() + sliceStart);
+    if (sliceStart > content.size())
+        sliceStart = content.size();
+
+    if (sliceStart > sliceEnd)
+        sliceEnd = sliceStart;
+
+    content = content.mid(sliceStart, sliceEnd - sliceStart);
+
+    this->cb(scId, QString("data:%1;base64,").arg(contentType) + content.toBase64());
+}
+
+bool File::rmDir(QDir dir) {
+    if (dir == _persistentDir) {//can't remove root dir
+        return false;
+    }
+    bool result = true;
+    if (dir.exists()) {
+        // Iterate over entries and remove them
+        Q_FOREACH(const QFileInfo &fileInfo, dir.entryInfoList(QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot)) {
+            if (fileInfo.isDir()) {
+                result = rmDir(fileInfo.absoluteFilePath());
+            }
+            else {
+                result = QFile::remove(fileInfo.absoluteFilePath());
+            }
+
+            if (!result) {
+                return result;
+            }
+        }
+
+        // Finally remove the current dir
+        return dir.rmdir(dir.absolutePath());
+    }
+    return result;
+}
+
+bool File::copyFile(int scId, int ecId,const QString& sourceFile, const QString& destinationParentDir, const QString& newName) {
+    if (!QDir(destinationParentDir).exists()){
+        this->callback(ecId, FileError::kNotFoundErr);
+        return false;
+    }
+
+    QFileInfo fileInfo(sourceFile);
+    QString fileName = ((newName.isEmpty()) ? fileInfo.fileName() : newName);
+    QString destinationFile(destinationParentDir + "/" + fileName);
+
+    //NOTE: colon is not safe in url, it is not a valid path in Win and Mac, simple disable it here.
+    if (!QUrl::fromUserInput(destinationFile).isValid() || destinationFile.contains(":")){
+        this->callback(ecId, FileError::kEncodingErr);
+        return false;
+    }
+
+    if (QFile::copy(sourceFile, destinationFile)){
+        this->cb(scId, file2map(QFileInfo(destinationFile)));
+        return true;
+    } else {
+        this->callback(ecId, FileError::kInvalidModificationErr);
+        return false;
+    }
+}
+
+void File::copyDir(int scId, int ecId,const QString& sourceFolder, const QString& destinationParentDir, const QString& newName) {
+    QDir sourceDir(sourceFolder);
+    QString dirName = ((newName.isEmpty()) ? sourceDir.dirName() : newName);
+    QString destFolder(destinationParentDir + "/" + dirName);
+
+    if (QFileInfo(destFolder).isFile()){
+        this->callback(ecId, FileError::kInvalidModificationErr);
+        return;
+    }
+    QDir destDir(destFolder);
+
+    if ((sourceFolder == destFolder) || (sourceFolder == destinationParentDir)){
+        this->callback(ecId, FileError::kInvalidModificationErr);
+        return;
+    }
+
+    if (!destDir.exists()){
+        destDir.mkdir(destFolder);;
+    } else{
+        this->callback(ecId, FileError::kInvalidModificationErr);
+        return;
+    }
+
+    if (copyFolder(sourceFolder, destFolder)){
+        this->cb(scId, dir2map(destDir));
+        return;
+    } else {
+        this->callback(ecId, FileError::kInvalidModificationErr);
+        return;
+    }
+}
+
+void File::copyTo(int scId, int ecId, const QString& source, const QString& destinationDir, const QString& newName) {
+    if (QFileInfo(source).isDir())
+        copyDir(scId, ecId, source, destinationDir, newName);
+    else
+        copyFile(scId, ecId, source, destinationDir, newName);
+}
+
+void File::moveFile(int scId, int ecId,const QString& sourceFile, const QString& destinationParentDir, const QString& newName) {
+    QString fileName = ((newName.isEmpty()) ? QFileInfo(sourceFile).fileName() : newName);
+    QString destinationFile(destinationParentDir + "/" + fileName);
+
+    if (QFileInfo(sourceFile) == QFileInfo(destinationFile)) {
+        this->callback(ecId, FileError::kInvalidModificationErr);
+        return;
+    }
+
+    if (!QFileInfo(destinationParentDir).exists()) {
+        this->callback(ecId, FileError::kNotFoundErr);
+        return;
+    }
+
+    if (QFileInfo(destinationFile).exists()) {
+        if (!QFile::remove(QFileInfo(destinationFile).absoluteFilePath())) {
+            this->callback(ecId, FileError::kInvalidModificationErr);
+            return;
+        }
+    }
+
+    QFile::rename(sourceFile, destinationFile);
+    this->cb(scId, file2map(QFileInfo(destinationFile)));
+}
+
+void File::moveDir(int scId, int ecId,const QString& sourceDir, const QString& destinationParentDir, const QString& newName){
+    QString dirName = ((newName.isEmpty()) ? QDir(sourceDir).dirName() : newName);
+    QString destFolder(destinationParentDir + "/" + dirName);
+    QDir destDir(destFolder);
+
+    if (!QFileInfo(destinationParentDir).exists()){
+        this->callback(ecId, FileError::kNotFoundErr);
+        return;
+    }
+
+    if (QFileInfo(destFolder).isFile()){
+        this->callback(ecId, FileError::kInvalidModificationErr);
+        return;
+    }
+
+    if ((QFileInfo(sourceDir) == QFileInfo(destFolder)) || (QFileInfo(sourceDir) == QFileInfo(destinationParentDir))) {
+        this->callback(ecId, FileError::kInvalidModificationErr);
+        return;
+    }
+
+    if (destDir.exists() && !QDir(destinationParentDir).rmdir(dirName)) {
+        this->callback(ecId, FileError::kInvalidModificationErr);
+        return;
+    }
+
+    if (copyFolder(sourceDir, destFolder)) {
+        rmDir(sourceDir);
+        this->cb(scId, file2map(QFileInfo(destFolder)));
+    } else {
+        this->callback(ecId, FileError::kNoModificationAllowedErr);
+    }
+}
+
+void File::moveTo(int scId, int ecId, const QString& source, const QString& destinationDir, const QString& newName) {
+    if (newName.contains(":")) {
+        this->callback(ecId, FileError::kEncodingErr);
+        return;
+    }
+    if (QFileInfo(source).isDir())
+        moveDir(scId, ecId, source, destinationDir, newName);
+    else
+        moveFile(scId, ecId, source, destinationDir, newName);
+}
+
+bool File::copyFolder(const QString& sourceFolder, const QString& destFolder) {
+    QDir sourceDir(sourceFolder);
+    if (!sourceDir.exists())
+        return false;
+    QDir destDir(destFolder);
+    if (!destDir.exists()){
+        destDir.mkdir(destFolder);
+    }
+    QStringList files = sourceDir.entryList(QDir::Files);
+    for (int i = 0; i< files.count(); i++)
+    {
+        QString srcName = sourceFolder + "/" + files[i];
+        QString destName = destFolder + "/" + files[i];
+        QFile::copy(srcName, destName);
+    }
+    files.clear();
+    files = sourceDir.entryList(QDir::AllDirs | QDir::NoDotAndDotDot);
+    for (int i = 0; i< files.count(); i++)
+    {
+        QString srcName = sourceFolder + "/" + files[i];
+        QString destName = destFolder + "/" + files[i];
+        copyFolder(srcName, destName);
+    }
+    return true;
+}

=== added file 'build/src/plugins/org.apache.cordova.file/file.h'
--- build/src/plugins/org.apache.cordova.file/file.h	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.file/file.h	2014-02-19 16:53:58 +0000
@@ -0,0 +1,73 @@
+/*
+ *  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.
+ */
+
+#ifndef FILEAPI_H_SDASDASDAS
+#define FILEAPI_H_SDASDASDAS
+
+#include <QNetworkReply>
+#include <QtCore>
+
+#include <cplugin.h>
+#include <cordova.h>
+
+class File: public CPlugin {
+    Q_OBJECT
+public:
+    explicit File(Cordova *cordova);
+
+    virtual const QString fullName() override {
+        return File::fullID();
+    }
+
+    virtual const QString shortName() override {
+        return "File";
+    }
+
+    static const QString fullID() {
+        return "File";
+    }
+
+public slots:
+    void requestFileSystem(int scId, int ecId, unsigned short type, unsigned long long size);
+    void resolveLocalFileSystemURI(int scId, int ecId, QString uri);
+    void getDirectory(int scId, int ecId, QString parentPath, QString path, QVariantMap options);
+    void getFile(int scId, int ecId, const QString &parentPath, const QString &rpath, const QVariantMap &options);
+    void readEntries(int scId, int ecId, QString path);
+    void getParent(int scId, int ecId, QString path);
+    void copyTo(int scId, int ecId, const QString& source, const QString& destinationDir, const QString& newName);
+    void moveTo(int scId, int ecId, const QString& source, const QString& destinationDir, const QString& newName);
+    void getFileMetadata(int scId, int ecId, const QString &path);
+    void getMetadata(int scId, int ecId, const QString &path);
+    void remove(int scId, int ecId, QString path);
+    void removeRecursively(int scId, int ecId, QString path);
+    void readAsText(int scId, int ecId, const QString &path, const QString &encoding, int sliceStart, int sliceEnd);
+    void write(int scId, int ecId, const QString &path, const QString &_data, unsigned long long position, bool binary);
+    void readAsDataURL(int scId, int ecId, const QString &path, int sliceStart, int sliceEnd);
+    void readAsArrayBuffer(int scId, int ecId, const QString &path, int sliceStart, int sliceEnd);
+    void readAsBinaryString(int scId, int ecId, const QString &path, int sliceStart, int sliceEnd);
+    void truncate(int scId, int ecId, const QString &path, unsigned long long size);
+private:
+    void moveFile(int scId, int ecId,const QString& sourceFile, const QString& destinationParentDir, const QString& newName);
+    void moveDir(int scId, int ecId,const QString& sourceFolder, const QString& destFolder, const QString& newName);
+    bool copyFile(int scId, int ecId, const QString& sourceFile, const QString& destinationParentDir, const QString& newName);
+    void copyDir(int scId, int ecId, const QString& sourceFolder, const QString& destFolder, const QString& newName);
+    bool rmDir(QDir dir);
+    bool copyFolder(const QString& sourceFolder, const QString& destFolder);
+
+    QMimeDatabase _db;
+    const QString _persistentDir;
+    QNetworkAccessManager _manager;
+};
+
+#endif

=== added directory 'build/src/plugins/org.apache.cordova.geolocation'
=== added file 'build/src/plugins/org.apache.cordova.geolocation/geolocation.cpp'
--- build/src/plugins/org.apache.cordova.geolocation/geolocation.cpp	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.geolocation/geolocation.cpp	2014-02-19 16:53:58 +0000
@@ -0,0 +1,119 @@
+/*
+ *
+ * Copyright 2013 Canonical Ltd.
+ *
+ * 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.
+ *
+*/
+
+#include <QUuid>
+
+#include "geolocation.h"
+
+Geolocation::Geolocation(Cordova *cordova): CPlugin(cordova),
+                                            _geoPositionInfoSource(QGeoPositionInfoSource::createDefaultSource(this)) {
+    if (_geoPositionInfoSource.data() != 0) {
+        QObject::connect(_geoPositionInfoSource.data(), SIGNAL(positionUpdated(QGeoPositionInfo)), this, SLOT(positionUpdated(QGeoPositionInfo)));
+        QObject::connect(_geoPositionInfoSource.data(), SIGNAL(updateTimeout()), this, SLOT(updateTimeout()));
+    }
+}
+
+void Geolocation::addWatch(int scId, int ecId, const QString &id, bool enableHighAccuracy) {
+    Q_UNUSED(enableHighAccuracy);
+
+    assert(_id2sc.find(id) == _id2sc.end());
+
+    if (!_geoPositionInfoSource.data()) {
+        QVariantMap err;
+        err.insert("code", POSITION_UNAVAILABLE);
+        err.insert("message", "unavailable");
+
+        this->cb(ecId, err);
+        return;
+    }
+
+    _id2sc[id] = scId;
+    _id2ec[id] = ecId;
+}
+
+void Geolocation::clearWatch(int scId, int ecId, const QString &id) {
+    _id2sc.remove(id);
+    _id2ec.remove(id);
+}
+
+void Geolocation::getLocation(int scId, int ecId, bool enableHighAccuracy, qint64 maximumAge) {
+    Q_UNUSED(maximumAge);
+    Q_UNUSED(enableHighAccuracy);
+
+    if (!_geoPositionInfoSource.data()) {
+        QVariantMap err;
+        err.insert("code", POSITION_UNAVAILABLE);
+        err.insert("message", "unavailable");
+
+        this->cb(ecId, err);
+        return;
+    }
+
+    _geoPositionInfoSource->requestUpdate();
+
+    QString id = QString("_INTERNAL_") + QUuid::createUuid().toString();
+
+    _id2sc[id] = scId;
+    _id2ec[id] = ecId;
+    _singleUpdate.insert(id);
+}
+
+void Geolocation::positionUpdated(const QGeoPositionInfo &update) {
+    QGeoCoordinate coordinate = update.coordinate();
+
+    QVariantMap p;
+
+    p.insert("latitude", coordinate.latitude());
+    p.insert("longitude", coordinate.longitude());
+    p.insert("altitude", coordinate.altitude());
+
+    if (update.hasAttribute(QGeoPositionInfo::VerticalAccuracy))
+        p.insert("accuracy", update.attribute(QGeoPositionInfo::VerticalAccuracy));
+    if (update.hasAttribute(QGeoPositionInfo::Direction))
+        p.insert("heading", update.attribute(QGeoPositionInfo::Direction));
+    if (update.hasAttribute(QGeoPositionInfo::GroundSpeed))
+        p.insert("velocity", update.attribute(QGeoPositionInfo::GroundSpeed));
+    if (update.hasAttribute(QGeoPositionInfo::HorizontalAccuracy))
+        p.insert("altitudeAccuracy", update.attribute(QGeoPositionInfo::HorizontalAccuracy));
+    p.insert("timestamp", update.timestamp().toMSecsSinceEpoch());
+
+    for (const QString &id: _id2sc.keys()) {
+        int scId = _id2sc[id];
+        this->cb(scId, p);
+        if (_singleUpdate.contains(id)) {
+            _singleUpdate.remove(id);
+            _id2sc.remove(id);
+            _id2ec.remove(id);
+        }
+    }
+}
+
+void Geolocation::updateTimeout() {
+    QVariantMap err;
+    err.insert("code", TIMEOUT);
+    err.insert("message", "timeout");
+
+    for (int ecId: _id2ec) {
+        this->cb(ecId, err);
+    }
+
+    _id2ec.clear();
+    _id2sc.clear();
+    _singleUpdate.clear();
+}

=== added file 'build/src/plugins/org.apache.cordova.geolocation/geolocation.h'
--- build/src/plugins/org.apache.cordova.geolocation/geolocation.h	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.geolocation/geolocation.h	2014-02-19 16:53:58 +0000
@@ -0,0 +1,69 @@
+/*
+ *
+ * Copyright 2013 Canonical Ltd.
+ *
+ * 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.
+ *
+*/
+
+#ifndef GEOLOCATION_H_SVO2013
+#define GEOLOCATION_H_SVO2013
+
+#include <QGeoPositionInfoSource>
+#include <QGeoPositionInfo>
+#include <QtCore>
+#include <cassert>
+
+#include <cplugin.h>
+
+class Geolocation: public CPlugin {
+    Q_OBJECT
+public:
+    explicit Geolocation(Cordova *cordova);
+
+    virtual const QString fullName() override {
+        return Geolocation::fullID();
+    }
+
+    virtual const QString shortName() override {
+        return "Geolocation";
+    }
+
+    static const QString fullID() {
+        return "Geolocation";
+    }
+
+public slots:
+    void getLocation(int scId, int ecId, bool enableHighAccuracy, qint64 maximumAge);
+    void addWatch(int scId, int ecId, const QString &id, bool enableHighAccuracy);
+    void clearWatch(int scId, int ecId, const QString &id);
+
+protected slots:
+    void positionUpdated(const QGeoPositionInfo &update);
+    void updateTimeout();
+
+private:
+    QMap<QString, int> _id2sc;
+    QMap<QString, int> _id2ec;
+    QSet<QString> _singleUpdate;
+    QSharedPointer<QGeoPositionInfoSource> _geoPositionInfoSource;
+
+    enum PositionError {
+        PERMISSION_DENIED = 1,
+        POSITION_UNAVAILABLE = 2,
+        TIMEOUT = 3
+    };
+};
+
+#endif

=== added directory 'build/src/plugins/org.apache.cordova.globalization'
=== added file 'build/src/plugins/org.apache.cordova.globalization/globalization.cpp'
--- build/src/plugins/org.apache.cordova.globalization/globalization.cpp	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.globalization/globalization.cpp	2014-02-19 16:53:58 +0000
@@ -0,0 +1,342 @@
+/*
+ *
+ * Copyright 2013 Canonical Ltd.
+ *
+ * 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.
+ *
+*/
+
+#include <ctime> //TODO: switch to QTimeZone (QT 5.1)
+#include <unicode/decimfmt.h>
+#include <unicode/timezone.h>
+
+#include "globalization.h"
+
+Globalization::Globalization(Cordova *cordova):
+    CPlugin(cordova) {
+}
+
+void Globalization::getPreferredLanguage(int scId, int ecId) {
+    Q_UNUSED(ecId)
+
+    QLocale locale;
+    QString lang = QLocale::languageToString(locale.language());
+    QVariantMap obj;
+    obj.insert("value", lang);
+    this->cb(scId, obj);
+}
+
+void Globalization::getLocaleName(int scId, int ecId) {
+    Q_UNUSED(ecId)
+
+    QVariantMap obj;
+    obj.insert("value", QLocale().name());
+    this->cb(scId, obj);
+}
+
+void Globalization::getFirstDayOfWeek(int scId, int ecId) {
+    Q_UNUSED(ecId)
+
+    QLocale locale;
+
+    int res;
+    if (locale.firstDayOfWeek() == Qt::Sunday) {
+        res = 1;
+    } else {
+        res = (2 - Qt::Monday) + locale.firstDayOfWeek();
+    }
+
+    QVariantMap obj;
+    obj.insert("value", res);
+    this->cb(scId, obj);
+}
+
+void Globalization::isDayLightSavingsTime(int scId, int ecId, const QVariantMap &options) {
+    time_t time = options.find("time_t")->toLongLong() / 1000;
+    const tm *desc = std::localtime(&time);
+    if (desc->tm_isdst < 0) {
+        this->callback(ecId, QString("new GlobalizationError(%1, 'information is not available');").arg(Globalization::UNKNOWN_ERROR));
+        return;
+    }
+    this->callback(scId, QString("{dst:%1}").arg(desc->tm_isdst > 0 ? "true" : "false"));
+}
+
+QLocale::FormatType translateFormat(Globalization::Format formatLength) {
+    QLocale::FormatType format = QLocale::ShortFormat;
+    switch (formatLength) {
+    case Globalization::FORMAT_FULL:
+    case Globalization::FORMAT_LONG:
+        format = QLocale::ShortFormat; // TODO: Qt cant parse string produced with QLocale::LongFormat;
+        break;
+    case Globalization::FORMAT_MEDIUM:
+        format = QLocale::ShortFormat;
+        break;
+    case Globalization::FORMAT_SHORT:
+        format = QLocale::NarrowFormat;
+        break;
+    }
+    return format;
+}
+
+void Globalization::dateToString(int scId, int ecId, const QVariantMap &options) {
+    time_t time = options.find("time_t")->toLongLong() / 1000;
+
+    Globalization::Format formatLength = static_cast<Globalization::Format>(options.find("formatLength")->toInt());
+    Globalization::Selector selector = static_cast<Globalization::Selector>(options.find("selector")->toInt());
+
+    QLocale::FormatType format = translateFormat(formatLength);
+    if (time < 0) {
+        this->callback(ecId, QString("new GlobalizationError(%1, 'unsupported operation');").arg(Globalization::FORMATTING_ERROR));
+        return;
+    }
+
+    QLocale locale;
+    QString res;
+    QDateTime dateTime = QDateTime::fromTime_t((uint)time);
+    switch (selector) {
+    case SELECTOR_ALL:
+        res = locale.toString(dateTime,format);
+        break;
+    case SELECTOR_TIME:
+        res = locale.toString(dateTime.time(), format);
+        break;
+    case SELECTOR_DATE:
+        res = locale.toString(dateTime.date(), format);
+        break;
+    }
+    QVariantMap obj;
+    obj.insert("value", res);
+    this->cb(scId, obj);
+}
+
+void Globalization::stringToDate(int scId, int ecId, const QVariantMap &options) {
+    QString dateString = options.find("dateString")->toString();
+    Globalization::Format formatLength = static_cast<Globalization::Format>(options.find("formatLength")->toInt());
+    Globalization::Selector selector = static_cast<Globalization::Selector>(options.find("selector")->toInt());
+
+    QLocale::FormatType format = translateFormat(formatLength);
+    QLocale locale;
+    bool valid(true);
+    int year(0), month(0), day(0), hour(0), minute(0), second(0), millisecond(0);
+    switch (selector) {
+    case SELECTOR_ALL:
+        {
+            QDateTime dateTime = locale.toDateTime(dateString, format);
+            valid = dateTime.isValid();
+            QTime time = dateTime.time();
+            hour = time.hour(); minute = time.minute(); second = time.second(); millisecond = time.msec();
+            QDate date = dateTime.date();
+            year = date.year(); month = date.month(); day = date.day();
+        }
+        break;
+    case SELECTOR_TIME:
+        {
+            QTime time = locale.toTime(dateString, format);
+            valid = time.isValid();
+            hour = time.hour(); minute = time.minute(); second = time.second(); millisecond = time.msec();
+        }
+        break;
+    case SELECTOR_DATE:
+        {
+            QDate date = locale.toDate(dateString, format);
+            valid = date.isValid();
+            year = date.year(); month = date.month(); day = date.day();
+        }
+        break;
+    }
+    if ((format == QLocale::NarrowFormat || format == QLocale::ShortFormat) && year < 2000 && year > 1900) {
+        year += 100;
+    }
+    if (!valid) {
+        this->callback(ecId, QString("new GlobalizationError(%1, 'parsing error')").arg(Globalization::PARSING_ERROR));
+    } else {
+        QVariantMap obj;
+        obj.insert("year", year);
+        obj.insert("month", month - 1);
+        obj.insert("day", day);
+        obj.insert("hour", hour);
+        obj.insert("minute", minute);
+        obj.insert("second", second);
+        obj.insert("millisecond", millisecond);
+        this->cb(scId, obj);
+    }
+}
+
+void Globalization::getDateNames(int scId, int ecId, const QVariantMap &options) {
+    Q_UNUSED(ecId)
+
+    int type = options.find("type")->toInt();
+    int item = options.find("item")->toInt();
+
+    QLocale::FormatType format;
+    if (type == FORMAT_SHORT)
+        format = QLocale::ShortFormat;
+    else
+        format = QLocale::LongFormat;
+    QLocale locale;
+    QList<QString> res;
+    if (item == REQUEST_DAY_NAMES) {
+        for (int i = 1; i <= 7; i++) {
+            res.append(locale.dayName(i, format));
+        }
+    } else { //REQUEST_MONTH_NAMES
+        for (int i = 1; i <= 12; i++) {
+            res.append(locale.monthName(i, format));
+        }
+    }
+
+    QString result;
+    for (QList<QString>::iterator it = res.begin(); it != res.end(); it++) {
+        result += QString("'%1',").arg(*it);
+    }
+    this->callback(scId, QString("{ value: [ %1 ]}").arg(result));
+}
+
+template<class T>
+static QString format(T number, Globalization::NumberType type) {
+    QString res;
+    QLocale locale;
+    switch (type) {
+    case Globalization::DECIMAL:
+        res = locale.toString(number);
+        break;
+    case Globalization::PERCENT:
+        res = locale.toString(number) + locale.percent();
+        break;
+    case Globalization::CURRENCY:
+        res = locale.toCurrencyString(number);
+        break;
+    };
+    return res;
+}
+
+void Globalization::numberToString(int scId, int ecId, const QVariantMap &options) {
+    Q_UNUSED(ecId)
+
+    bool isInt = options.find("isInt")->toBool();
+    NumberType type = static_cast<NumberType>(options.find("type")->toBool());
+
+    QString res;
+    if (isInt) {
+        long long number = options.find("number")->toLongLong();
+        res = format(number, type);
+    } else {
+        double number = options.find("number")->toDouble();
+        res = format(number, type);
+    }
+    this->callback(scId, QString("{ value: '%1' }").arg(res));
+}
+
+void Globalization::stringToNumber(int scId, int ecId, int type, QString string) {
+    switch ((NumberType)type) {
+    case Globalization::DECIMAL:
+        string = string.remove(QLocale().groupSeparator());
+        break;
+    case Globalization::PERCENT:
+        string = string.remove(QLocale().percent()).remove(QLocale().groupSeparator());
+        break;
+    case Globalization::CURRENCY:
+        string = string.remove(QLocale().currencySymbol()).remove(QLocale().groupSeparator());
+        break;
+    };
+    bool ok;
+    double res = QLocale().toDouble(string, &ok);
+    if (ok)
+        this->callback(scId, QString("{ value: %1 }").arg(res));
+    else
+        this->callback(ecId, QString("new GlobalizationError(%1, 'parsing error')").arg(Globalization::PARSING_ERROR));
+}
+
+static QString ustr2qstr(UnicodeString &ustr) {
+    std::string res;
+    ustr.toUTF8String(res);
+
+    return QString(res.c_str());
+}
+
+void Globalization::getNumberPattern(int scId, int ecId, int type) {
+    Q_UNUSED(ecId);
+    UErrorCode status = U_ZERO_ERROR;
+    icu::DecimalFormat icu(status);
+
+    icu::UnicodeString pattern;
+    icu.toPattern(pattern);
+
+    QLocale locale;
+    QVariantMap obj;
+
+    obj.insert("pattern", ustr2qstr(pattern));
+
+    switch ((NumberType)type) {
+    case Globalization::DECIMAL:
+        obj.insert("symbol", "");
+        break;
+    case Globalization::PERCENT:
+        obj.insert("symbol", QString(locale.percent()));
+        break;
+    case Globalization::CURRENCY:
+        obj.insert("symbol", QString(locale.currencySymbol()));
+        break;
+    };
+
+    obj.insert("fraction", icu.getMaximumFractionDigits());
+    obj.insert("rounding", icu.getRoundingIncrement());
+    obj.insert("positive", QString(locale.positiveSign()));
+    obj.insert("negative", QString(locale.negativeSign()));
+    obj.insert("decimal", QString(locale.decimalPoint()));
+    obj.insert("grouping", QString(locale.groupSeparator()));
+
+    this->cb(scId, obj);
+}
+
+static bool inDayLightSavingsTime() {
+    time_t now;
+
+    time(&now);
+
+    const tm *desc = std::localtime(&now);
+
+    return desc->tm_isdst > 0;
+}
+
+void Globalization::getDatePattern(int scId, int ecId, int formatLength, int selector) {
+    Q_UNUSED(ecId);
+
+    QLocale locale;
+    QVariantMap res;
+    QLocale::FormatType format = translateFormat((Format)formatLength);
+
+    switch ((Selector)selector) {
+    case Selector::SELECTOR_TIME:
+        res.insert("pattern", locale.timeFormat(format));
+        break;
+    case Selector::SELECTOR_DATE:
+        res.insert("pattern", locale.dateFormat(format));
+        break;
+    case Selector::SELECTOR_ALL:
+        res.insert("pattern", locale.dateTimeFormat(format));
+        break;
+    };
+
+    UnicodeString result;
+    QSharedPointer<TimeZone> timezone = QSharedPointer<TimeZone>(TimeZone::createDefault());
+    timezone->getDisplayName(inDayLightSavingsTime(), TimeZone::SHORT, result);
+
+    res.insert("timezone", ustr2qstr(result));
+    res.insert("utc_offset", timezone->getRawOffset() / 1000 + timezone->getDSTSavings() / 1000);
+    res.insert("dst_offset", timezone->getDSTSavings() / 1000);
+
+    this->cb(scId, res);
+}
+

=== added file 'build/src/plugins/org.apache.cordova.globalization/globalization.h'
--- build/src/plugins/org.apache.cordova.globalization/globalization.h	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.globalization/globalization.h	2014-02-19 16:53:58 +0000
@@ -0,0 +1,93 @@
+/*
+ *
+ * Copyright 2013 Canonical Ltd.
+ *
+ * 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.
+ *
+*/
+#ifndef GLOBALIZATION_H_SVO2013
+#define GLOBALIZATION_H_SVO2013
+
+#include <QtCore>
+#include <QLocale>
+
+#include <cplugin.h>
+
+class Globalization: public CPlugin {
+    Q_OBJECT
+    enum GlobalizationError {
+        UNKNOWN_ERROR = 0,
+        FORMATTING_ERROR = 1,
+        PARSING_ERROR = 2,
+        PATTERN_ERROR = 3
+    };
+
+    enum Selector {
+        SELECTOR_DATE = 0,
+        SELECTOR_TIME = 1,
+        SELECTOR_ALL = 2
+    };
+
+    enum Format {
+        FORMAT_SHORT = 0,
+        FORMAT_MEDIUM = 1,
+        FORMAT_LONG = 2,
+        FORMAT_FULL = 3
+    };
+
+    enum {
+        REQUEST_DAY_NAMES = 0,
+        REQUEST_MONTH_NAMES = 1
+    };
+
+    enum NumberType {
+        DECIMAL,
+        PERCENT,
+        CURRENCY
+    };
+
+public:
+    explicit Globalization(Cordova *cordova);
+
+    virtual const QString fullName() override {
+        return Globalization::fullID();
+    }
+
+    virtual const QString shortName() override {
+        return "Globalization";
+    }
+
+    static const QString fullID() {
+        return "Globalization";
+    }
+
+public slots:
+    void getPreferredLanguage(int scId, int ecId);
+    void getLocaleName(int scId, int ecId);
+    void getFirstDayOfWeek(int scId, int ecId);
+    void isDayLightSavingsTime(int scId, int ecId, const QVariantMap &options);
+    void dateToString(int scId, int ecId, const QVariantMap &options);
+    void stringToDate(int scId, int ecId, const QVariantMap &options);
+
+    void getDateNames(int scId, int ecId, const QVariantMap &options);
+    void numberToString(int scId, int ecId, const QVariantMap &options);
+    void stringToNumber(int scId, int ecId, int type, QString string);
+    void getNumberPattern(int scId, int ecId, int type);
+    void getDatePattern(int scId, int ecId, int formatLength, int selector);
+private:
+    friend QLocale::FormatType translateFormat(Globalization::Format formatLength);
+    template<class T> friend QString format(T number, Globalization::NumberType type);
+};
+
+#endif

=== added directory 'build/src/plugins/org.apache.cordova.inappbrowser'
=== added file 'build/src/plugins/org.apache.cordova.inappbrowser/inappbrowser.cpp'
--- build/src/plugins/org.apache.cordova.inappbrowser/inappbrowser.cpp	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.inappbrowser/inappbrowser.cpp	2014-02-19 16:53:58 +0000
@@ -0,0 +1,106 @@
+/*
+ *
+ * Copyright 2013 Canonical Ltd.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+
+#include <QQuickView>
+#include <QQuickItem>
+
+#include "inappbrowser.h"
+#include <cordova.h>
+
+Inappbrowser::Inappbrowser(Cordova *cordova): CPlugin(cordova), _eventCb(0) {
+}
+
+const char code[] = "\
+var component, object;                                                  \
+function createObject() {                                               \
+    component = Qt.createComponent(%1);                                 \
+    if (component.status == Component.Ready)                            \
+        finishCreation();                                               \
+    else                                                                \
+        component.statusChanged.connect(finishCreation);                \
+}                                                                       \
+function finishCreation() {                                             \
+    CordovaWrapper.object = component.createObject(root,                \
+        {root: root, cordova: cordova, url1: %2});                      \
+}                                                                       \
+createObject()";
+
+const char EXIT_EVENT[] = "'exit'";
+const char LOADSTART_EVENT[] = "'loadstart'";
+const char LOADSTOP_EVENT[] = "'loadstop'";
+const char LOADERROR_EVENT[] = "'loaderror'";
+
+void Inappbrowser::open(int cb, int, const QString &url, const QString &windowName, const QString &windowFeatures) {
+    assert(_eventCb == 0);
+
+    _eventCb = cb;
+
+    QString path = m_cordova->get_app_dir() + "/../qml/InAppBrowser.qml";
+
+    // TODO: relative url
+    QString qml = QString(code)
+      .arg(CordovaInternal::format(path)).arg(CordovaInternal::format(url));
+    m_cordova->execQML(qml);
+}
+
+void Inappbrowser::show(int, int) {
+    m_cordova->execQML("CordovaWrapper.object.visible = true");
+}
+
+void Inappbrowser::close(int, int) {
+    m_cordova->execQML("CordovaWrapper.object.destroy()");
+    this->callbackWithoutRemove(_eventCb, EXIT_EVENT);
+    _eventCb = 0;
+}
+
+void Inappbrowser::injectStyleFile(int cb, int, const QString&, bool) {
+    // TODO:
+    qCritical() << "unimplemented " << __PRETTY_FUNCTION__;
+}
+
+void Inappbrowser::injectStyleCode(int cb, int, const QString&, bool) {
+    // TODO:
+    qCritical() << "unimplemented " << __PRETTY_FUNCTION__;
+}
+
+void Inappbrowser::injectScriptFile(int cb, int, const QString&, bool) {
+    // TODO:
+    qCritical() << "unimplemented " << __PRETTY_FUNCTION__;
+}
+
+void Inappbrowser::injectScriptCode(int cb, int, const QString&, bool) {
+    // TODO:
+    qCritical() << "unimplemented " << __PRETTY_FUNCTION__;
+}
+
+void Inappbrowser::loadFinished(int status) {
+    if (status == 2) {
+        this->callbackWithoutRemove(_eventCb, LOADERROR_EVENT);
+    }
+    if (status == 0) {
+        this->callbackWithoutRemove(_eventCb, LOADSTART_EVENT);
+    }
+    if (status == 3) {
+        this->callbackWithoutRemove(_eventCb, LOADSTOP_EVENT);
+    }
+}

=== added file 'build/src/plugins/org.apache.cordova.inappbrowser/inappbrowser.h'
--- build/src/plugins/org.apache.cordova.inappbrowser/inappbrowser.h	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.inappbrowser/inappbrowser.h	2014-02-19 16:53:58 +0000
@@ -0,0 +1,61 @@
+/*
+ *
+ * Copyright 2013 Canonical Ltd.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+#ifndef INAPPBROWSER_H
+#define INAPPBROWSER_H
+
+#include <QtCore>
+#include <cplugin.h>
+
+class Inappbrowser: public CPlugin {
+    Q_OBJECT
+public:
+    Inappbrowser(Cordova *cordova);
+
+    virtual const QString fullName() override {
+        return Inappbrowser::fullID();
+    }
+
+    virtual const QString shortName() override {
+        return "InAppBrowser";
+    }
+
+    static const QString fullID() {
+        return "InAppBrowser";
+    }
+
+public slots:
+    void open(int cb, int, const QString &url, const QString &windowName, const QString &windowFeatures);
+    void show(int, int);
+    void close(int, int);
+    void injectStyleFile(int cb, int, const QString&, bool);
+    void injectStyleCode(int cb, int, const QString&, bool);
+    void injectScriptFile(int cb, int, const QString&, bool);
+    void injectScriptCode(int cb, int, const QString&, bool);
+
+    void loadFinished(int status);
+
+private:
+    int _eventCb;
+};
+
+#endif

=== added directory 'build/src/plugins/org.apache.cordova.media'
=== added directory 'build/src/plugins/org.apache.cordova.media-capture'
=== added file 'build/src/plugins/org.apache.cordova.media-capture/capture.cpp'
--- build/src/plugins/org.apache.cordova.media-capture/capture.cpp	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.media-capture/capture.cpp	2014-02-19 16:53:58 +0000
@@ -0,0 +1,167 @@
+/*
+ *
+ * Copyright 2013 Canonical Ltd.
+ *
+ * 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.
+ *
+*/
+#include "capture.h"
+
+const char code[] = "\
+var component, object;                                                  \
+function createObject() {                                               \
+    component = Qt.createComponent(%1);                                 \
+    if (component.status == Component.Ready)                            \
+        finishCreation();                                               \
+    else                                                                \
+        component.statusChanged.connect(finishCreation);                \
+}                                                                       \
+function finishCreation() {                                             \
+    CordovaWrapper.captureObject = component.createObject(root,         \
+        {root: root, cordova: cordova, state: \"%2\"});                 \
+}                                                                       \
+createObject()";
+
+static QString formatFile(const QMimeDatabase &db, const QString &path) {
+    QFileInfo info(path);
+    QMimeType mime = db.mimeTypeForFile(info.fileName());
+
+    QVariantMap file;
+    file.insert("name", info.fileName());
+    file.insert("fullPath", info.absoluteFilePath());
+    file.insert("lastModifiedDate", info.lastModified().toMSecsSinceEpoch());
+    file.insert("size", info.size());
+    file.insert("type", mime.name());
+
+    return CordovaInternal::format(file);
+}
+
+MediaCapture::MediaCapture(Cordova *cordova): CPlugin(cordova), _scId(0), _ecId(0) {
+}
+
+void MediaCapture::captureAudio(int scId, int ecId, QVariantMap options) {
+    if (_scId || _ecId) {
+        this->callback(_ecId, QString("{code: %1}").arg(CAPTURE_APPLICATION_BUSY));
+        return;
+    }
+
+    QString path = m_cordova->get_app_dir() + "/../qml/MediaCaptureWidget.qml";
+
+    // TODO: relative url
+    QString qml = QString(code).arg(CordovaInternal::format(path)).arg("audio");
+    m_cordova->execQML(qml);
+
+    _scId = scId;
+    _ecId = ecId;
+}
+
+void MediaCapture::onAudioRecordError(QMediaRecorder::Error) {
+    if (!_ecId)
+        return;
+    this->callback(_ecId, QString("{code: %1}").arg(CAPTURE_INTERNAL_ERR));
+    _ecId = _scId = 0;
+
+    _recorder.clear();
+    _files.clear();
+
+    m_cordova->execQML("CordovaWrapper.captureObject.destroy()");
+}
+
+void MediaCapture::recordAudio() {
+    if (_recorder.data()) {
+        QUrl url = _recorder->outputLocation();
+
+        QString path = url.toString();
+        _recorder->stop();
+
+        _recorder.clear();
+
+        this->callback(_scId, QString("[%1]").arg(formatFile(_db, path)));
+        _ecId = _scId = 0;
+
+        m_cordova->execQML("CordovaWrapper.captureObject.destroy()");
+    } else {
+        _recorder = QSharedPointer<QAudioRecorder>(new QAudioRecorder);
+        QObject::connect(_recorder.data(), SIGNAL(error(QMediaRecorder::Error)), this, SLOT(onAudioRecordError(QMediaRecorder::Error)));
+
+        if (_options.find("mode")->toString() == "audio/amr") {
+            _recorder->setContainerFormat("amr");
+            _recorder->setOutputLocation(generateLocation("amr"));
+        } else {
+            _recorder->setContainerFormat("wav");
+            _recorder->setOutputLocation(generateLocation("wav"));
+        }
+        _recorder->record();
+    }
+}
+
+void MediaCapture::cancel() {
+    if (!_ecId)
+        return;
+
+    m_cordova->execQML("CordovaWrapper.captureObject.destroy()");
+
+    _recorder.clear();
+    this->callback(_ecId, QString("{code: %1}").arg(CAPTURE_NO_MEDIA_FILES));
+    _ecId = _scId = 0;
+
+    _recorder.clear();
+}
+
+void MediaCapture::captureVideo(int scId, int ecId, QVariantMap options) {
+    if (_scId || _ecId) {
+        this->callback(_ecId, QString("{code: %1}").arg(CAPTURE_APPLICATION_BUSY));
+        return;
+    }
+
+    QString path = m_cordova->get_app_dir() + "/../qml/MediaCaptureWidget.qml";
+
+    // TODO: relative url
+    QString qml = QString(code).arg(CordovaInternal::format(path)).arg("videoRecording");
+    m_cordova->execQML(qml);
+
+    _scId = scId;
+    _ecId = ecId;
+}
+
+void MediaCapture::onVideoRecordEnd(QString path) {
+    assert(path.startsWith("file:"));
+    path = path.mid(5);
+
+    this->callback(_scId, QString("[%1]").arg(formatFile(_db, path)));
+    _ecId = _scId = 0;
+
+    m_cordova->execQML("CordovaWrapper.captureObject.destroy()");
+}
+
+void MediaCapture::captureImage(int scId, int ecId, QVariantMap options) {
+    if (_scId || _ecId) {
+        this->callback(_ecId, QString("{code: %1}").arg(CAPTURE_APPLICATION_BUSY));
+        return;
+    }
+
+    QString path = m_cordova->get_app_dir() + "/../qml/MediaCaptureWidget.qml";
+
+    // TODO: relative url
+    QString qml = QString(code).arg(CordovaInternal::format(path)).arg("camera");
+    m_cordova->execQML(qml);
+
+    _scId = scId;
+    _ecId = ecId;
+}
+
+void MediaCapture::onImageSaved(const QString &path) {
+    this->callback(_scId, QString("[%1]").arg(formatFile(_db, path)));
+    _ecId = _scId = 0;
+}

=== added file 'build/src/plugins/org.apache.cordova.media-capture/capture.h'
--- build/src/plugins/org.apache.cordova.media-capture/capture.h	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.media-capture/capture.h	2014-02-19 16:53:58 +0000
@@ -0,0 +1,84 @@
+/*
+ *
+ * Copyright 2013 Canonical Ltd.
+ *
+ * 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.
+ *
+*/
+#ifndef CAPTURE_H_ASCXZFG975
+#define CAPTURE_H_ASCXZFG975
+
+#include <cordova.h>
+#include <cplugin.h>
+#include <QtMultimedia>
+#include <QtCore>
+#include <QtQuick>
+
+class MediaCapture: public CPlugin {
+    Q_OBJECT
+public:
+    explicit MediaCapture(Cordova *cordova);
+
+    virtual const QString fullName() override {
+        return MediaCapture::fullID();
+    }
+
+    virtual const QString shortName() override {
+        return "Capture";
+    }
+
+    static const QString fullID() {
+        return "Capture";
+    }
+
+public slots:
+    void captureAudio(int scId, int ecId, QVariantMap options);
+    void captureImage(int scId, int ecId, QVariantMap options);
+    void captureVideo(int scId, int ecId, QVariantMap options);
+
+    void recordAudio();
+    void cancel();
+    void onVideoRecordEnd(QString path);
+    void onImageSaved(const 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 slots:
+    void onAudioRecordError(QMediaRecorder::Error);
+private:
+    QSharedPointer<QAudioRecorder> _recorder;
+
+    int _scId, _ecId;
+    QList<QString> _files;
+    QVariantMap _options;
+    QMimeDatabase _db;
+
+    enum CaptureError {
+        CAPTURE_INTERNAL_ERR = 0,
+        CAPTURE_APPLICATION_BUSY = 1,
+        CAPTURE_INVALID_ARGUMENT = 2,
+        CAPTURE_NO_MEDIA_FILES = 3,
+        CAPTURE_NOT_SUPPORTED = 20
+    };
+};
+
+#endif

=== added file 'build/src/plugins/org.apache.cordova.media/media.cpp'
--- build/src/plugins/org.apache.cordova.media/media.cpp	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.media/media.cpp	2014-02-19 16:53:58 +0000
@@ -0,0 +1,128 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+
+#include "media.h"
+
+void Media::create(int scId, int ecId, const QString &id, const QString &src) {
+    Q_UNUSED(scId);
+    Q_UNUSED(ecId);
+
+    if (_id2Player.find(id) != _id2Player.end()) {
+        _id2Player[id]->stop();
+        _id2Player.remove(id);
+    }
+
+    _id2Player[id] = QSharedPointer<Player>(new Player(id, src, this));
+}
+
+void Media::relase(int scId, int ecId, const QString &id) {
+    Q_UNUSED(scId);
+    Q_UNUSED(ecId);
+
+    if (_id2Player.find(id) == _id2Player.end())
+        return;
+    _id2Player.remove(id);
+}
+
+void Media::startPlayingAudio(int scId, int ecId, const QString &id, const QString &src, QVariantMap options) {
+    Q_UNUSED(scId);
+    Q_UNUSED(ecId);
+    Q_UNUSED(src);
+    Q_UNUSED(options);
+
+    if (_id2Player.find(id) == _id2Player.end())
+        return;
+    QSharedPointer<Player> player = _id2Player[id];
+    player->play();
+}
+
+void Media::pausePlayingAudio(int scId, int ecId, const QString &id) {
+    Q_UNUSED(scId);
+    Q_UNUSED(ecId);
+
+    if (_id2Player.find(id) == _id2Player.end())
+        return;
+    QSharedPointer<Player> player = _id2Player[id];
+    player->pause();
+}
+
+void Media::stopPlayingAudio(int scId, int ecId, const QString &id) {
+    Q_UNUSED(scId);
+    Q_UNUSED(ecId);
+
+    if (_id2Player.find(id) == _id2Player.end())
+        return;
+    QSharedPointer<Player> player = _id2Player[id];
+    player->stop();
+}
+
+void Media::startRecordingAudio(int scId, int ecId, const QString &id, const QString &src) {
+    Q_UNUSED(scId);
+    Q_UNUSED(ecId);
+    Q_UNUSED(src);
+
+    if (_id2Player.find(id) == _id2Player.end())
+        return;
+    QSharedPointer<Player> player = _id2Player[id];
+    player->startRecording();
+}
+
+void Media::stopRecordingAudio(int scId, int ecId, const QString &id) {
+    Q_UNUSED(scId);
+    Q_UNUSED(ecId);
+
+    if (_id2Player.find(id) == _id2Player.end())
+        return;
+    QSharedPointer<Player> player = _id2Player[id];
+    player->stopRecording();
+}
+
+void Media::getCurrentPositionAudio(int scId, int ecId, const QString &id) {
+    Q_UNUSED(ecId);
+
+    if (_id2Player.find(id) == _id2Player.end())
+        return;
+
+    QSharedPointer<Player> player = _id2Player[id];
+    double position = player->getPosition();
+    this->cb(scId, position);
+}
+
+void Media::seekToAudio(int scId, int ecId, const QString &id, qint64 position) {
+    Q_UNUSED(scId);
+    Q_UNUSED(ecId);
+
+    if (_id2Player.find(id) == _id2Player.end())
+        return;
+
+    QSharedPointer<Player> player = _id2Player[id];
+    player->seekTo(position);
+}
+
+void Media::setVolume(int scId, int ecId, const QString &id, int volume) {
+    Q_UNUSED(scId);
+    Q_UNUSED(ecId);
+
+    if (_id2Player.find(id) == _id2Player.end())
+        return;
+    QSharedPointer<Player> player = _id2Player[id];
+    player->setVolume(volume);
+}

=== added file 'build/src/plugins/org.apache.cordova.media/media.h'
--- build/src/plugins/org.apache.cordova.media/media.h	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.media/media.h	2014-02-19 16:53:58 +0000
@@ -0,0 +1,267 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+
+#ifndef MEDIA_H_789768978
+#define MEDIA_H_789768978
+
+#include <QtMultimedia/QMediaPlayer>
+#include <QtCore>
+#include <QAudioRecorder>
+#include <QtMultimedia/QAudioEncoderSettings>
+
+#include <cplugin.h>
+#include <cordova.h>
+
+class Player;
+
+class Media: public CPlugin {
+    Q_OBJECT
+public:
+    explicit Media(Cordova *cordova): CPlugin(cordova) {
+    }
+
+    virtual const QString fullName() override {
+        return Media::fullID();
+    }
+
+    virtual const QString shortName() override {
+        return "Media";
+    }
+
+    static const QString fullID() {
+        return "Media";
+    }
+
+    enum State {
+        MEDIA_NONE = 0,
+        MEDIA_STARTING = 1,
+        MEDIA_RUNNING = 2,
+        MEDIA_PAUSED = 3,
+        MEDIA_STOPPED = 4
+    };
+    enum ErrorCode {
+        MEDIA_ERR_NONE_ACTIVE = 0,
+        MEDIA_ERR_ABORTED = 1,
+        MEDIA_ERR_NETWORK = 2,
+        MEDIA_ERR_DECODE = 3,
+        MEDIA_ERR_NONE_SUPPORTED = 4
+    };
+
+    void execJS(const QString &js) {
+        m_cordova->execJS(js);
+    }
+public slots:
+    void create(int scId, int ecId, const QString &id, const QString &src);
+    void relase(int scId, int ecId, const QString &id);
+
+    void startRecordingAudio(int scId, int ecId, const QString &id, const QString &src);
+    void stopRecordingAudio(int scId, int ecId, const QString &id);
+
+    void startPlayingAudio(int scId, int ecId, const QString &id, const QString &src, QVariantMap options);
+    void pausePlayingAudio(int scId, int ecId, const QString &id);
+    void stopPlayingAudio(int scId, int ecId, const QString &id);
+    void getCurrentPositionAudio(int scId, int ecId, const QString &id);
+    void seekToAudio(int scId, int ecId, const QString &id, qint64 position);
+    void setVolume(int scId, int ecId, const QString &id, int volume);
+
+private:
+    QMap<QString, QSharedPointer<Player> > _id2Player;
+};
+
+class Player: public QObject {
+    Q_OBJECT
+public:
+    Player(const QString &id, QString src, Media *plugin):
+        _state(Media::MEDIA_NONE),
+        _src(src),
+        _mode(MODE_NONE),
+        _plugin(plugin),
+        _id(id),
+        _stateChanged(false) {
+        QUrl url(src, QUrl::TolerantMode);
+
+        if (url.scheme().isEmpty()) {
+            QAudioEncoderSettings audioSettings;
+
+            _recorder.setEncodingSettings(audioSettings);
+            _recorder.setOutputLocation(QFileInfo(src).absoluteFilePath());
+
+            _player.setMedia(QUrl::fromLocalFile(QFileInfo(src).absoluteFilePath()));
+        } else {
+            _player.setMedia(url);
+        }
+        QObject::connect(&_player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)), this, SLOT(onMediaStatusChanged(QMediaPlayer::MediaStatus)));
+        QObject::connect(&_recorder, SIGNAL(error(QMediaRecorder::Error)), this, SLOT(onError(QMediaRecorder::Error)));
+
+        connect(&_timer, SIGNAL(timeout()), this, SLOT(reportPosition()));
+    }
+
+    void startRecording() {
+        if (recordMode() && _state != Media::MEDIA_RUNNING) {
+            _recorder.record();
+            setState(Media::MEDIA_RUNNING);
+        }
+    }
+    void stopRecording() {
+        if (recordMode() && _state == Media::MEDIA_RUNNING) {
+            _recorder.stop();
+            setState(Media::MEDIA_STOPPED);
+        }
+    }
+
+    void setVolume(int volume) {
+        _player.setVolume(volume);
+    }
+
+    void play() {
+        if (playMode() && _state != Media::MEDIA_RUNNING) {
+            _player.play();
+            setState(Media::MEDIA_RUNNING);
+        }
+    }
+    void pause() {
+        if (playMode() && _state == Media::MEDIA_RUNNING) {
+            _player.pause();
+            setState(Media::MEDIA_PAUSED);
+        }
+    }
+    void stop() {
+        if (playMode() && (_state == Media::MEDIA_RUNNING || _state == Media::MEDIA_PAUSED)) {
+            _player.stop();
+            setState(Media::MEDIA_STOPPED);
+        }
+    }
+    double getDuration() {
+        if (_mode == MODE_NONE || _player.duration() == -1)
+            return -1;
+        if (_mode != MODE_PLAY)
+            return -2;
+        return static_cast<double>(_player.duration()) / 1000.0;
+    }
+    double getPosition() {
+        if (_mode != MODE_PLAY)
+            return -1;
+        return static_cast<double>(_player.position()) / 1000.0;
+    }
+    bool seekTo(qint64 position) {
+        if (!_player.isSeekable())
+            return false;
+        _player.setPosition(position * 1000);
+        return true;
+    }
+private slots:
+    void reportPosition() {
+        double position = getPosition();
+        _plugin->execJS(QString("Media.onStatus('%1', Media.MEDIA_POSITION, %2)")
+                        .arg(_id).arg(position));
+        double duration = getDuration();
+        _plugin->execJS(QString("Media.onStatus('%1', Media.MEDIA_DURATION, %2)")
+                        .arg(_id).arg(duration));
+
+        if (_stateChanged && !(_state == Media::MEDIA_RUNNING && (duration == -1 || position == 0))) {
+        qCritical() << _id << "POSITION" << position << ":" << duration;
+            _stateChanged = false;
+            _plugin->execJS(QString("Media.onStatus('%1', Media.MEDIA_STATE, %2)").arg(_id).arg(_state));
+        }
+    }
+
+    void onMediaStatusChanged(QMediaPlayer::MediaStatus status) {
+        if (status == QMediaPlayer::InvalidMedia) {
+            reportError(Media::MEDIA_ERR_ABORTED, "AudioPlayer Error: The current media cannot be played.");
+            setState(Media::MEDIA_STOPPED);
+        }
+        if (status == QMediaPlayer::EndOfMedia) {
+            setState(Media::MEDIA_STOPPED);
+            seekTo(0);
+        }
+    }
+    void onError(QMediaRecorder::Error) {
+        reportError(Media::MEDIA_ERR_NONE_SUPPORTED, "AudioPlayer Error: Device is not ready or not available.");
+        setState(Media::MEDIA_STOPPED);
+    }
+
+private:
+    void reportError(int code, const QString &descr) {
+        Q_UNUSED(descr);
+        _plugin->execJS(QString("Media.onStatus('%1', Media.MEDIA_ERROR, {code: %2})")
+                        .arg(_id).arg(code));
+    }
+
+    bool playMode() {
+        switch (_mode) {
+        case Player::MODE_NONE:
+            _mode = MODE_PLAY;
+            break;
+        case Player::MODE_PLAY:
+            break;
+        case Player::MODE_RECORD:
+            reportError(Media::MEDIA_ERR_NONE_SUPPORTED, "AudioPlayer Error: Can't play in record mode.");
+            return false;
+            break;
+        }
+        return true;
+    }
+
+    bool recordMode() {
+        switch (_mode) {
+        case Player::MODE_NONE:
+            if (_recorder.outputLocation().isEmpty()) {
+                reportError(Media::MEDIA_ERR_NONE_SUPPORTED, "AudioPlayer Error: unsupported output location.");
+                return false;
+            }
+            _mode = MODE_RECORD;
+            break;
+        case Player::MODE_PLAY:
+            reportError(Media::MEDIA_ERR_NONE_SUPPORTED, "AudioPlayer Error: Can't play in play mode.");
+            return false;
+            break;
+        case Player::MODE_RECORD:
+            break;
+        }
+        return true;
+    }
+
+    void setState(Media::State state) {
+        _state = state;
+        _stateChanged = true;
+        _timer.start(250);
+    }
+
+    QMediaPlayer _player;
+
+    QAudioRecorder _recorder;
+    QTimer _timer;
+
+    Media::State _state;
+    QString _src;
+    enum Mode {
+        MODE_NONE,
+        MODE_PLAY,
+        MODE_RECORD
+    };
+    Mode _mode;
+    Media *_plugin;
+    QString _id;
+
+    bool _stateChanged;
+};
+
+#endif

=== added directory 'build/src/plugins/org.apache.cordova.splashscreen'
=== added file 'build/src/plugins/org.apache.cordova.splashscreen/splashscreen.cpp'
--- build/src/plugins/org.apache.cordova.splashscreen/splashscreen.cpp	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.splashscreen/splashscreen.cpp	2014-02-19 16:53:58 +0000
@@ -0,0 +1,42 @@
+/*
+ *
+ * Copyright 2013 Canonical Ltd.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+
+#include <QQuickItem>
+
+#include "splashscreen.h"
+#include <cordova.h>
+
+#define SPLASHSCREEN_STATE_NAME "splashscreen"
+
+Splashscreen::Splashscreen(Cordova *cordova): CPlugin(cordova) {
+}
+
+void Splashscreen::show(int, int) {
+    m_cordova->rootObject()->setProperty("splashscreenPath", m_cordova->getSplashscreenPath());
+
+    m_cordova->pushViewState(SPLASHSCREEN_STATE_NAME);
+}
+
+void Splashscreen::hide(int, int) {
+    m_cordova->popViewState(SPLASHSCREEN_STATE_NAME);
+}

=== added file 'build/src/plugins/org.apache.cordova.splashscreen/splashscreen.h'
--- build/src/plugins/org.apache.cordova.splashscreen/splashscreen.h	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.splashscreen/splashscreen.h	2014-02-19 16:53:58 +0000
@@ -0,0 +1,52 @@
+/*
+ *
+ * Copyright 2013 Canonical Ltd.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+
+#ifndef SPLASHSCREEN_H
+#define SPLASHSCREEN_H
+
+#include <QtCore>
+#include <cplugin.h>
+
+class Splashscreen: public CPlugin {
+    Q_OBJECT
+public:
+    explicit Splashscreen(Cordova *cordova);
+
+    virtual const QString fullName() override {
+        return Splashscreen::fullID();
+    }
+
+    virtual const QString shortName() override {
+        return "SplashScreen";
+    }
+
+    static const QString fullID() {
+        return "SplashScreen";
+    }
+
+public slots:
+    void show(int, int);
+    void hide(int, int);
+};
+
+#endif // SPLASHSCREEN_H

=== added directory 'build/src/plugins/org.apache.cordova.vibration'
=== added file 'build/src/plugins/org.apache.cordova.vibration/vibration.cpp'
--- build/src/plugins/org.apache.cordova.vibration/vibration.cpp	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.vibration/vibration.cpp	2014-02-19 16:53:58 +0000
@@ -0,0 +1,38 @@
+/*
+ *
+ * Copyright 2013 Canonical Ltd.
+ *
+ * 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.
+ *
+*/
+
+#include <QFeedbackHapticsEffect>
+#include "vibration.h"
+
+void Vibration::vibrate(int, int, int mills) {
+    QFeedbackHapticsEffect *vibrate = new QFeedbackHapticsEffect;
+    vibrate->setIntensity(1.0);
+    vibrate->setDuration(mills);
+
+    connect(vibrate, &QFeedbackHapticsEffect::stateChanged, [&]() {
+        QFeedbackEffect *effect = qobject_cast<QFeedbackEffect *>(sender());
+        if (!effect)
+            return;
+        if (effect->state() == QFeedbackEffect::Stopped)
+            effect->deleteLater();
+    });
+
+    vibrate->start();
+}
+

=== added file 'build/src/plugins/org.apache.cordova.vibration/vibration.h'
--- build/src/plugins/org.apache.cordova.vibration/vibration.h	1970-01-01 00:00:00 +0000
+++ build/src/plugins/org.apache.cordova.vibration/vibration.h	2014-02-19 16:53:58 +0000
@@ -0,0 +1,47 @@
+/*
+ *
+ * Copyright 2013 Canonical Ltd.
+ *
+ * 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.
+ *
+*/
+
+#ifndef _VIBRATION_H_SFAFKNVX3456
+#define _VIBRATION_H_SFAFKNVX3456
+
+#include <QtQuick>
+#include <cplugin.h>
+
+class Vibration: public CPlugin {
+    Q_OBJECT
+public:
+    explicit Vibration(Cordova *cordova): CPlugin(cordova) {
+    }
+
+    virtual const QString fullName() override {
+        return Vibration::fullID();
+    }
+
+    virtual const QString shortName() override {
+        return "Vibration";
+    }
+
+    static const QString fullID() {
+        return "Vibration";
+    }
+public slots:
+    void vibrate(int, int, int mills);
+};
+
+#endif

=== modified file 'config.xml'
--- config.xml	2014-02-05 23:42:31 +0000
+++ config.xml	2014-02-19 16:53:58 +0000
@@ -1,5 +1,24 @@
 <?xml version='1.0' encoding='utf-8'?>
 <widget id="io.cordova.hellocordova" version="0.0.1" xmlns="http://www.w3.org/ns/widgets" xmlns:cdv="http://cordova.apache.org/ns/1.0">
+    <preference name="loglevel" value="DEBUG" />
+    <feature name="Camera">
+        <param policy_group="camera" policy_version="1" />
+    </feature>
+    <feature name="DeviceOrientation">
+        <param policy_group="sensors" policy_version="1" />
+    </feature>
+    <feature name="Geolocation">
+        <param policy_group="location" policy_version="1" />
+    </feature>
+    <feature name="Media">
+        <param policy_group="microphone" policy_version="1" />
+        <param policy_group="video" policy_version="1" />
+    </feature>
+    <feature name="Capture">
+        <param policy_group="audio" policy_version="1" />
+        <param policy_group="camera" policy_version="1" />
+        <param policy_group="microphone" policy_version="1" />
+    </feature>
     <name>HelloCordova</name>
     <description>
         A sample Apache Cordova application that responds to the deviceready event.

=== modified file 'debian/changelog'
--- debian/changelog	2014-02-18 10:03:39 +0000
+++ debian/changelog	2014-02-19 16:53:58 +0000
@@ -1,3 +1,9 @@
+cordova-ubuntu-3.4 (3.4~pre3.r17ubuntu2) trusty; urgency=low
+
+  * Test build with additional plugins
+
+ -- David Barth <[e-mail]>  Wed, 19 Feb 2014 17:48:58 +0100
+
 cordova-ubuntu-3.4 (3.4~pre3.r17) trusty; urgency=medium
 
   [ Alexandre Abreu ]
@@ -11,6 +17,12 @@
 
  -- Daniel Holbach <[e-mail]>  Fri, 14 Feb 2014 10:21:43 +0100
 
+cordova-ubuntu-3.4 (3.4~pre3ubuntu1) UNRELEASED; urgency=low
+
+  * Add the full set of platform plugins
+
+ -- David Barth <[e-mail]>  Fri, 14 Feb 2014 16:17:05 +0100
+
 cordova-ubuntu-3.4 (3.4~pre3) trusty; urgency=low
 
   * Trusty build

=== modified file 'debian/control'
--- debian/control	2014-02-17 16:24:58 +0000
+++ debian/control	2014-02-19 16:53:58 +0000
@@ -28,8 +28,10 @@
 Architecture: any
 Depends: ${misc:Depends},
          ${shlibs:Depends},
-Description: Ubuntu HTML5 Framework for building mobile web apps - development files
- This package contains files that are needed to build applications.
+Description: Cordova Framework for building mobile web apps - development files
+ Cordova is a free and open source framework that allows you to create mobile
+ apps using standardized web APIs for the platforms you care about.
  .
- They are not meant to be used locally, but are embedded in the resulting
- click packages.
+ This package contains library files that are needed to build applications.
+ The libraries are not meant to be installed on the system, but should be
+ embedded in a click package.

=== modified file 'debian/rules'
--- debian/rules	2014-02-17 16:24:58 +0000
+++ debian/rules	2014-02-19 16:53:58 +0000
@@ -1,12 +1,33 @@
 #!/usr/bin/make -f
 # -*- makefile -*-
 
+# to update the source tree:
+# create a temporary directory to construct the runtime with the cordova CLI tool
+# cordova create runtime
+# cd runtime
+# cordova platform add ubuntu
+# cordova plugin add org.apache.cordova.camera
+# cordova plugin add <other plugins>
+# ...
+# cordova prepare
+# then copy back files from the platforms/ubuntu directory
+
 DEB_HOST_MULTIARCH ?= $(shell dpkg-architecture -qDEB_HOST_MULTIARCH)
+INSTALL_PREFIX="/usr/share/ubuntu-html5-platform-3.4/${DEB_HOST_MULTIARCH}"
+PACKAGE_NAME=ubuntu-html5-platform-3.4-dev
 
 override_dh_auto_configure:
-	cd build; cmake -DCMAKE_INSTALL_PREFIX=/usr/share/ubuntu-html5-platform-3.4/${DEB_HOST_MULTIARCH} \
+	cd build; cmake -DCMAKE_INSTALL_PREFIX=${INSTALL_PREFIX} \
 	                -DCMAKE_VERBOSE_MAKEFILE=ON \
 	                -DCMAKE_BUILD_TYPE=RelWithDebInfo
 
+override_dh_install:
+	dh_install
+	cp -R www debian/${PACKAGE_NAME}/${INSTALL_PREFIX}/; \
+	cp -R qml debian/${PACKAGE_NAME}/${INSTALL_PREFIX}/; \
+	rm -f debian/${PACKAGE_NAME}/${INSTALL_PREFIX}/cordova-ubuntu
+
+override_dh_strip:
+
 %:
 	dh $@ --sourcedirectory=build --fail-missing

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

=== added file 'qml/InAppBrowser.qml'
--- qml/InAppBrowser.qml	1970-01-01 00:00:00 +0000
+++ qml/InAppBrowser.qml	2014-02-19 16:53:58 +0000
@@ -0,0 +1,69 @@
+/*
+ *
+ * Copyright 2013 Canonical Ltd.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+import QtQuick 2.0
+import QtWebKit 3.0
+import Ubuntu.Components.Popups 0.1
+import Ubuntu.Components 0.1
+
+Rectangle {
+    anchors.fill: parent
+    id: inappbrowser
+    property string url1
+    Rectangle {
+        border.color: "black"
+        width: parent.width
+        height: urlEntry.height
+        color: "gray"
+        TextInput {
+            id: urlEntry
+            width: parent.width - closeButton.width
+            text: url1
+            activeFocusOnPress: false
+        }
+        Image {
+            id: closeButton
+            width: height
+            x: parent.width - width
+            height: parent.height
+            source: "close.png"
+            MouseArea {
+                anchors.fill: parent
+                onClicked: {
+                    root.exec("InAppBrowser", "close", [0, 0])
+                }
+            }
+        }
+    }
+
+    WebView {
+        width: parent.width
+        y: urlEntry.height
+        height: parent.height - y
+        url: url1
+        onLoadingChanged: {
+            if (loadRequest.status) {
+                root.exec("InAppBrowser", "loadFinished", [loadRequest.status])
+            }
+        }
+    }
+}

=== added file 'qml/MediaCaptureWidget.qml'
--- qml/MediaCaptureWidget.qml	1970-01-01 00:00:00 +0000
+++ qml/MediaCaptureWidget.qml	2014-02-19 16:53:58 +0000
@@ -0,0 +1,207 @@
+/*
+ *
+ * Copyright 2013 Canonical Ltd.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+import QtQuick 2.0
+import QtMultimedia 5.0
+
+Rectangle {
+    property string recordOffImagePath: "record_off.png"
+    property string recordOnImagePath: "record_on.png"
+    property string shootImagePath: "shoot.png"
+    function isSuffix(str, suffix) {
+        return String(str).substr(String(str).length - suffix.length) == suffix
+    }
+
+    id: ui
+    color: "#252423"
+    anchors.fill: parent
+    state: "off"
+
+    Camera {
+        objectName: "camera"
+        id: camera
+        cameraState: Camera.UnloadedState
+        onError: {
+            console.log(errorString);
+            shootButton.source = recordOffImagePath
+        }
+        imageCapture {
+            onImageSaved: {
+                root.exec("Capture", "onImageSaved", [path]);
+                ui.destroy();
+            }
+        }
+        videoRecorder {
+            audioBitRate: 128000
+            mediaContainer: "mp4"
+            outputLocation: ui.parent.plugin('Capture').generateLocation("mp4")
+            onRecorderStateChanged: {
+               if (videoRecorder.recorderState === CameraRecorder.StoppedState) {
+                   ui.parent.exec("Capture", "onVideoRecordEnd", [camera.videoRecorder.actualLocation]);
+                   shootButton.source = recordOffImagePath
+               }
+            }
+        }
+    }
+    Image {
+        id: microphoneImage
+        source: "microphone.png"
+        smooth: true
+        visible: false
+        width: parent.width
+        height: parent.height
+    }
+    VideoOutput {
+        id: output
+        focus : visible
+        source: camera
+        width: parent.width
+        height: parent.height
+    }
+
+    Item {
+        anchors.bottom: parent.bottom
+        width: parent.width
+        height: shootButton.height
+        BorderImage {
+            id: leftBackground
+            anchors.left: parent.left
+            anchors.top: parent.top
+            anchors.bottom: parent.bottom
+            anchors.right: middle.left
+            anchors.topMargin: units.dp(2)
+            anchors.bottomMargin: units.dp(2)
+            source: "toolbar-left.png"
+            Image {
+                anchors.verticalCenter: parent.verticalCenter
+                anchors.left: parent.left
+                anchors.leftMargin: parent.iconSpacing
+                source: "back.png"
+                width: units.gu(6)
+                height: units.gu(5)
+                MouseArea {
+                    anchors.fill: parent
+                    onClicked: {
+                        root.exec("Capture", "cancel");
+                    }
+                }
+            }
+        }
+        BorderImage {
+            id: middle
+            anchors.top: parent.top
+            anchors.bottom: parent.bottom
+            anchors.horizontalCenter: parent.horizontalCenter
+            height: shootButton.height + units.gu(1)
+            width: shootButton.width
+            source: "toolbar-middle.png"
+            Image {
+                id: shootButton
+                width: units.gu(8)
+                height: width
+                anchors.horizontalCenter: parent.horizontalCenter
+                source: shootImagePath
+                MouseArea {
+                    anchors.fill: parent
+                    onClicked: {
+                        if (ui.state === "camera") {
+                            camera.imageCapture.captureToLocation(ui.parent.plugin('Capture').generateLocation("jpg"));
+                        } else if (ui.state === "audio") {
+                            ui.parent.exec("Capture", "recordAudio");
+                            if (isSuffix(shootButton.source, recordOffImagePath)) {
+                                shootButton.source = recordOnImagePath
+                            } else {
+                                shootButton.source = recordOffImagePath
+                            }
+                        } else if (ui.state === "videoRecording") {
+                            if (!camera.videoRecorder.recorderState) {
+                                shootButton.source = recordOnImagePath
+                                camera.videoRecorder.record();
+                            } else {
+                                camera.videoRecorder.stop();
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        BorderImage {
+            id: rightBackground
+            anchors.right: parent.right
+            anchors.top: parent.top
+            anchors.bottom: parent.bottom
+            anchors.left: middle.right
+            anchors.topMargin: units.dp(2)
+            anchors.bottomMargin: units.dp(2)
+            source: "toolbar-right.png"
+        }
+    }
+    states: [
+        State {
+            name: "off"
+            StateChangeScript {
+                script:{
+		    ui.visible = false;
+                    camera.stop();
+                    camera.unlock();
+                }
+            }
+        },
+        State {
+            name: "camera"
+            StateChangeScript {
+                script: {
+                    camera.start();
+		    microphoneImage.visible = false
+                    output.visible = true
+                    shootButton.source = shootImagePath
+                    ui.visible = true
+                }
+            }
+        },
+        State {
+            name: "videoRecording"
+            StateChangeScript {
+                script: {
+                    shootButton.source = recordOffImagePath
+                    camera.start();
+		    microphoneImage.visible = false
+                    output.visible = true
+                    ui.visible = true
+                }
+            }
+        },
+        State {
+            name: "audio"
+            StateChangeScript {
+                script:{
+                    shootButton.source = recordOffImagePath
+                    camera.stop();
+		    microphoneImage.visible = true
+                    camera.unlock();
+                    output.visible = false
+                    ui.visible = true
+                }
+            }
+        }
+    ]
+}

=== added file 'qml/back.png'
Binary files qml/back.png	1970-01-01 00:00:00 +0000 and qml/back.png	2014-02-19 16:53:58 +0000 differ
=== added file 'qml/close.png'
Binary files qml/close.png	1970-01-01 00:00:00 +0000 and qml/close.png	2014-02-19 16:53:58 +0000 differ
=== added file 'qml/microphone.png'
Binary files qml/microphone.png	1970-01-01 00:00:00 +0000 and qml/microphone.png	2014-02-19 16:53:58 +0000 differ
=== added file 'qml/notification.qml'
--- qml/notification.qml	1970-01-01 00:00:00 +0000
+++ qml/notification.qml	2014-02-19 16:53:58 +0000
@@ -0,0 +1,44 @@
+import QtQuick 2.0
+import Ubuntu.Components.Popups 0.1
+import Ubuntu.Components 0.1
+
+Dialog {
+    id: dialogue
+    property string button1Text
+    property string button2Text
+    property string button3Text
+    property bool promptVisible
+    property string defaultPromptText
+    TextInput {// FIXME: swith to TextField(TextField should support visible property)
+        id: prompt
+        color: "white"
+        text: defaultPromptText
+        visible: promptVisible
+        focus: true
+    }
+    Button {
+        text: button1Text
+        color: "orange"
+        onClicked: {
+            root.exec("Notification", "notificationDialogButtonPressed", [1, prompt.text]);
+            PopupUtils.close(dialogue)
+        }
+    }
+    Button {
+        text: button2Text
+        visible: button2Text.length > 0
+        color: "orange"
+        onClicked: {
+            root.exec("Notification", "notificationDialogButtonPressed", [2, prompt.text]);
+            PopupUtils.close(dialogue)
+        }
+    }
+    Button {
+        text: button3Text
+        visible: button3Text.length > 0
+        onClicked: {
+            root.exec("Notification", "notificationDialogButtonPressed", [3, prompt.text]);
+            PopupUtils.close(dialogue)
+        }
+    }
+}

=== added file 'qml/record_off.png'
Binary files qml/record_off.png	1970-01-01 00:00:00 +0000 and qml/record_off.png	2014-02-19 16:53:58 +0000 differ
=== added file 'qml/record_on.png'
Binary files qml/record_on.png	1970-01-01 00:00:00 +0000 and qml/record_on.png	2014-02-19 16:53:58 +0000 differ
=== added file 'qml/shoot.png'
Binary files qml/shoot.png	1970-01-01 00:00:00 +0000 and qml/shoot.png	2014-02-19 16:53:58 +0000 differ
=== added file 'qml/toolbar-left.png'
Binary files qml/toolbar-left.png	1970-01-01 00:00:00 +0000 and qml/toolbar-left.png	2014-02-19 16:53:58 +0000 differ
=== added file 'qml/toolbar-middle.png'
Binary files qml/toolbar-middle.png	1970-01-01 00:00:00 +0000 and qml/toolbar-middle.png	2014-02-19 16:53:58 +0000 differ
=== added file 'qml/toolbar-right.png'
Binary files qml/toolbar-right.png	1970-01-01 00:00:00 +0000 and qml/toolbar-right.png	2014-02-19 16:53:58 +0000 differ
=== modified file 'www/cordova_plugins.js'
--- www/cordova_plugins.js	2014-02-05 23:42:31 +0000
+++ www/cordova_plugins.js	2014-02-19 16:53:58 +0000
@@ -1,7 +1,412 @@
 cordova.define('cordova/plugin_list', function(require, exports, module) {
-module.exports = [];
+module.exports = [
+    {
+        "file": "plugins/org.apache.cordova.battery-status/www/battery.js",
+        "id": "org.apache.cordova.battery-status.battery",
+        "clobbers": [
+            "navigator.battery"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.camera/www/CameraConstants.js",
+        "id": "org.apache.cordova.camera.Camera",
+        "clobbers": [
+            "Camera"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.camera/www/CameraPopoverOptions.js",
+        "id": "org.apache.cordova.camera.CameraPopoverOptions",
+        "clobbers": [
+            "CameraPopoverOptions"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.camera/www/Camera.js",
+        "id": "org.apache.cordova.camera.camera",
+        "clobbers": [
+            "navigator.camera"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.camera/www/CameraPopoverHandle.js",
+        "id": "org.apache.cordova.camera.CameraPopoverHandle",
+        "clobbers": [
+            "CameraPopoverHandle"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.console/www/console-via-logger.js",
+        "id": "org.apache.cordova.console.console",
+        "clobbers": [
+            "console"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.console/www/logger.js",
+        "id": "org.apache.cordova.console.logger",
+        "clobbers": [
+            "cordova.logger"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.device/www/device.js",
+        "id": "org.apache.cordova.device.device",
+        "clobbers": [
+            "device"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.device/src/ubuntu/device.js",
+        "id": "org.apache.cordova.device.DeviceProxy",
+        "merges": [
+            "device"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.device-motion/www/Acceleration.js",
+        "id": "org.apache.cordova.device-motion.Acceleration",
+        "clobbers": [
+            "Acceleration"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.device-motion/www/accelerometer.js",
+        "id": "org.apache.cordova.device-motion.accelerometer",
+        "clobbers": [
+            "navigator.accelerometer"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.device-orientation/www/CompassError.js",
+        "id": "org.apache.cordova.device-orientation.CompassError",
+        "clobbers": [
+            "CompassError"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.device-orientation/www/CompassHeading.js",
+        "id": "org.apache.cordova.device-orientation.CompassHeading",
+        "clobbers": [
+            "CompassHeading"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.device-orientation/www/compass.js",
+        "id": "org.apache.cordova.device-orientation.compass",
+        "clobbers": [
+            "navigator.compass"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.dialogs/www/notification.js",
+        "id": "org.apache.cordova.dialogs.notification",
+        "merges": [
+            "navigator.notification"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file/www/DirectoryEntry.js",
+        "id": "org.apache.cordova.file.DirectoryEntry",
+        "clobbers": [
+            "window.DirectoryEntry"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file/www/DirectoryReader.js",
+        "id": "org.apache.cordova.file.DirectoryReader",
+        "clobbers": [
+            "window.DirectoryReader"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file/www/Entry.js",
+        "id": "org.apache.cordova.file.Entry",
+        "clobbers": [
+            "window.Entry"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file/www/File.js",
+        "id": "org.apache.cordova.file.File",
+        "clobbers": [
+            "window.File"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file/www/FileEntry.js",
+        "id": "org.apache.cordova.file.FileEntry",
+        "clobbers": [
+            "window.FileEntry"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file/www/FileError.js",
+        "id": "org.apache.cordova.file.FileError",
+        "clobbers": [
+            "window.FileError"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file/www/FileReader.js",
+        "id": "org.apache.cordova.file.FileReader",
+        "clobbers": [
+            "window.FileReader"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file/www/FileSystem.js",
+        "id": "org.apache.cordova.file.FileSystem",
+        "clobbers": [
+            "window.FileSystem"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file/www/FileUploadOptions.js",
+        "id": "org.apache.cordova.file.FileUploadOptions",
+        "clobbers": [
+            "window.FileUploadOptions"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file/www/FileUploadResult.js",
+        "id": "org.apache.cordova.file.FileUploadResult",
+        "clobbers": [
+            "window.FileUploadResult"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file/www/FileWriter.js",
+        "id": "org.apache.cordova.file.FileWriter",
+        "clobbers": [
+            "window.FileWriter"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file/www/Flags.js",
+        "id": "org.apache.cordova.file.Flags",
+        "clobbers": [
+            "window.Flags"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file/www/LocalFileSystem.js",
+        "id": "org.apache.cordova.file.LocalFileSystem",
+        "clobbers": [
+            "window.LocalFileSystem"
+        ],
+        "merges": [
+            "window"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file/www/Metadata.js",
+        "id": "org.apache.cordova.file.Metadata",
+        "clobbers": [
+            "window.Metadata"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file/www/ProgressEvent.js",
+        "id": "org.apache.cordova.file.ProgressEvent",
+        "clobbers": [
+            "window.ProgressEvent"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file/www/requestFileSystem.js",
+        "id": "org.apache.cordova.file.requestFileSystem",
+        "clobbers": [
+            "window.requestFileSystem"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file/www/resolveLocalFileSystemURI.js",
+        "id": "org.apache.cordova.file.resolveLocalFileSystemURI",
+        "merges": [
+            "window"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file/www/ubuntu/Entry.js",
+        "id": "org.apache.cordova.file.Entry1",
+        "merges": [
+            "window.Entry"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file/www/ubuntu/DirectoryEntry.js",
+        "id": "org.apache.cordova.file.DirectoryEntry1",
+        "merges": [
+            "window.DirectoryEntry"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file/www/ubuntu/FileWriter.js",
+        "id": "org.apache.cordova.file.FileWriter1",
+        "merges": [
+            "window.FileWriter"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file-transfer/www/FileTransferError.js",
+        "id": "org.apache.cordova.file-transfer.FileTransferError",
+        "clobbers": [
+            "window.FileTransferError"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.file-transfer/www/FileTransfer.js",
+        "id": "org.apache.cordova.file-transfer.FileTransfer",
+        "clobbers": [
+            "window.FileTransfer"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.geolocation/www/Coordinates.js",
+        "id": "org.apache.cordova.geolocation.Coordinates",
+        "clobbers": [
+            "Coordinates"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.geolocation/www/PositionError.js",
+        "id": "org.apache.cordova.geolocation.PositionError",
+        "clobbers": [
+            "PositionError"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.geolocation/www/Position.js",
+        "id": "org.apache.cordova.geolocation.Position",
+        "clobbers": [
+            "Position"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.geolocation/www/geolocation.js",
+        "id": "org.apache.cordova.geolocation.geolocation",
+        "clobbers": [
+            "navigator.geolocation"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.globalization/www/GlobalizationError.js",
+        "id": "org.apache.cordova.globalization.GlobalizationError",
+        "clobbers": [
+            "window.GlobalizationError"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.globalization/www/globalization.js",
+        "id": "org.apache.cordova.globalization.globalization",
+        "clobbers": [
+            "navigator.globalization"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.globalization/www/ubuntu/globalization.js",
+        "id": "org.apache.cordova.globalization.Globalization1",
+        "merges": [
+            "navigator.globalization"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.inappbrowser/www/InAppBrowser.js",
+        "id": "org.apache.cordova.inappbrowser.InAppBrowser",
+        "clobbers": [
+            "window.open"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.media/www/MediaError.js",
+        "id": "org.apache.cordova.media.MediaError",
+        "clobbers": [
+            "window.MediaError"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.media/www/Media.js",
+        "id": "org.apache.cordova.media.Media",
+        "clobbers": [
+            "window.Media"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.media-capture/www/CaptureAudioOptions.js",
+        "id": "org.apache.cordova.media-capture.CaptureAudioOptions",
+        "clobbers": [
+            "CaptureAudioOptions"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.media-capture/www/CaptureImageOptions.js",
+        "id": "org.apache.cordova.media-capture.CaptureImageOptions",
+        "clobbers": [
+            "CaptureImageOptions"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.media-capture/www/CaptureVideoOptions.js",
+        "id": "org.apache.cordova.media-capture.CaptureVideoOptions",
+        "clobbers": [
+            "CaptureVideoOptions"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.media-capture/www/CaptureError.js",
+        "id": "org.apache.cordova.media-capture.CaptureError",
+        "clobbers": [
+            "CaptureError"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.media-capture/www/MediaFileData.js",
+        "id": "org.apache.cordova.media-capture.MediaFileData",
+        "clobbers": [
+            "MediaFileData"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.media-capture/www/MediaFile.js",
+        "id": "org.apache.cordova.media-capture.MediaFile",
+        "clobbers": [
+            "MediaFile"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.media-capture/www/capture.js",
+        "id": "org.apache.cordova.media-capture.capture",
+        "clobbers": [
+            "navigator.device.capture"
+        ]
+    },
+    {
+        "file": "plugins/org.apache.cordova.vibration/www/vibration.js",
+        "id": "org.apache.cordova.vibration.notification",
+        "merges": [
+            "navigator.notification"
+        ]
+    }
+];
 module.exports.metadata = 
 // TOP OF METADATA
-{}
+{
+    "org.apache.cordova.battery-status": "0.2.7",
+    "org.apache.cordova.camera": "0.2.7",
+    "org.apache.cordova.console": "0.2.7",
+    "org.apache.cordova.device": "0.2.8",
+    "org.apache.cordova.device-motion": "0.2.6",
+    "org.apache.cordova.device-orientation": "0.3.5",
+    "org.apache.cordova.dialogs": "0.2.6",
+    "org.apache.cordova.file": "1.0.0",
+    "org.apache.cordova.file-transfer": "0.4.1",
+    "org.apache.cordova.geolocation": "0.3.6",
+    "org.apache.cordova.globalization": "0.2.6",
+    "org.apache.cordova.inappbrowser": "0.3.1",
+    "org.apache.cordova.media": "0.2.8",
+    "org.apache.cordova.media-capture": "0.2.7",
+    "org.apache.cordova.vibration": "0.3.7"
+}
 // BOTTOM OF METADATA
 });
\ No newline at end of file

=== added directory 'www/plugins'
=== added directory 'www/plugins/org.apache.cordova.battery-status'
=== added directory 'www/plugins/org.apache.cordova.battery-status/www'
=== added file 'www/plugins/org.apache.cordova.battery-status/www/battery.js'
--- www/plugins/org.apache.cordova.battery-status/www/battery.js	1970-01-01 00:00:00 +0000
+++ www/plugins/org.apache.cordova.battery-status/www/battery.js	2014-02-19 16:53:58 +0000
@@ -0,0 +1,101 @@
+cordova.define("org.apache.cordova.battery-status.battery", function(require, exports, module) { /*
+ *
+ * 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.
+ *
+*/
+
+/**
+ * This class contains information about the current battery status.