Merge lp:camera-app/staging into lp:camera-app

[Florian Boucault]

New release:
- Reverted revision 637 that was causing a regression where the controls could not be opened in landscape orientation anymore.
- Set Camera.position to switch front/back cameras instead of AdvancedCameraSettings and hardcoded camera indexes

New release:
- Reverted revision 637 that was causing a regression where the controls could not be opened in landscape orientation anymore.
- Set Camera.position to switch front/back cameras instead of AdvancedCameraSettings and hardcoded camera indexes

=== modified file 'CameraApp/advancedcamerasettings.cpp'
--- CameraApp/advancedcamerasettings.cpp	2016-01-28 09:52:25 +0000
+++ CameraApp/advancedcamerasettings.cpp	2016-04-21 10:43:56 +0000
@@ -36,7 +36,6 @@
 
 AdvancedCameraSettings::AdvancedCameraSettings(QObject *parent) :
     QObject(parent),
-    m_activeCameraIndex(0),
     m_cameraObject(0),
     m_camera(0),
     m_deviceSelector(0),
@@ -45,6 +44,7 @@
     m_cameraExposureControl(0),
     m_imageEncoderControl(0),
     m_videoEncoderControl(0),
+    m_cameraInfoControl(0),
     m_hdrEnabled(false)
 {
 }
@@ -183,16 +183,23 @@
     return videoEncoderControl;
 }
 
+QCameraInfoControl* AdvancedCameraSettings::cameraInfoControlFromCamera(QCamera *camera) const
+{
+    QMediaControl *control = mediaControlFromCamera(camera, QCameraInfoControl_iid);
+    QCameraInfoControl *infoControl = qobject_cast<QCameraInfoControl*>(control);
+
+    if (infoControl == 0) {
+        qWarning() << "No info control support";
+    }
+
+    return infoControl;
+}
+
 QObject* AdvancedCameraSettings::camera() const
 {
     return m_cameraObject;
 }
 
-int AdvancedCameraSettings::activeCameraIndex() const
-{
-    return m_activeCameraIndex;
-}
-
 void AdvancedCameraSettings::setCamera(QObject *cameraObject)
 {
     if (cameraObject != m_cameraObject) {
@@ -210,15 +217,25 @@
 
             QVideoDeviceSelectorControl* selector = selectorFromCamera(m_camera);
             m_deviceSelector = selector;
-            if (selector) {
-                m_deviceSelector->setSelectedDevice(m_activeCameraIndex);
-            }
+            connect(m_deviceSelector, SIGNAL(selectedDeviceChanged(int)),
+                    this, SLOT(onSelectedDeviceChanged(int)));
         }
 
         Q_EMIT cameraChanged();
     }
 }
 
+void AdvancedCameraSettings::onSelectedDeviceChanged(int index)
+{
+    Q_UNUSED(index);
+
+    Q_EMIT resolutionChanged();
+    Q_EMIT maximumResolutionChanged();
+    Q_EMIT fittingResolutionChanged();
+    Q_EMIT hasFlashChanged();
+    Q_EMIT videoSupportedResolutionsChanged();
+}
+
 void AdvancedCameraSettings::readCapabilities()
 {
     m_viewFinderControl = viewfinderFromCamera(m_camera);
@@ -249,6 +266,7 @@
 
     m_imageEncoderControl = imageEncoderControlFromCamera(m_camera);
     m_videoEncoderControl = videoEncoderControlFromCamera(m_camera);
+    m_cameraInfoControl = cameraInfoControlFromCamera(m_camera);
 
     Q_EMIT resolutionChanged();
     Q_EMIT maximumResolutionChanged();
@@ -267,22 +285,6 @@
     }
 }
 
-void AdvancedCameraSettings::setActiveCameraIndex(int index)
-{
-    if (index != m_activeCameraIndex) {
-        m_activeCameraIndex = index;
-        if (m_deviceSelector) {
-            m_deviceSelector->setSelectedDevice(m_activeCameraIndex);
-        }
-        Q_EMIT activeCameraIndexChanged();
-        Q_EMIT resolutionChanged();
-        Q_EMIT maximumResolutionChanged();
-        Q_EMIT fittingResolutionChanged();
-        Q_EMIT hasFlashChanged();
-        Q_EMIT videoSupportedResolutionsChanged();
-    }
-}
-
 QSize AdvancedCameraSettings::resolution() const
 {
     if (m_viewFinderControl != 0) {
@@ -417,7 +419,9 @@
             // When using the front camera on krillin, using resolution 640x480 does
             // not work properly and results in stretched videos. Remove it from
             // the list of supported resolutions.
-            if (activeCameraIndex() == 1 && size.width() == 640 && size.height() == 480) {
+            QString currentDeviceName = m_deviceSelector->deviceName(m_deviceSelector->selectedDevice());
+            if (m_cameraInfoControl->cameraPosition(currentDeviceName) == QCamera::FrontFace &&
+                size.width() == 640 && size.height() == 480) {
                 continue;
             }
             sizesAsStrings.append(QString("%1x%2").arg(size.width()).arg(size.height()));

=== modified file 'CameraApp/advancedcamerasettings.h'
--- CameraApp/advancedcamerasettings.h	2016-01-05 13:08:28 +0000
+++ CameraApp/advancedcamerasettings.h	2016-04-21 10:43:56 +0000
@@ -23,6 +23,7 @@
 #include <QObject>
 #include <QMultimedia>
 #include <QtMultimedia/QCamera>
+#include <QtMultimedia/QCameraInfoControl>
 #include <QtMultimedia/QVideoDeviceSelectorControl>
 #include <QtMultimedia/QCameraViewfinderSettingsControl>
 #include <QtMultimedia/QCameraExposureControl>
@@ -37,8 +38,6 @@
 {
     Q_OBJECT
     Q_PROPERTY (QObject* camera READ camera WRITE setCamera NOTIFY cameraChanged)
-    Q_PROPERTY (int activeCameraIndex READ activeCameraIndex WRITE setActiveCameraIndex
-                NOTIFY activeCameraIndexChanged)
     Q_PROPERTY (QSize resolution READ resolution NOTIFY resolutionChanged)
     Q_PROPERTY (QSize imageCaptureResolution READ imageCaptureResolution)
     Q_PROPERTY (QSize videoRecorderResolution READ videoRecorderResolution)
@@ -53,9 +52,7 @@
 public:
     explicit AdvancedCameraSettings(QObject *parent = 0);
     QObject* camera() const;
-    int activeCameraIndex() const;
     void setCamera(QObject* camera);
-    void setActiveCameraIndex(int index);
     QSize resolution() const;
     QSize imageCaptureResolution() const;
     QSize videoRecorderResolution() const;
@@ -73,7 +70,6 @@
 
 Q_SIGNALS:
     void cameraChanged();
-    void activeCameraIndexChanged();
     void resolutionChanged();
     void maximumResolutionChanged();
     void fittingResolutionChanged();
@@ -86,6 +82,7 @@
 private Q_SLOTS:
     void onCameraStateChanged();
     void onExposureValueChanged(int parameter);
+    void onSelectedDeviceChanged(int index);
 
 private:
     QVideoDeviceSelectorControl* selectorFromCamera(QCamera *camera) const;
@@ -97,17 +94,18 @@
     QMediaControl* mediaControlFromCamera(QCamera *camera, const char* iid) const;
     QImageEncoderControl* imageEncoderControlFromCamera(QCamera *camera) const;
     QVideoEncoderSettingsControl* videoEncoderControlFromCamera(QCamera *camera) const;
+    QCameraInfoControl* cameraInfoControlFromCamera(QCamera *camera) const;
 
     QObject* m_cameraObject;
     QCamera* m_camera;
     QVideoDeviceSelectorControl* m_deviceSelector;
-    int m_activeCameraIndex;
     QCameraViewfinderSettingsControl* m_viewFinderControl;
     QCameraControl* m_cameraControl;
     QCameraFlashControl* m_cameraFlashControl;
     QCameraExposureControl* m_cameraExposureControl;
     QImageEncoderControl* m_imageEncoderControl;
     QVideoEncoderSettingsControl* m_videoEncoderControl;
+    QCameraInfoControl* m_cameraInfoControl;
     bool m_hdrEnabled;
 };
 

=== modified file 'ViewFinderGeometry.qml'
--- ViewFinderGeometry.qml	2015-11-03 14:23:10 +0000
+++ ViewFinderGeometry.qml	2016-04-21 10:43:56 +0000
@@ -24,9 +24,9 @@
     property int viewFinderWidth;
     property int viewFinderOrientation;
 
-    property int __cameraWidth: Math.abs(viewFinderOrientation) == 90 ?
+    property int __cameraWidth: Math.abs(viewFinderOrientation) == 90 || Math.abs(viewFinderOrientation) == 270 ?
                                 cameraResolution.height : cameraResolution.width
-    property int __cameraHeight: Math.abs(viewFinderOrientation) == 90 ?
+    property int __cameraHeight: Math.abs(viewFinderOrientation) == 90 || Math.abs(viewFinderOrientation) == 270 ?
                                  cameraResolution.width : cameraResolution.height
 
     property real widthScale: viewFinderWidth / __cameraWidth

=== modified file 'ViewFinderOverlay.qml'
--- ViewFinderOverlay.qml	2016-03-23 14:49:34 +0000
+++ ViewFinderOverlay.qml	2016-04-21 10:43:56 +0000
@@ -55,8 +55,7 @@
         property bool playShutterSound: true
         // FIXME: stores the resolution selected for 2 cameras. Instead it should:
         //  - support any number of cameras
-        //  - not rely on the camera index but on Camera.deviceId
-        // Ref.: http://doc.qt.io/qt-5/qml-qtmultimedia-camera.html#deviceId-prop
+        //  - not assume that camera.deviceId is a string containing an integer
         property string photoResolution0
         property string photoResolution1
 
@@ -99,7 +98,7 @@
     Binding {
         target: camera.imageCapture
         property: "resolution"
-        value: settings["photoResolution" + camera.advanced.activeCameraIndex]
+        value: settings["photoResolution" + camera.deviceId]
     }
 
     Connections {
@@ -220,9 +219,9 @@
         }
 
         // If resolution setting is not supported select the resolution automatically
-        var photoResolution = settings["photoResolution" + camera.advanced.activeCameraIndex];
+        var photoResolution = settings["photoResolution" + camera.deviceId];
         if (!isResolutionAnOption(photoResolution)) {
-            settings["photoResolution" + camera.advanced.activeCameraIndex] = getAutomaticResolution();
+            settings["photoResolution" + camera.deviceId] = getAutomaticResolution();
         }
     }
 
@@ -261,18 +260,18 @@
     }
 
     Connections {
-        target: camera.advanced
-        onActiveCameraIndexChanged: {
-            var hasPhotoResolutionSetting = (settings["photoResolution" + camera.advanced.activeCameraIndex] != "")
+        target: camera
+        onDeviceIdChanged: {
+            var hasPhotoResolutionSetting = (settings["photoResolution" + camera.deviceId] != "")
             // FIXME: use camera.advanced.imageCaptureResolution instead of camera.imageCapture.resolution
             // because the latter is not updated when the backend changes the resolution
-            settings["photoResolution" + camera.advanced.activeCameraIndex] = sizeToString(camera.advanced.imageCaptureResolution);
+            settings["photoResolution" + camera.deviceId] = sizeToString(camera.advanced.imageCaptureResolution);
             settings.videoResolution = sizeToString(camera.advanced.videoRecorderResolution);
             updateResolutionOptions();
 
             // If no resolution has ever been chosen, select one automatically
             if (!hasPhotoResolutionSetting) {
-                settings["photoResolution" + camera.advanced.activeCameraIndex] = getAutomaticResolution();
+                settings["photoResolution" + camera.deviceId] = getAutomaticResolution();
             }
         }
     }
@@ -558,7 +557,7 @@
                 ListModel {
                     id: photoResolutionOptionsModel
 
-                    property string settingsProperty: "photoResolution" + camera.advanced.activeCameraIndex
+                    property string settingsProperty: "photoResolution" + camera.deviceId
                     property string icon: ""
                     property string label: sizeToAspectRatio(stringToSize(settings[settingsProperty]))
                     property bool isToggle: false
@@ -916,14 +915,8 @@
 
             MouseArea {
                 id: manualFocusMouseArea
+                anchors.fill: parent
                 objectName: "manualFocusMouseArea"
-                anchors {
-                    fill: parent
-                    // Pinch gestures need more clearance at the edges of the screen, but
-                    // tap to focus should be safe all the way to the edges themselves instead.
-                    leftMargin: -bottomEdgeIndicators.height
-                    rightMargin: -bottomEdgeIndicators.height
-                }
                 enabled: camera.focus.isFocusPointModeSupported(Camera.FocusPointCustom) &&
                          !camera.photoCaptureInProgress && !camera.timedCaptureInProgress
                 onClicked: {

=== modified file 'ViewFinderView.qml'
--- ViewFinderView.qml	2016-03-23 14:49:34 +0000
+++ ViewFinderView.qml	2016-04-21 10:43:56 +0000
@@ -56,7 +56,7 @@
         id: camera
         captureMode: Camera.CaptureStillImage
         cameraState: Camera.UnloadedState
-        StateSaver.properties: "captureMode"
+        StateSaver.properties: "captureMode, position"
         property bool failedToConnect: false
 
         function manualFocus(x, y) {
@@ -89,7 +89,6 @@
         property AdvancedCameraSettings advanced: AdvancedCameraSettings {
             id: advancedCamera
             camera: camera
-            StateSaver.properties: "activeCameraIndex"
         }
 
         /* Use only digital zoom for now as it's what phone cameras mostly use.
@@ -171,7 +170,7 @@
                     viewFinder.width = 1;
                     viewFinder.height = 1;
                     camera.cameraState = Camera.LoadedState;
-                    camera.advanced.activeCameraIndex = (camera.advanced.activeCameraIndex === 0) ? 1 : 0;
+                    camera.position = (camera.position === Camera.FrontFace) ? Camera.BackFace : Camera.FrontFace;
                     decideCameraState();
                     viewFinderSwitcherRotation.angle = 180;
                 }

=== modified file 'camera-app.qml'
--- camera-app.qml	2016-03-23 14:49:34 +0000
+++ camera-app.qml	2016-04-21 10:43:56 +0000
@@ -26,8 +26,8 @@
 Window {
     id: main
     objectName: "main"
-    width: height * viewFinderView.aspectRatio
-    height: units.gu(80)
+    width: Math.min(Screen.width, height * viewFinderView.aspectRatio)
+    height: Math.min(Screen.height, units.gu(80))
     color: "black"
     title: "Camera"
     // special flag only supported by Unity8/MIR so far that hides the shell's

=== modified file 'debian/control'
--- debian/control	2016-03-09 10:29:26 +0000
+++ debian/control	2016-04-21 10:43:56 +0000
@@ -65,5 +65,6 @@
          python3-autopilot,
          python3-wand,
          python3-mediainfodll,
+         python3-fixtures,
 Description: Test package for the camera app
  Autopilot tests for the camera-app package

=== modified file 'tests/autopilot/camera_app/emulators/main_window.py'
--- tests/autopilot/camera_app/emulators/main_window.py	2016-03-23 15:42:31 +0000
+++ tests/autopilot/camera_app/emulators/main_window.py	2016-04-21 10:43:56 +0000
@@ -196,15 +196,29 @@
         view_switcher.settling.wait_for(False)
         view_switcher.switching.wait_for(False)
         viewfinder.inView.wait_for(True)
+
         x, y = view_switcher.x, view_switcher.y
         w, h = view_switcher.width, view_switcher.height
-
-        tx = x + (w // 2)
-        ty = y + (h // 2)
+        center_x = x + (w // 2)
+        center_y = y + (h // 2)
 
         # FIXME: a rate higher than 1 does not always make view_switcher move
-        self.app.pointing_device.drag(tx, ty, x, ty, rate=1,
-                                      time_between_events=0.0001)
+        if view_switcher.state == "PORTRAIT":
+            self.app.pointing_device.drag(center_x, center_y,
+                                          x, center_y,
+                                          rate=1, time_between_events=0.0001)
+        elif view_switcher.state == "LANDSCAPE":
+            self.app.pointing_device.drag(center_x, y + (3 * h // 4),
+                                          center_x, center_y,
+                                          rate=1, time_between_events=0.0001)
+        elif view_switcher.state == "INVERTED_LANDSCAPE":
+            self.app.pointing_device.drag(center_x, y + (h // 4),
+                                          center_x, center_y,
+                                          rate=1, time_between_events=0.0001)
+        else:
+            self.app.pointing_device.drag(center_x, center_y,
+                                          x + w - 1, center_y,
+                                          rate=1, time_between_events=0.0001)
 
         testCase.assertThat(viewfinder.inView, Eventually(Equals(False)))
         view_switcher.settling.wait_for(False)
@@ -218,16 +232,30 @@
         view_switcher.settling.wait_for(False)
         view_switcher.switching.wait_for(False)
         viewfinder.inView.wait_for(False)
+
         x, y = view_switcher.x, view_switcher.y
         w, h = view_switcher.width, view_switcher.height
-
-        tx = x + (w // 2)
-        ty = y + (h // 2)
+        center_x = x + (w // 2)
+        center_y = y + (h // 2)
 
         # FIXME: a rate higher than 1 does not always make view_switcher move
-        self.app.pointing_device.drag(
-            tx, ty, (tx + view_switcher.width // 2), ty, rate=1,
-            time_between_events=0.0001)
+        if view_switcher.state == "PORTRAIT":
+            self.app.pointing_device.drag(center_x, center_y,
+                                          x + w - 1, center_y,
+                                          rate=1, time_between_events=0.0001)
+        elif view_switcher.state == "LANDSCAPE":
+            self.app.pointing_device.drag(center_x, y + (h // 4),
+                                          center_x, center_y,
+                                          rate=1, time_between_events=0.0001)
+        elif view_switcher.state == "INVERTED_LANDSCAPE":
+            self.app.pointing_device.drag(center_x, y + (3 * h // 4),
+                                          center_x, center_y,
+                                          rate=1, time_between_events=0.0001)
+        else:
+            self.app.pointing_device.drag(center_x, center_y,
+                                          x, center_y,
+                                          rate=1, time_between_events=0.0001)
+
         testCase.assertThat(viewfinder.inView, Eventually(Equals(True)))
         view_switcher.settling.wait_for(False)
         view_switcher.switching.wait_for(False)

=== modified file 'tests/autopilot/camera_app/emulators/panel.py'
--- tests/autopilot/camera_app/emulators/panel.py	2016-03-18 12:24:36 +0000
+++ tests/autopilot/camera_app/emulators/panel.py	2016-04-21 10:43:56 +0000
@@ -35,13 +35,29 @@
 
     def _drag_to_open(self):
         x, y, _, _ = self.globalRect
-        line_x = x + self.width * 0.50
-        start_y = y + self.height - 1
-        stop_y = y
+        center_x = x + self.width * 0.50
+        center_y = y + self.height * 0.50
+
+        view_switcher = self.get_root_instance().wait_select_single(
+            objectName="viewSwitcher")
 
         # FIXME: a rate higher than 1 does not always make panel move
-        self.pointing_device.drag(line_x, start_y, line_x, stop_y, rate=1,
-                                  time_between_events=0.0001)
+        if view_switcher.state == "PORTRAIT":
+            self.pointing_device.drag(center_x, y + self.height - 1,
+                                      center_x, y, rate=1,
+                                      time_between_events=0.0001)
+        elif view_switcher.state == "LANDSCAPE":
+            self.pointing_device.drag(0, center_y,
+                                      self.height - 1, center_y, rate=1,
+                                      time_between_events=0.0001)
+        elif view_switcher.state == "INVERTED_LANDSCAPE":
+            self.pointing_device.drag(x + self.height - 1, center_y,
+                                      x, center_y, rate=1,
+                                      time_between_events=0.0001)
+        else:
+            self.pointing_device.drag(center_x, y + self.height - 1,
+                                      center_x, y, rate=1,
+                                      time_between_events=0.0001)
 
     @autopilot_logging.log_action(logger.info)
     def close(self):
@@ -55,10 +71,25 @@
 
     def _drag_to_close(self):
         x, y, _, _ = self.globalRect
-        line_x = x + self.width - 1
-        start_y = y
-        stop_y = y + self.height - 1
+        center_y = y + self.height * 0.50
+
+        view_switcher = self.get_root_instance().wait_select_single(
+            objectName="viewSwitcher")
 
         # FIXME: a rate higher than 1 does not always make panel move
-        self.pointing_device.drag(line_x, start_y, line_x, stop_y, rate=1,
-                                  time_between_events=0.0001)
+        if view_switcher.state == "PORTRAIT":
+            self.pointing_device.drag(x, y,
+                                      x, y + self.height - 1, rate=1,
+                                      time_between_events=0.0001)
+        elif view_switcher.state == "LANDSCAPE":
+            self.pointing_device.drag(self.height - 1, center_y,
+                                      0, center_y, rate=1,
+                                      time_between_events=0.0001)
+        elif view_switcher.state == "INVERTED_LANDSCAPE":
+            self.pointing_device.drag(x, center_y,
+                                      x + self.height - 1, center_y, rate=1,
+                                      time_between_events=0.0001)
+        else:
+            self.pointing_device.drag(x, y,
+                                      x, y + self.height - 1, rate=1,
+                                      time_between_events=0.0001)

=== modified file 'tests/autopilot/camera_app/tests/__init__.py'
--- tests/autopilot/camera_app/tests/__init__.py	2016-03-23 10:30:32 +0000
+++ tests/autopilot/camera_app/tests/__init__.py	2016-04-21 10:43:56 +0000
@@ -17,6 +17,8 @@
 from autopilot.testcase import AutopilotTestCase
 
 from camera_app.emulators.main_window import MainWindow
+from camera_app.ubuntu_system_tests.helpers.camera.fixture_setup import (
+    SetCameraAccessRequests)
 
 
 CUSTOM_PROXY_OBJECT_BASE = ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase
@@ -41,6 +43,7 @@
     sample_dir = resource_filename('camera_app', 'data')
 
     def setUp(self):
+        self.useFixture(SetCameraAccessRequests())
         # Remove configuration file
         config_file = os.path.expanduser(
             "~/.config/com.ubuntu.camera/com.ubuntu.camera.conf")

=== modified file 'tests/autopilot/camera_app/tests/test_focus.py'
--- tests/autopilot/camera_app/tests/test_focus.py	2016-03-18 12:04:56 +0000
+++ tests/autopilot/camera_app/tests/test_focus.py	2016-04-21 10:43:56 +0000
@@ -50,12 +50,12 @@
         # Then try on the side edges and top edge to verify they
         # are focusable too
         self.verify_focus_ring_after_click_at(focus_ring,
-                                              geometry.globalRect.x + 1, mid_y)
+                                              geometry.globalRect.x + 100,
+                                              mid_y)
         self.verify_focus_ring_after_click_at(focus_ring,
                                               geometry.globalRect.x +
-                                              geometry.globalRect.width - 1,
+                                              geometry.globalRect.width - 100,
                                               mid_y)
-        self.verify_focus_ring_after_click_at(focus_ring, mid_x, 1)
 
         # Switch cameras, wait for camera to settle, and try again
         self.pointing_device.move_to_object(switch_cameras)
@@ -68,12 +68,12 @@
         # Then try on the left, right and above the center to verify they
         # are focusable too
         self.verify_focus_ring_after_click_at(focus_ring,
-                                              geometry.globalRect.x + 1, mid_y)
+                                              geometry.globalRect.x + 100,
+                                              mid_y)
         self.verify_focus_ring_after_click_at(focus_ring,
                                               geometry.globalRect.x +
-                                              geometry.globalRect.width - 1,
+                                              geometry.globalRect.width - 100,
                                               mid_y)
-        self.verify_focus_ring_after_click_at(focus_ring, mid_x, 1)
 
     @unittest.skipIf(model() == 'Galaxy Nexus', 'Unusable with Mir on maguro')
     def test_focus_invalid(self):

=== modified file 'tests/autopilot/camera_app/tests/test_options.py'
--- tests/autopilot/camera_app/tests/test_options.py	2016-03-18 12:04:56 +0000
+++ tests/autopilot/camera_app/tests/test_options.py	2016-04-21 10:43:56 +0000
@@ -41,10 +41,10 @@
         # check overlay is opened
         self.assertThat(bottom_edge.opened, Eventually(Equals(True)))
 
-        # tap on the bottom of the viewfinder to close overlay
+        # tap on the top of the viewfinder to close overlay
         viewfinder = self.main_window.get_viewfinder()
         x = viewfinder.globalRect.x + viewfinder.width / 2.0
-        y = viewfinder.globalRect.y + viewfinder.height - 1.0
+        y = viewfinder.globalRect.y + 1.0
         self.pointing_device.move(x, y)
         self.pointing_device.click()
 

=== added directory 'tests/autopilot/camera_app/ubuntu_system_tests'
=== added file 'tests/autopilot/camera_app/ubuntu_system_tests/__init__.py'
--- tests/autopilot/camera_app/ubuntu_system_tests/__init__.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/camera_app/ubuntu_system_tests/__init__.py	2016-04-21 10:43:56 +0000
@@ -0,0 +1,19 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Ubuntu System Tests
+# Copyright (C) 2015 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#

=== added directory 'tests/autopilot/camera_app/ubuntu_system_tests/helpers'
=== added file 'tests/autopilot/camera_app/ubuntu_system_tests/helpers/__init__.py'
--- tests/autopilot/camera_app/ubuntu_system_tests/helpers/__init__.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/camera_app/ubuntu_system_tests/helpers/__init__.py	2016-04-21 10:43:56 +0000
@@ -0,0 +1,19 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Ubuntu System Tests
+# Copyright (C) 2015 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#

=== added file 'tests/autopilot/camera_app/ubuntu_system_tests/helpers/backup_restore_fixture.py'
--- tests/autopilot/camera_app/ubuntu_system_tests/helpers/backup_restore_fixture.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/camera_app/ubuntu_system_tests/helpers/backup_restore_fixture.py	2016-04-21 10:43:56 +0000
@@ -0,0 +1,135 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Ubuntu System Tests
+# Copyright (C) 2015 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import fixtures
+import os
+import shutil
+import time
+
+from camera_app.ubuntu_system_tests.helpers import file_system as fs
+from camera_app.ubuntu_system_tests.helpers import sqlite
+
+DEFAULT_STORE_ROOT = os.path.expanduser('~/.tmp_backup')
+
+
+class BackupRestoreFixture(fixtures.Fixture):
+    """Generic fixture class to backup and restore a specific directory."""
+
+    def __init__(self, backup_dir, storage_root_dir=DEFAULT_STORE_ROOT,
+                 start_clean=True):
+        """
+        :param backup_dir: Directory to be backed up.
+        :param storage_root_dir: Root directoty to use as backup.
+        :param start_clean: Whether to clean the backup directory.
+        """
+        if not os.path.exists(storage_root_dir):
+            os.makedirs(storage_root_dir)
+        self.backup_dir = backup_dir
+        self.storage_dir = fixtures.TempDir(storage_root_dir)
+        self.start_clean = start_clean
+
+    def setUp(self):
+        """Backup the required directory and register restore actions."""
+        super().setUp()
+        self.useFixture(self.storage_dir)
+        self.addCleanup(self._restore_directory)
+        shutil.rmtree(self.storage_dir.path)
+        if os.path.exists(self.backup_dir):
+            if self.start_clean:
+                fs.move_folder_contents(self.backup_dir, self.storage_dir.path)
+            else:
+                shutil.copytree(self.backup_dir, self.storage_dir.path)
+
+    def _restore_directory(self):
+        """Move the backup data back to original location."""
+        if os.path.exists(self.backup_dir):
+            fs.clean_dir(self.backup_dir)
+        if os.path.exists(self.storage_dir.path):
+            fs.move_folder_contents(self.storage_dir.path, self.backup_dir)
+
+
+class BackupRestoreRequestAccessFixture(fixtures.Fixture):
+    """Fill the access requests for the an app by adding the answer in the
+    its db and restoring the original data after the test execution."""
+
+    REQUESTS_SCHEMA = 'ApplicationId, Feature, Timestamp, Answer'
+
+    def __init__(self, db, app_id, feature, answer):
+        """ Create a Fixture
+        :param db: the path to the db
+        :param app_id: the application id as it appears in the db
+        :param feature: the feature as it appears in the db
+        :param answer: True to allow access, False to deny access
+        """
+        self.db = db
+        self.app_id = app_id
+        self.feature = feature
+        self.timestamp = int(str(time.time()).replace('.', ''))
+        self.answer = int(answer)
+
+    def setUp(self):
+        super().setUp()
+
+        # Get the initial request access state
+        initial_state = self.get_access_request()
+
+        # Fill the db with the desired answer
+        self.fill_access_request(self.app_id, self.feature, self.timestamp,
+                                 self.answer)
+
+        # Restore the initial access state
+        self.clean_request(initial_state)
+
+    def clean_request(self, state):
+        """ Restore this request in case there was an initial state, otherwise
+        delete the access request when there wasn't an initial state
+        """
+        if state:
+            self.addCleanup(self.fill_access_request, *state)
+        else:
+            self.addCleanup(self.delete_access_request)
+
+    def fill_access_request(self, app_id, feature, timestamp, answer):
+        """ Complete the db with the desired state to allow/deny the access
+        to the app_id from the camera app
+        """
+        cmd = "INSERT OR REPLACE INTO requests (Id, {schema}) VALUES " \
+              "((SELECT Id FROM requests WHERE ApplicationId = '{app_id}'), " \
+              "'{app_id}', {feature}, {timestamp}, {answer});".\
+            format(schema=self.REQUESTS_SCHEMA, app_id=app_id,
+                   feature=feature, timestamp=timestamp, answer=answer)
+        sqlite.execute(self.db, cmd)
+
+    def delete_access_request(self):
+        """ Delete the current state  """
+        cmd = "DELETE FROM requests WHERE ApplicationId = '{app_id}' AND " \
+              "Feature = {feature}".format(app_id=self.app_id,
+                                           feature=self.feature)
+        sqlite.execute(self.db, cmd)
+
+    def get_access_request(self):
+        """ Retrieve the first access request in the db for the current
+        application id and feature
+        :return: a list with the values following the table structure
+        """
+        cmd = "SELECT {schema} FROM requests WHERE ApplicationId = " \
+              "'{app_id}' AND Feature = {feature}".\
+            format(schema=self.REQUESTS_SCHEMA, app_id=self.app_id,
+                   feature=self.feature)
+        return sqlite.query_one(self.db, cmd)

=== added directory 'tests/autopilot/camera_app/ubuntu_system_tests/helpers/camera'
=== added file 'tests/autopilot/camera_app/ubuntu_system_tests/helpers/camera/__init__.py'
--- tests/autopilot/camera_app/ubuntu_system_tests/helpers/camera/__init__.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/camera_app/ubuntu_system_tests/helpers/camera/__init__.py	2016-04-21 10:43:56 +0000
@@ -0,0 +1,19 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Ubuntu System Tests
+# Copyright (C) 2015 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#

=== added file 'tests/autopilot/camera_app/ubuntu_system_tests/helpers/camera/fixture_setup.py'
--- tests/autopilot/camera_app/ubuntu_system_tests/helpers/camera/fixture_setup.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/camera_app/ubuntu_system_tests/helpers/camera/fixture_setup.py	2016-04-21 10:43:56 +0000
@@ -0,0 +1,58 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Ubuntu System Tests
+# Copyright (C) 2015 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import fixtures
+import os
+
+from camera_app.ubuntu_system_tests.helpers import file_system as fs
+from camera_app.ubuntu_system_tests.helpers.backup_restore_fixture import (
+    BackupRestoreRequestAccessFixture)
+
+SERVICE_DB = os.path.join(fs.DIR_HOME_LOCAL, 'share', 'CameraService',
+                          'trust.db')
+AUDIO_DB = os.path.join(fs.DIR_HOME_LOCAL, 'share', 'PulseAudio', 'trust.db')
+
+FEATURE = 0
+APP_ID = 'com.ubuntu.camera_camera'
+
+
+class SetCameraAccessRequests(fixtures.Fixture):
+    """ Fill the camera and audio access request for the camera app and
+    restore their initial state during the cleanup. """
+
+    def __init__(self, camera=True, audio=True):
+        """ Init the fixture
+        :param camera: Desired answer for the camera service
+        :param audio: Desired answer for the audio service
+        """
+        self.camera = camera
+        self.audio = audio
+
+    def setUp(self):
+        super().setUp()
+
+        self.useFixture(BackupRestoreRequestAccessFixture(SERVICE_DB,
+                                                          APP_ID,
+                                                          FEATURE,
+                                                          self.camera))
+        self.useFixture(BackupRestoreRequestAccessFixture(AUDIO_DB,
+                                                          APP_ID,
+                                                          FEATURE,
+                                                          self.audio))

=== added file 'tests/autopilot/camera_app/ubuntu_system_tests/helpers/file_system.py'
--- tests/autopilot/camera_app/ubuntu_system_tests/helpers/file_system.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/camera_app/ubuntu_system_tests/helpers/file_system.py	2016-04-21 10:43:56 +0000
@@ -0,0 +1,359 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Ubuntu System Tests
+# Copyright (C) 2015 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import filecmp
+import getpass
+import glob
+import hashlib
+import logging
+import random
+import os
+import shutil
+import string
+import subprocess
+
+logger = logging.getLogger(__name__)
+
+FILE_PREFIX = 'file://'
+IMAGE_PREFIX = 'image://'
+MUSIC_PREFIX = 'music://'
+ALBUM_PREFIX = 'album://'
+
+DIR_MUSIC = 'Music'
+DIR_PICTURES = 'Pictures'
+DIR_VIDEOS = 'Videos'
+DIR_DOCUMENTS = 'Documents'
+DIR_DOWNLOADS = 'Downloads'
+DIR_CONFIG = '.config'
+DIR_CACHE = '.cache'
+DIR_LOCAL = '.local'
+DIR_CAMERA_PICTURES = 'com.ubuntu.camera'
+DIR_MUSIC_CONFIG = 'com.ubuntu.music'
+DIR_GALLERY = 'com.ubuntu.gallery'
+DIR_WEBBROWSER = 'webbrowser-app'
+DIR_SHARE = 'share'
+DIR_IMPORTED = 'imported'
+
+# Home dirs
+DIR_HOME = os.path.expanduser('~')
+DIR_HOME_MUSIC = os.path.join(DIR_HOME, DIR_MUSIC)
+DIR_HOME_PICTURES = os.path.join(DIR_HOME, DIR_PICTURES)
+DIR_HOME_VIDEOS = os.path.join(DIR_HOME, DIR_VIDEOS)
+DIR_HOME_DOCUMENTS = os.path.join(DIR_HOME, DIR_DOCUMENTS)
+DIR_HOME_DOWNLOADS = os.path.join(DIR_HOME, DIR_DOWNLOADS)
+DIR_HOME_CONFIG = os.path.join(DIR_HOME, DIR_CONFIG)
+DIR_HOME_LOCAL = os.path.join(DIR_HOME, DIR_LOCAL)
+DIR_HOME_CACHE = os.path.join(DIR_HOME, DIR_CACHE)
+
+# .share dir
+DIR_HOME_LOCAL_SHARE = os.path.join(DIR_HOME_LOCAL, DIR_SHARE)
+
+# Camera dirs
+DIR_HOME_CAMERA_PICTURES = os.path.join(DIR_HOME_PICTURES,
+                                        DIR_CAMERA_PICTURES)
+DIR_HOME_CAMERA_VIDEOS = os.path.join(DIR_HOME_VIDEOS,
+                                      DIR_CAMERA_PICTURES)
+DIR_HOME_CAMERA_CONFIG = os.path.join(DIR_HOME_CONFIG,
+                                      DIR_CAMERA_PICTURES)
+DIR_HOME_CAMERA_THUMBNAILS = os.path.join(DIR_HOME, DIR_CACHE,
+                                          DIR_CAMERA_PICTURES)
+
+# Gallery dirs
+DIR_HOME_CACHE_GALLERY = os.path.join(DIR_HOME_CACHE, DIR_GALLERY)
+
+# Music dirs
+DIR_HOME_MUSIC_CONFIG = os.path.join(DIR_HOME_CONFIG, DIR_MUSIC_CONFIG)
+
+# Pictures download
+DIR_HOME_PICTURES_IMPORTED = os.path.join(DIR_HOME_PICTURES, DIR_IMPORTED)
+
+# Webbrowser dirs
+DIR_HOME_LOCAL_SHARE_WEBBROWSER = os.path.join(DIR_HOME_LOCAL_SHARE,
+                                               DIR_WEBBROWSER)
+
+# Test data dirs
+DIR_TESTS = os.path.realpath(__file__ + '/../../tests')
+DIR_TEST_DATA = os.path.join(DIR_TESTS, 'data')
+DIR_TEST_DATA_AUDIO = os.path.join(DIR_TEST_DATA, 'audio')
+DIR_TEST_DATA_HTML = os.path.join(DIR_TEST_DATA, 'html')
+DIR_TEST_DATA_IMAGES = os.path.join(DIR_TEST_DATA, 'images')
+DIR_TEST_DATA_SCOPES = os.path.join(DIR_TEST_DATA, 'scopes')
+DIR_TEST_DATA_TEXT = os.path.join(DIR_TEST_DATA, 'text')
+DIR_TEST_DATA_VIDEO = os.path.join(DIR_TEST_DATA, 'video')
+DIR_TEST_DATA_DEVICES = os.path.join(DIR_TEST_DATA, 'devices')
+DIR_TEST_DATA_DATABASES = os.path.join(DIR_TEST_DATA, 'databases')
+
+# Media dirs
+DIR_MEDIA = '/media'
+DIR_MEDIA_ROOT = os.path.join(DIR_MEDIA, getpass.getuser())
+
+# Misc dirs
+DIR_TEMP = '/tmp'
+
+# Preinstalled click apps
+DIR_PREINSTALLED_CLICK_APPS = '/usr/share/click/preinstalled/'
+
+
+def delete_file(file_name):
+    """Delete the file passed as parameter. In case the file does not
+    exist, the deletion is skipped"""
+    if os.path.isfile(file_name):
+        os.unlink(file_name)
+
+
+def create_directory_if_not_exists(directory):
+    """Create the directory passed as parameter, if it does not
+    already exist"""
+    if not os.path.exists(directory):
+        os.makedirs(directory)
+
+
+def clean_files(dir_path):
+    """Delete all the files in the directory.
+    Subdirs are not deleted"""
+    for root, dirs, files in os.walk(dir_path):
+        for file in files:
+            os.unlink(os.path.join(root, file))
+
+
+def files_in_dir(dir_path):
+    """Retrieve all the files in the directory"""
+    f = []
+    for (root, dirs, files) in os.walk(dir_path):
+        f.extend(files)
+        break
+    return f
+
+
+def recursive_files_in_dir(root):
+    """Recursively search root dir and return list of absolute file paths."""
+    file_list = []
+    for dir, subdirs, files in os.walk(root):
+        root_dir = os.path.join(root, dir)
+        for file in files:
+            file_list.append(os.path.abspath(os.path.join(root_dir, file)))
+    return file_list
+
+
+def remove_dir(dir_path):
+    """Remove the directory"""
+    if os.path.isdir(dir_path):
+        shutil.rmtree(dir_path, True)
+
+
+def clean_dir(dir_path):
+    """Delete all the content of the directory"""
+    if os.path.isdir(dir_path):
+        for obj in os.listdir(dir_path):
+            obj_path = os.path.join(dir_path, obj)
+            if os.path.isfile(obj_path):
+                os.remove(obj_path)
+            else:
+                remove_dir(obj_path)
+
+
+def move_folder_contents(src_root, dst_root):
+    """
+    Move each top-level item individually from src folder to dest folder
+    leaving the top-level folder in place. Result will be an empty src folder
+    with all items moved to dest folder.
+
+    :param src_folder: The folder containing content to move
+    :parap dst_folder: The destination folder for all content
+
+    """
+    if os.path.isdir(src_root):
+        for item in os.listdir(src_root):
+            src = os.path.join(src_root, item)
+            dst = os.path.join(dst_root, item)
+            dst_folder = os.path.dirname(dst)
+            if not os.path.exists(dst_folder):
+                os.makedirs(dst_folder)
+            shutil.move(src, dst)
+
+
+def calculate_file_sha1(file_path):
+    """Calculates the sha1 digest for the file
+    :param file_path: The path to the file to calculate the sha1 digest
+    :return The sha1 digest for the file passed as parameter
+    :raise EnvironmentError: If the file couldn't be opened
+    """
+    sha = hashlib.sha1()
+    with open(file_path, 'rb') as f:
+        while True:
+            block = f.read(1024)
+            if not block:
+                break
+            sha.update(block)
+        return sha.hexdigest()
+
+
+def get_random_string(length=10):
+    """Get a string with random content"""
+    return ''.join(random.choice(string.ascii_uppercase) for i in
+                   range(length))
+
+
+def compare_files(file_1, file_2):
+    """Return True if files match exactly, False otherwise."""
+    return filecmp.cmp(file_1, file_2)
+
+
+def _get_media_folders_from_root(root):
+    """Return a list of Music, Pictures or Video folders present at root."""
+    directories = []
+    for directory in [DIR_MUSIC, DIR_PICTURES, DIR_VIDEOS]:
+        sub_directory = os.path.join(root, directory)
+        if os.path.isdir(sub_directory):
+            directories.append(sub_directory)
+    return directories
+
+
+def is_media_folder_dir(media_dir):
+    """
+    Indicate if the media dir exists or not and checks its permissions
+    :param media_dir: The media dir required such as: Music, Videos, etc
+    :return: True if the media dir exists and False otherwise
+    """
+    try:
+        dir = get_media_folder_dir(media_dir)
+        return os.access(dir, os.R_OK) and os.access(dir, os.W_OK)
+    except RuntimeError:
+        return False
+
+
+def get_media_folder_dir(media_dir):
+    """Get the first media folders that matches with the media dir passed as
+    parameter.
+    :param media_dir: The media dir required such as: Music, Videos, etc
+    :return: The path to the media path
+    :raises: RuntimeError: when the media dir does not exist
+    """
+    if not os.path.isdir(DIR_MEDIA_ROOT):
+        raise RuntimeError('Media directory does not exist: ' + DIR_MEDIA_ROOT)
+
+    media_dirs = glob.glob(DIR_MEDIA_ROOT + '/*/{name}'.format(name=media_dir))
+    if not media_dirs:
+        raise RuntimeError('Media directory does not exist.')
+
+    return media_dirs[0]
+
+
+def _get_media_folders_for_home_folder():
+    """Get media folders from home folder."""
+    return _get_media_folders_from_root(DIR_HOME)
+
+
+def _get_media_folders_for_media_devices():
+    """Get media directories for any storage devices present."""
+    directories = []
+    if os.path.exists(DIR_MEDIA_ROOT):
+        for directory in os.listdir(DIR_MEDIA_ROOT):
+            media_directory = os.path.abspath(
+                os.path.join(DIR_MEDIA_ROOT, directory))
+            directories += _get_media_folders_from_root(media_directory)
+    return directories
+
+
+def get_media_folder_list():
+    """Return a list of media folder paths for current user."""
+    home_folders = _get_media_folders_for_home_folder()
+    media_folders = _get_media_folders_for_media_devices()
+    return home_folders + media_folders
+
+
+def create_random_file(path, ext='', length=10):
+    """ Create a file with random name and content in the specified dir
+    :param path: The path to create the file
+    :param ext: The extension for the file
+    :param length: the length of the file content
+    :return: The path of the created file
+    """
+    file_path = os.path.join(path, get_random_string() + ext)
+    if os.path.isfile(file_path):
+        raise RuntimeError('The file to be created already exists')
+
+    with open(file_path, 'w') as f:
+        f.write(get_random_string(length))
+
+    return file_path
+
+
+def get_file_path(path):
+    return FILE_PREFIX + path
+
+
+def remove_file_path(file_path):
+    return file_path.split(FILE_PREFIX)[1]
+
+
+def create_empty_file(file_path):
+    """ Create an empty file in case the file does not exist, otherwise skip
+    :param file_path: the path to the file
+    """
+    if not os.path.exists(file_path):
+        subprocess.call('touch {}'.format(file_path), shell=True)
+
+
+def _get_free_space(cmd, line):
+    """ Retrieve the free scpace in the disk measured in KB using df command
+    :param cmd: df command line
+    :param line: line in which the desired results are displayed
+    """
+    # df output is (device, size, used, available, percent, mountpoint)
+    return int(
+        subprocess.check_output(cmd, universal_newlines=True,
+                                shell=True).split('\n')[line].split()[3])
+
+
+def get_disk_usage(path):
+    """ Retrieve the usage in KB used in a specific path, in case the path is
+    a dir, the result includes the subdirs
+    """
+    return int(subprocess.check_output('du -bs {}'.format(path),
+                                       universal_newlines=True,
+                                       shell=True).split()[0])
+
+
+def get_user_data_free_space():
+    """ Retrieve the free scpace in /userdata disk measured in KB
+    :return:
+    """
+    return _get_free_space('df /userdata', 1)
+
+
+def get_total_free_space():
+    """ Retrieve the free scpace in the disk measured in KB """
+    return _get_free_space('df --total', -2)
+
+
+def get_content_list_from_file_list(file_path_list, sort_content=False):
+    """Return a list of file contents from a list of file paths.
+    :param file_path_list: List of file paths to read.
+    :param sort_content: Whether to sort return list by content.
+    :return: List of file contents.
+    """
+    content_list = []
+    for file_path in file_path_list:
+        with open(file_path, 'rb') as f:
+            content_list.append(f.read())
+    if sort_content:
+        content_list = sorted(content_list)
+    return content_list

=== added file 'tests/autopilot/camera_app/ubuntu_system_tests/helpers/sqlite.py'
--- tests/autopilot/camera_app/ubuntu_system_tests/helpers/sqlite.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/camera_app/ubuntu_system_tests/helpers/sqlite.py	2016-04-21 10:43:56 +0000
@@ -0,0 +1,62 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Ubuntu System Tests
+# Copyright (C) 2015 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import sqlite3
+
+
+def open_db(db):
+    """ Open the sqlite db
+    :param db: The path to the DB
+    :return: the connection to the db
+    """
+    try:
+        conn = sqlite3.connect(db)
+    except sqlite3.Error as e:
+        e.args += 'DB {} cannot be opened'.format(db)
+        raise
+
+    return conn
+
+
+def query_one(db, command):
+    """ Query the db an retrieve one result
+    :param db: The path to the db
+    :param command: The query command
+    :return: a list with the query result
+    """
+    conn = open_db(db)
+
+    with conn:
+        cur = conn.cursor()
+        cur.execute(command)
+        return cur.fetchone()
+
+
+def execute(db, command, **kwargs):
+    """ Execute a command in the specified db
+    :param db: The path to the db
+    :param command: The command to execute
+    :param **kwargs: Keyword arguments for parameter substitution
+    """
+    conn = open_db(db)
+
+    with conn:
+        c = conn.cursor()
+        c.execute(command, kwargs)
+        conn.commit()