Merge lp:~fboucault/camera-app/fix_test_video_resolution into lp:camera-app

[Florian Boucault]

Fix AP test camera_app.tests.test_capture.TestCapture.test_video_resolution_setting_switching_cameras: use selected resolution from current camera as expected resolution.

Unmerged revisions

=== modified file 'BottomEdgeIndicators.qml'
--- BottomEdgeIndicators.qml	2015-10-22 12:21:14 +0000
+++ BottomEdgeIndicators.qml	2015-11-30 15:11:56 +0000
@@ -84,7 +84,7 @@
                     id: indicatorIcon
                     anchors.fill: parent
                     color: "white"
-                    name: modelData && modelData.isToggle ? modelData.icon : modelData.get(model.selectedIndex).icon
+                    name: modelData && modelData.isToggle ? modelData.icon : (modelData.get(model.selectedIndex) ? modelData.get(model.selectedIndex).icon : "")
                     source: name ? "image://theme/%1".arg(name) : (modelData.iconSource || "")
                     visible: source != ""
                 }

=== modified file 'CameraApp/advancedcamerasettings.cpp'
--- CameraApp/advancedcamerasettings.cpp	2015-10-27 09:17:27 +0000
+++ CameraApp/advancedcamerasettings.cpp	2015-11-30 15:11:56 +0000
@@ -26,6 +26,10 @@
 #include <QtMultimedia/QVideoDeviceSelectorControl>
 #include <QtMultimedia/QCameraFlashControl>
 #include <QtMultimedia/QCameraExposureControl>
+#include <QGuiApplication>
+#include <QScreen>
+
+#include <cmath>
 
 // Definition of this enum value is duplicated in qtubuntu-camera
 static const QCameraExposure::ExposureMode ExposureHdr = static_cast<QCameraExposure::ExposureMode>(QCameraExposure::ExposureModeVendor + 1);
@@ -222,6 +226,12 @@
         QObject::connect(m_cameraControl,
                          SIGNAL(captureModeChanged(QCamera::CaptureModes)),
                          this, SIGNAL(resolutionChanged()));
+        QObject::connect(m_cameraControl,
+                         SIGNAL(captureModeChanged(QCamera::CaptureModes)),
+                         this, SIGNAL(maximumResolutionChanged()));
+        QObject::connect(m_cameraControl,
+                         SIGNAL(captureModeChanged(QCamera::CaptureModes)),
+                         this, SIGNAL(fittingResolutionChanged()));
     }
 
     m_cameraFlashControl = flashControlFromCamera(m_camera);
@@ -237,6 +247,8 @@
     m_videoEncoderControl = videoEncoderControlFromCamera(m_camera);
 
     Q_EMIT resolutionChanged();
+    Q_EMIT maximumResolutionChanged();
+    Q_EMIT fittingResolutionChanged();
     Q_EMIT hasFlashChanged();
     Q_EMIT hasHdrChanged();
     Q_EMIT hdrEnabledChanged();
@@ -260,6 +272,8 @@
         }
         Q_EMIT activeCameraIndexChanged();
         Q_EMIT resolutionChanged();
+        Q_EMIT maximumResolutionChanged();
+        Q_EMIT fittingResolutionChanged();
         Q_EMIT hasFlashChanged();
         Q_EMIT videoSupportedResolutionsChanged();
     }
@@ -277,6 +291,117 @@
     return QSize();
 }
 
+QSize AdvancedCameraSettings::imageCaptureResolution() const
+{
+    if (m_imageEncoderControl != 0) {
+        return m_imageEncoderControl->imageSettings().resolution();
+    }
+
+    return QSize();
+}
+
+QSize AdvancedCameraSettings::videoRecorderResolution() const
+{
+    if (m_videoEncoderControl != 0) {
+        return m_videoEncoderControl->videoSettings().resolution();
+    }
+
+    return QSize();
+}
+
+QSize AdvancedCameraSettings::maximumResolution() const
+{
+    if (m_imageEncoderControl) {
+        QList<QSize> sizes = m_imageEncoderControl->supportedResolutions(
+                                       m_imageEncoderControl->imageSettings());
+
+        QSize maximumSize;
+        long maximumPixels = 0;
+
+        QList<QSize>::const_iterator it = sizes.begin();
+        while (it != sizes.end()) {
+            const long pixels = ((long)((*it).width())) * ((long)((*it).height()));
+            if (pixels > maximumPixels) {
+                maximumSize = *it;
+                maximumPixels = pixels;
+            }
+            ++it;
+        }
+
+        return maximumSize;
+    }
+
+    return QSize();
+}
+
+float AdvancedCameraSettings::getScreenAspectRatio() const
+{
+    float screenAspectRatio;
+    QScreen *screen = QGuiApplication::primaryScreen();
+    Q_ASSERT(!screen);
+    const int kScreenWidth = screen->geometry().width();
+    const int kScreenHeight = screen->geometry().height();
+    Q_ASSERT(kScreenWidth > 0 && kScreenHeight > 0);
+
+    screenAspectRatio = (kScreenWidth > kScreenHeight) ?
+        ((float)kScreenWidth / (float)kScreenHeight) : ((float)kScreenHeight / (float)kScreenWidth);
+
+    return screenAspectRatio;
+}
+
+QSize AdvancedCameraSettings::fittingResolution() const
+{
+    QList<float> prioritizedAspectRatios;
+    prioritizedAspectRatios.append(getScreenAspectRatio());
+    const float backAspectRatios[4] = { 16.0f/9.0f, 3.0f/2.0f, 4.0f/3.0f, 5.0f/4.0f };
+    for (int i=0; i<4; ++i) {
+        if (!prioritizedAspectRatios.contains(backAspectRatios[i])) {
+            prioritizedAspectRatios.append(backAspectRatios[i]);
+        }
+    }
+
+    if (m_imageEncoderControl) {
+        QList<QSize> sizes = m_imageEncoderControl->supportedResolutions(
+                                       m_imageEncoderControl->imageSettings());
+
+        QSize optimalSize;
+        long optimalPixels = 0;
+
+        if (!sizes.empty()) {
+            float aspectRatio;
+
+            // Loop over all reported camera resolutions until we find the highest
+            // one that matches the current prioritized aspect ratio. If it doesn't
+            // find one on the current aspect ration, it selects the next ratio and
+            // tries again.
+            QList<float>::const_iterator ratioIt = prioritizedAspectRatios.begin();
+            while (ratioIt != prioritizedAspectRatios.end()) {
+                // Don't update the aspect ratio when using this function for finding
+                // the optimal thumbnail size as it will affect the preview window size
+                aspectRatio = (*ratioIt);
+
+                QList<QSize>::const_iterator it = sizes.begin();
+                while (it != sizes.end()) {
+                    const float ratio = (float)(*it).width() / (float)(*it).height();
+                    const long pixels = ((long)((*it).width())) * ((long)((*it).height()));
+                    const float EPSILON = 0.02;
+                    if (fabs(ratio - aspectRatio) < EPSILON && pixels > optimalPixels) {
+                        optimalSize = *it;
+                        optimalPixels = pixels;
+                    }
+                    ++it;
+                }
+                if (optimalPixels > 0) break;
+                ++ratioIt;
+            }
+        }
+
+        return optimalSize;
+    }
+
+    return QSize();
+}
+
 QStringList AdvancedCameraSettings::videoSupportedResolutions() const
 {
     if (m_videoEncoderControl) {

=== modified file 'CameraApp/advancedcamerasettings.h'
--- CameraApp/advancedcamerasettings.h	2014-12-08 19:12:52 +0000
+++ CameraApp/advancedcamerasettings.h	2015-11-30 15:11:56 +0000
@@ -40,6 +40,10 @@
     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)
+    Q_PROPERTY (QSize maximumResolution READ maximumResolution NOTIFY maximumResolutionChanged)
+    Q_PROPERTY (QSize fittingResolution READ fittingResolution NOTIFY fittingResolutionChanged)
     Q_PROPERTY (QStringList videoSupportedResolutions READ videoSupportedResolutions NOTIFY videoSupportedResolutionsChanged)
     Q_PROPERTY (bool hasFlash READ hasFlash NOTIFY hasFlashChanged)
     Q_PROPERTY (bool hdrEnabled READ hdrEnabled WRITE setHdrEnabled NOTIFY hdrEnabledChanged)
@@ -53,6 +57,11 @@
     void setCamera(QObject* camera);
     void setActiveCameraIndex(int index);
     QSize resolution() const;
+    QSize imageCaptureResolution() const;
+    QSize videoRecorderResolution() const;
+    QSize maximumResolution() const;
+    QSize fittingResolution() const;
+    float getScreenAspectRatio() const;
     QStringList videoSupportedResolutions() const;
     bool hasFlash() const;
     bool hasHdr() const;
@@ -66,6 +75,8 @@
     void cameraChanged();
     void activeCameraIndexChanged();
     void resolutionChanged();
+    void maximumResolutionChanged();
+    void fittingResolutionChanged();
     void hasFlashChanged();
     void hasHdrChanged();
     void hdrEnabledChanged();

=== modified file 'OptionButton.qml'
--- OptionButton.qml	2015-10-22 12:21:14 +0000
+++ OptionButton.qml	2015-11-30 15:11:56 +0000
@@ -23,7 +23,7 @@
     property var model
     property string settingsProperty: model.settingsProperty
 
-    iconName: model.isToggle || !model.get(model.selectedIndex).icon ? model.icon : model.get(model.selectedIndex).icon
+    iconName: !model.get(model.selectedIndex).icon ? model.icon : model.get(model.selectedIndex).icon
     iconSource: (model && model.iconSource) ? model.iconSource : ""
     on: model.isToggle ? model.get(model.selectedIndex).value : true
     enabled: model.available

=== modified file 'ViewFinderOverlay.qml'
--- ViewFinderOverlay.qml	2015-10-22 12:21:14 +0000
+++ ViewFinderOverlay.qml	2015-11-30 15:11:56 +0000
@@ -50,6 +50,13 @@
         property bool gridEnabled: false
         property bool preferRemovableStorage: false
         property string videoResolution: "1920x1080"
+        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
+        property string photoResolution0
+        property string photoResolution1
 
         onFlashModeChanged: if (flashMode != Camera.FlashOff) hdrEnabled = false;
         onHdrEnabledChanged: if (hdrEnabled) flashMode = Camera.FlashOff
@@ -87,12 +94,83 @@
         value: settings.videoResolution
     }
 
+    Binding {
+        target: camera.imageCapture
+        property: "resolution"
+        value: settings["photoResolution" + camera.advanced.activeCameraIndex]
+    }
+
+    Connections {
+        target: camera.imageCapture
+        onResolutionChanged: {
+            // FIXME: this is a necessary workaround because:
+            // - Neither camera.viewfinder.resolution nor camera.advanced.resolution
+            //   emit a changed signal when the underlying AalViewfinderSettingsControl's
+            //   resolution changes
+            // - we know that qtubuntu-camera changes the resolution of the
+            //   viewfinder automatically when the capture resolution is set
+            // - we need camera.viewfinder.resolution to hold the right
+            //   value
+            camera.viewfinder.resolution = camera.advanced.resolution;
+        }
+    }
+
+    Connections {
+        target: camera.videoRecorder
+        onResolutionChanged: {
+            // FIXME: see workaround setting camera.viewfinder.resolution above
+            camera.viewfinder.resolution = camera.advanced.resolution;
+        }
+    }
+
+    Connections {
+        target: camera
+        onCaptureModeChanged: {
+            // FIXME: see workaround setting camera.viewfinder.resolution above
+            camera.viewfinder.resolution = camera.advanced.resolution;
+        }
+    }
+
     function resolutionToLabel(resolution) {
         // takes in a resolution string (e.g. "1920x1080") and returns a nicer
         // form of it for display in the UI: "1080p"
         return resolution.split("x").pop() + "p";
     }
 
+    function sizeToString(size) {
+        return size.width + "x" + size.height;
+    }
+
+    function stringToSize(resolution) {
+        var r = resolution.split("x");
+        return Qt.size(r[0], r[1]);
+    }
+
+    function sizeToAspectRatio(size) {
+        var ratio = Math.max(size.width, size.height) / Math.min(size.width, size.height);
+        var maxDenominator = 12;
+        var epsilon;
+        var numerator;
+        var denominator;
+        var bestDenominator;
+        var bestEpsilon = 10000;
+        for (denominator = 2; denominator <= maxDenominator; denominator++) {
+            numerator = ratio * denominator;
+            epsilon = Math.abs(Math.round(numerator) - numerator);
+            if (epsilon < bestEpsilon) {
+                bestEpsilon = epsilon;
+                bestDenominator = denominator;
+            }
+        }
+        numerator = Math.round(ratio * bestDenominator);
+        return "%1:%2".arg(numerator).arg(bestDenominator);
+    }
+
+    function sizeToMegapixels(size) {
+        var megapixels = (size.width * size.height) / 1000000;
+        return parseFloat(megapixels.toFixed(1))
+    }
+
     function updateVideoResolutionOptions() {
         // Clear and refill videoResolutionOptionsModel with available resolutions
         // Try to only display well known resolutions: 1080p, 720p and 480p
@@ -110,25 +188,71 @@
         }
 
         // If resolution setting chosen is not supported select the highest available resolution
-        if (supported.indexOf(settings.videoResolution) == -1) {
+        if (supported.length > 0 && supported.indexOf(settings.videoResolution) == -1) {
             settings.videoResolution = supported[supported.length - 1];
         }
     }
 
+    function updatePhotoResolutionOptions() {
+        // Clear and refill photoResolutionOptionsModel with available resolutions
+        photoResolutionOptionsModel.clear();
+
+        var optionMaximum = {"icon": "",
+                             "label": "%1 (%2MP)".arg(sizeToAspectRatio(camera.advanced.maximumResolution))
+                                                 .arg(sizeToMegapixels(camera.advanced.maximumResolution)),
+                             "value": sizeToString(camera.advanced.maximumResolution)};
+
+        var optionFitting = {"icon": "",
+                             "label": "%1 (%2MP)".arg(sizeToAspectRatio(camera.advanced.fittingResolution))
+                                                 .arg(sizeToMegapixels(camera.advanced.fittingResolution)),
+                             "value": sizeToString(camera.advanced.fittingResolution)};
+
+        photoResolutionOptionsModel.insert(0, optionMaximum);
+        if (camera.advanced.fittingResolution != camera.advanced.maximumResolution) {
+            photoResolutionOptionsModel.insert(1, optionFitting);
+        }
+
+        var photoResolution = settings["photoResolution" + camera.advanced.activeCameraIndex];
+        // If resolution setting chosen is not supported select the fitting resolution
+        if (photoResolution != optionFitting.value &&
+            photoResolution != optionMaximum.value) {
+            settings["photoResolution" + camera.advanced.activeCameraIndex] = optionFitting.value;
+        }
+    }
+
     Component.onCompleted: {
+        camera.cameraState = Camera.LoadedState;
         updateVideoResolutionOptions();
+        updatePhotoResolutionOptions();
+        // FIXME: see workaround setting camera.viewfinder.resolution above
+        camera.viewfinder.resolution = camera.advanced.resolution;
+        camera.cameraState = Camera.ActiveState;
     }
 
     Connections {
         target: camera.advanced
         onVideoSupportedResolutionsChanged: updateVideoResolutionOptions();
+        onFittingResolutionChanged: updatePhotoResolutionOptions();
+        onMaximumResolutionChanged: updatePhotoResolutionOptions();
     }
 
     Connections {
         target: camera.advanced
         onActiveCameraIndexChanged: {
+            var hasPhotoResolutionSetting = (settings["photoResolution" + camera.advanced.activeCameraIndex] != "")
+            // 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.videoResolution = sizeToString(camera.advanced.videoRecorderResolution);
+            updatePhotoResolutionOptions();
             updateVideoResolutionOptions();
-            camera.videoRecorder.resolution = settings.videoResolution;
+            // FIXME: see workaround setting camera.viewfinder.resolution above
+            camera.viewfinder.resolution = camera.advanced.resolution;
+
+            // If no resolution has ever been chosen, select the one that fits the screen
+            if (!hasPhotoResolutionSetting) {
+                settings["photoResolution" + camera.advanced.activeCameraIndex] = sizeToString(camera.advanced.fittingResolution);
+            }
         }
     }
 
@@ -280,7 +404,7 @@
                     property bool isToggle: true
                     property int selectedIndex: bottomEdge.indexForValue(hdrOptionsModel, settings.hdrEnabled)
                     property bool available: camera.advanced.hasHdr
-                    property bool visible: true
+                    property bool visible: camera.captureMode === Camera.CaptureStillImage
                     property bool showInIndicators: true
 
                     ListElement {
@@ -404,6 +528,41 @@
                     property bool available: true
                     property bool visible: camera.captureMode == Camera.CaptureVideo
                     property bool showInIndicators: false
+                },
+                ListModel {
+                    id: shutterSoundOptionsModel
+
+                    property string settingsProperty: "playShutterSound"
+                    property string icon: ""
+                    property string label: ""
+                    property bool isToggle: true
+                    property int selectedIndex: bottomEdge.indexForValue(shutterSoundOptionsModel, settings.playShutterSound)
+                    property bool available: true
+                    property bool visible: camera.captureMode === Camera.CaptureStillImage
+                    property bool showInIndicators: false
+
+                    ListElement {
+                        icon: "audio-volume-high"
+                        label: QT_TR_NOOP("On")
+                        value: true
+                    }
+                    ListElement {
+                        icon: "audio-volume-muted"
+                        label: QT_TR_NOOP("Off")
+                        value: false
+                    }
+                },
+                ListModel {
+                    id: photoResolutionOptionsModel
+
+                    property string settingsProperty: "photoResolution" + camera.advanced.activeCameraIndex
+                    property string icon: ""
+                    property string label: sizeToAspectRatio(stringToSize(settings[settingsProperty]))
+                    property bool isToggle: false
+                    property int selectedIndex: bottomEdge.indexForValue(photoResolutionOptionsModel, settings[settingsProperty])
+                    property bool available: true
+                    property bool visible: camera.captureMode == Camera.CaptureStillImage
+                    property bool showInIndicators: false
                 }
             ]
 
@@ -571,18 +730,25 @@
         function completeSwitch() {
             viewFinderSwitcherAnimation.restart();
             camera.switchInProgress = false;
+            zoomControl.value = camera.currentZoom;
         }
 
         function changeRecordMode() {
             if (camera.captureMode == Camera.CaptureVideo) camera.videoRecorder.stop()
             camera.captureMode = (camera.captureMode == Camera.CaptureVideo) ? Camera.CaptureStillImage : Camera.CaptureVideo
+            zoomControl.value = camera.currentZoom
+        }
+
+        Connections {
+            target: Qt.application
+            onActiveChanged: if (active) zoomControl.value = camera.currentZoom
         }
 
         Timer {
             id: shootingTimer
             repeat: true
             triggeredOnStart: true
-            
+
             property int remainingSecs: 0
 
             onTriggered: {

=== modified file 'ViewFinderView.qml'
--- ViewFinderView.qml	2015-11-16 15:54:25 +0000
+++ ViewFinderView.qml	2015-11-30 15:11:56 +0000
@@ -36,6 +36,7 @@
     Camera {
         id: camera
         captureMode: Camera.CaptureStillImage
+        cameraState: Camera.UnloadedState
         StateSaver.properties: "captureMode"
 
         function manualFocus(x, y) {
@@ -67,10 +68,6 @@
             StateSaver.properties: "activeCameraIndex"
         }
 
-        Component.onCompleted: {
-            camera.start();
-        }
-        
         /* Use only digital zoom for now as it's what phone cameras mostly use.
                TODO: if optical zoom is available, maximumZoom should be the combined
                range of optical and digital zoom and currentZoom should adjust the two
@@ -121,12 +118,14 @@
         target: Qt.application
         onActiveChanged: {
             if (Qt.application.active) {
-                camera.start()
+                if (camera.cameraState == Camera.LoadedState) {
+                    camera.cameraState = Camera.ActiveState;
+                }
             } else if (!application.desktopMode) {
                 if (camera.videoRecorder.recorderState == CameraRecorder.RecordingState) {
                     camera.videoRecorder.stop();
                 }
-                camera.stop()
+                camera.cameraState = Camera.LoadedState;
             }
         }
     }
@@ -250,16 +249,16 @@
                 axis.x: 0; axis.y: 1; axis.z: 0
                 angle: application.desktopMode ? 180 : 0
             }
-
-            ViewFinderGeometry {
-                id: viewFinderGeometry
-                anchors.centerIn: parent
-
-                cameraResolution: camera.advanced.resolution
-                viewFinderHeight: viewFinder.height
-                viewFinderWidth: viewFinder.width
-                viewFinderOrientation: viewFinder.orientation
-            }
+        }
+
+        ViewFinderGeometry {
+            id: viewFinderGeometry
+            anchors.centerIn: parent
+
+            cameraResolution: camera.viewfinder.resolution
+            viewFinderHeight: viewFinder.height
+            viewFinderWidth: viewFinder.width
+            viewFinderOrientation: viewFinder.orientation
         }
 
         Item {

=== modified file 'manifest.json.in'
--- manifest.json.in	2015-11-23 15:07:14 +0000
+++ manifest.json.in	2015-11-30 15:11:56 +0000
@@ -1,6 +1,6 @@
 {
     "description": "An application to take pictures and videos with the device cameras",
-    "framework": "ubuntu-sdk-15.04.2",
+    "framework": "ubuntu-sdk-15.04.3",
     "architecture": "@CLICK_ARCH@",
     "hooks": {
         "camera": {

=== modified file 'tests/autopilot/camera_app/emulators/main_window.py'
--- tests/autopilot/camera_app/emulators/main_window.py	2015-11-20 15:01:02 +0000
+++ tests/autopilot/camera_app/emulators/main_window.py	2015-11-30 15:11:56 +0000
@@ -7,7 +7,7 @@
 
 from camera_app.emulators.panel import Panel
 from autopilot.matchers import Eventually
-from testtools.matchers import Equals
+from testtools.matchers import Equals, NotEquals
 
 
 class MainWindow(object):
@@ -163,3 +163,22 @@
             tx, ty, (tx + view_switcher.width // 2), ty, rate=1)
         viewfinder = self.get_viewfinder()
         testCase.assertThat(viewfinder.inView, Eventually(Equals(True)))
+
+    def switch_cameras(self):
+        # Swap cameras and wait for camera to settle
+        shoot_button = self.get_exposure_button()
+        swap_camera_button = self.get_swap_camera_button()
+        self.app.pointing_device.move_to_object(swap_camera_button)
+        self.app.pointing_device.click()
+        shoot_button.enabled.wait_for(True)
+
+    def switch_recording_mode(self):
+        record_control = self.get_record_control()
+
+        # Wait for the camera overlay to be loaded
+        record_control.enabled.wait_for(True)
+        record_control.width.wait_for(NotEquals(0))
+        record_control.height.wait_for(NotEquals(0))
+
+        self.app.pointing_device.move_to_object(record_control)
+        self.app.pointing_device.click()

=== modified file 'tests/autopilot/camera_app/tests/test_capture.py'
--- tests/autopilot/camera_app/tests/test_capture.py	2015-10-05 13:14:12 +0000
+++ tests/autopilot/camera_app/tests/test_capture.py	2015-11-30 15:11:56 +0000
@@ -90,13 +90,11 @@
 
         """
         # Get all the elements
-        record_control = self.main_window.get_record_control()
         stop_watch = self.main_window.get_stop_watch()
         exposure_button = self.main_window.get_exposure_button()
 
         # Click the record button to toggle photo/video mode
-        self.pointing_device.move_to_object(record_control)
-        self.pointing_device.click()
+        self.main_window.switch_recording_mode()
 
         # Before recording the stop watch should read zero recording time
         # and not be visible anyway.
@@ -137,8 +135,7 @@
         # Now stop the video and go back to picture mode and check if
         # everything resets itself to previous states
         self.pointing_device.click()
-        self.pointing_device.move_to_object(record_control)
-        self.pointing_device.click()
+        self.main_window.switch_recording_mode()
 
         self.assertThat(stop_watch.opacity, Eventually(Equals(0.0)))
 
@@ -268,7 +265,7 @@
     """Test recording videos at a set resolution and switching cameras"""
     def test_video_resolution_setting_switching_cameras(self):
         # switch to video recording and empty video folder
-        self.switch_to_video_recording()
+        self.main_window.switch_recording_mode()
         self.delete_all_videos()
 
         # select the first resolution for the current camera
@@ -277,32 +274,25 @@
         self.set_video_resolution(initial_resolution)
 
         # switch cameras and select the last resolution for the current camera
-        self.switch_cameras()
+        self.main_window.switch_cameras()
         resolutions = self.get_available_video_resolutions()
         expected_resolution = resolutions[-1]
         self.assertThat(expected_resolution, NotEquals(initial_resolution))
         self.set_video_resolution(expected_resolution)
 
         # switch back to the initial camera and record a video
-        self.switch_cameras()
+        self.main_window.switch_cameras()
         self.record_video(2)
         video_file = self.get_first_video()
         height = self.read_video_height(video_file)
+        expected_resolution = self.get_selected_video_resolution()
         expected_height = self.height_from_resolution_label(
             expected_resolution)
         self.assertThat(height, Equals(expected_height))
 
-    def switch_cameras(self):
-        # Swap cameras and wait for camera to settle
-        shoot_button = self.main_window.get_exposure_button()
-        swap_camera_button = self.main_window.get_swap_camera_button()
-        self.pointing_device.move_to_object(swap_camera_button)
-        self.pointing_device.click()
-        self.assertThat(shoot_button.enabled, Eventually(Equals(True)))
-
     """Test recording videos at various resolutions"""
     def test_video_resolution_setting(self):
-        self.switch_to_video_recording()
+        self.main_window.switch_recording_mode()
         resolutions = self.get_available_video_resolutions()
 
         for resolution_label in resolutions:
@@ -316,16 +306,6 @@
             self.assertThat(height, Equals(expected_height))
             self.dismiss_first_photo_hint()
 
-    def switch_to_video_recording(self):
-        record_control = self.main_window.get_record_control()
-        # Wait for the camera overlay to be loaded
-        self.assertThat(record_control.enabled, Eventually(Equals(True)))
-        self.assertThat(record_control.width, Eventually(NotEquals(0)))
-        self.assertThat(record_control.height, Eventually(NotEquals(0)))
-
-        self.pointing_device.move_to_object(record_control)
-        self.pointing_device.click()
-
     def get_available_video_resolutions(self):
         # open bottom edge
         bottom_edge = self.main_window.get_bottom_edge()
@@ -346,6 +326,26 @@
         bottom_edge.close()
         return resolutions
 
+    def get_selected_video_resolution(self):
+        # open bottom edge
+        bottom_edge = self.main_window.get_bottom_edge()
+        bottom_edge.open()
+
+        # open video resolution option value selector showing the possible
+        # values
+        video_resolution_button = (
+            self.main_window.get_video_resolution_button())
+        self.pointing_device.move_to_object(video_resolution_button)
+        self.pointing_device.click()
+        option_value_selector = self.main_window.get_option_value_selector()
+        self.assertThat(
+            option_value_selector.visible, Eventually(Equals(True)))
+        optionButtons = option_value_selector.select_many("OptionValueButton")
+        resolutions = [button.label for button in optionButtons if button.selected]
+
+        bottom_edge.close()
+        return resolutions[0]
+
     def delete_all_videos(self):
         video_files = os.listdir(self.videos_dir)
         for f in video_files:

=== modified file 'tests/autopilot/camera_app/tests/test_zoom.py'
--- tests/autopilot/camera_app/tests/test_zoom.py	2015-04-29 15:56:44 +0000
+++ tests/autopilot/camera_app/tests/test_zoom.py	2015-11-30 15:11:56 +0000
@@ -68,3 +68,50 @@
 
         self.pointing_device.drag(tx, ty, (tx - zoom_control.width), ty)
         self.assertThat(zoom_control.value, Eventually(Equals(1.0)))
+
+    """Tests zoom is reset to minimum on camera switch"""
+    def test_zoom_reset_on_camera_change(self):
+        zoom_control = self.main_window.get_zoom_control()
+        zoom_slider = self.main_window.get_zoom_slider()
+
+        self.activate_zoom()
+        x, y, w, h = zoom_slider.globalRect
+        tx = x + (w // 2)
+        ty = y + (h // 2)
+        self.pointing_device.drag(tx, ty, (tx + zoom_control.width), ty)
+        self.assertThat(
+            zoom_control.value, Eventually(Equals(zoom_control.maximumValue)))
+
+        self.main_window.switch_cameras()
+        self.assertThat(
+            zoom_control.value, Eventually(Equals(zoom_control.minimumValue)))
+
+        self.activate_zoom()
+        self.pointing_device.drag(tx, ty, (tx + zoom_control.width), ty)
+        self.assertThat(
+            zoom_control.value, Eventually(Equals(zoom_control.maximumValue)))
+
+        self.main_window.switch_cameras()
+        self.assertThat(
+            zoom_control.value, Eventually(Equals(zoom_control.minimumValue)))
+
+    """Tests zoom is reset to minimum on recording mode switch"""
+    def test_zoom_reset_on_recording_mode_change(self):
+        zoom_control = self.main_window.get_zoom_control()
+        zoom_slider = self.main_window.get_zoom_slider()
+
+        self.activate_zoom()
+        x, y, w, h = zoom_slider.globalRect
+        tx = x + (w // 2)
+        ty = y + (h // 2)
+        self.pointing_device.drag(tx, ty, (tx + zoom_control.width), ty)
+        self.assertThat(
+            zoom_control.value, Eventually(Equals(zoom_control.maximumValue)))
+
+        self.main_window.switch_recording_mode()
+        self.assertThat(
+            zoom_control.value, Eventually(Equals(zoom_control.minimumValue)))
+
+        # Ideally we should test the same thing when switching back to photo
+        # mode, however due to http://pad.lv/1191088 zooming when recording
+        # video is disabled, so adding that test is pointless until fixed.