slapin/qtmultimedia
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge remote-tracking branch 'origin/stable' into dev

Browse Source 
Change-Id: I42587537cadade4b3f45df18385adb760fb24430
This commit is contained in:
Sergio Ahumada
2014-03-11 09:26:50 +01:00
parent ed43209f42 4bb51fef0a
commit cd7882b760
108 changed files with 3107 additions and 448 deletions
Download Patch File Download Diff File Expand all files Collapse all files

77
tests/auto/integration/qcamerabackend/tst_qcamerabackend.cpp
View File

@@ -58,6 +58,7 @@
#include <qcameracapturedestinationcontrol.h>
#include <qmediaservice.h>
#include <qcamera.h>
#include <qcamerainfo.h>
#include <qcameraimagecapture.h>
#include <qvideorenderercontrol.h>
#include <private/qmediaserviceprovider_p.h>
@@ -82,7 +83,10 @@ public slots:
private slots:
void testAvailableDevices();
void testDeviceDescription();
void testCameraInfo();
void testCtorWithDevice();
void testCtorWithCameraInfo();
void testCtorWithPosition();
void testCameraStates();
void testCaptureMode();
@@ -126,6 +130,23 @@ void tst_QCameraBackend::testDeviceDescription()
}
}
void tst_QCameraBackend::testCameraInfo()
{
int deviceCount = QMediaServiceProvider::defaultServiceProvider()->devices(QByteArray(Q_MEDIASERVICE_CAMERA)).count();
QList<QCameraInfo> cameras = QCameraInfo::availableCameras();
QCOMPARE(cameras.count(), deviceCount);
if (cameras.isEmpty()) {
QVERIFY(QCameraInfo::defaultCamera().isNull());
QSKIP("Camera selection is not supported");
}
foreach (const QCameraInfo &info, cameras) {
QVERIFY(!info.deviceName().isEmpty());
QVERIFY(!info.description().isEmpty());
QVERIFY(info.orientation() % 90 == 0);
}
}
void tst_QCameraBackend::testCtorWithDevice()
{
if (QCamera::availableDevices().isEmpty())
@@ -142,6 +163,58 @@ void tst_QCameraBackend::testCtorWithDevice()
delete camera;
}
void tst_QCameraBackend::testCtorWithCameraInfo()
{
if (QCameraInfo::availableCameras().isEmpty())
QSKIP("Camera selection not supported");
{
QCameraInfo info = QCameraInfo::defaultCamera();
QCamera camera(info);
QCOMPARE(camera.error(), QCamera::NoError);
QCOMPARE(QCameraInfo(camera), info);
}
{
QCameraInfo info = QCameraInfo::availableCameras().first();
QCamera camera(info);
QCOMPARE(camera.error(), QCamera::NoError);
QCOMPARE(QCameraInfo(camera), info);
}
{
// loading an invalid CameraInfo should fail
QCamera *camera = new QCamera(QCameraInfo());
QCOMPARE(camera->error(), QCamera::ServiceMissingError);
QVERIFY(QCameraInfo(*camera).isNull());
delete camera;
}
{
// loading non existing camera should fail
QCamera camera(QCameraInfo(QUuid::createUuid().toByteArray()));
QCOMPARE(camera.error(), QCamera::ServiceMissingError);
QVERIFY(QCameraInfo(camera).isNull());
}
}
void tst_QCameraBackend::testCtorWithPosition()
{
{
QCamera camera(QCamera::UnspecifiedPosition);
QCOMPARE(camera.error(), QCamera::NoError);
}
{
QCamera camera(QCamera::FrontFace);
// even if no camera is available at this position, it should not fail
// and load the default camera
QCOMPARE(camera.error(), QCamera::NoError);
}
{
QCamera camera(QCamera::BackFace);
// even if no camera is available at this position, it should not fail
// and load the default camera
QCOMPARE(camera.error(), QCamera::NoError);
}
}
void tst_QCameraBackend::testCameraStates()
{
QCamera camera;
@@ -283,7 +356,7 @@ void tst_QCameraBackend::testCameraCapture()
QSignalSpy capturedSignal(&imageCapture, SIGNAL(imageCaptured(int,QImage)));
QSignalSpy savedSignal(&imageCapture, SIGNAL(imageSaved(int,QString)));
QSignalSpy errorSignal(&imageCapture, SIGNAL(error(int, QCameraImageCapture::Error,QString)));
QSignalSpy errorSignal(&imageCapture, SIGNAL(error(int,QCameraImageCapture::Error,QString)));
imageCapture.capture();
QTRY_COMPARE(errorSignal.size(), 1);
@@ -354,7 +427,7 @@ void tst_QCameraBackend::testCaptureToBuffer()
QSignalSpy capturedSignal(&imageCapture, SIGNAL(imageCaptured(int,QImage)));
QSignalSpy imageAvailableSignal(&imageCapture, SIGNAL(imageAvailable(int,QVideoFrame)));
QSignalSpy savedSignal(&imageCapture, SIGNAL(imageSaved(int,QString)));
QSignalSpy errorSignal(&imageCapture, SIGNAL(error(int, QCameraImageCapture::Error,QString)));
QSignalSpy errorSignal(&imageCapture, SIGNAL(error(int,QCameraImageCapture::Error,QString)));
camera.start();
QTRY_VERIFY(imageCapture.isReadyForCapture());

8
tests/auto/integration/qmediaplayerbackend/tst_qmediaplayerbackend.cpp
View File

@@ -736,9 +736,9 @@ void tst_QMediaPlayerBackend::probes()
QAudioProbe *audioProbe = new QAudioProbe;
ProbeDataHandler probeHandler;
connect(videoProbe, SIGNAL(videoFrameProbed(const QVideoFrame&)), &probeHandler, SLOT(processFrame(QVideoFrame)));
connect(videoProbe, SIGNAL(videoFrameProbed(QVideoFrame)), &probeHandler, SLOT(processFrame(QVideoFrame)));
connect(videoProbe, SIGNAL(flush()), &probeHandler, SLOT(flushVideo()));
connect(audioProbe, SIGNAL(audioBufferProbed(const QAudioBuffer&)), &probeHandler, SLOT(processBuffer(QAudioBuffer)));
connect(audioProbe, SIGNAL(audioBufferProbed(QAudioBuffer)), &probeHandler, SLOT(processBuffer(QAudioBuffer)));
connect(audioProbe, SIGNAL(flush()), &probeHandler, SLOT(flushAudio()));
QVERIFY(videoProbe->setSource(player));
@@ -762,8 +762,8 @@ void tst_QMediaPlayerBackend::playlist()
{
QMediaPlayer player;
QSignalSpy mediaSpy(&player, SIGNAL(mediaChanged(const QMediaContent&)));
QSignalSpy currentMediaSpy(&player, SIGNAL(currentMediaChanged(const QMediaContent&)));
QSignalSpy mediaSpy(&player, SIGNAL(mediaChanged(QMediaContent)));
QSignalSpy currentMediaSpy(&player, SIGNAL(currentMediaChanged(QMediaContent)));
QSignalSpy stateSpy(&player, SIGNAL(stateChanged(QMediaPlayer::State)));
QSignalSpy errorSpy(&player, SIGNAL(error(QMediaPlayer::Error)));

76
tests/auto/integration/qsoundeffect/tst_qsoundeffect.cpp
View File

@@ -152,16 +152,86 @@ void tst_QSoundEffect::testLooping()
sound->setLoopCount(5);
sound->setVolume(0.1f);
QCOMPARE(sound->loopCount(),5);
QCOMPARE(readSignal_Count.count(),1);
QCOMPARE(sound->loopCount(), 5);
QCOMPARE(readSignal_Count.count(), 1);
QCOMPARE(sound->loopsRemaining(), 0);
QCOMPARE(readSignal_Remaining.count(), 0);
sound->play();
QCOMPARE(sound->loopsRemaining(), 5);
QCOMPARE(readSignal_Remaining.count(), 1);
// test.wav is about 200ms, wait until it has finished playing 5 times
QTestEventLoop::instance().enterLoop(3);
QTRY_COMPARE(sound->loopsRemaining(), 0);
QCOMPARE(readSignal_Remaining.count(),5);
QVERIFY(readSignal_Remaining.count() >= 6);
QTRY_VERIFY(!sound->isPlaying());
// QTBUG-36643 (setting the loop count while playing should work)
{
readSignal_Count.clear();
readSignal_Remaining.clear();
sound->setLoopCount(30);
QCOMPARE(sound->loopCount(), 30);
QCOMPARE(readSignal_Count.count(), 1);
QCOMPARE(sound->loopsRemaining(), 0);
QCOMPARE(readSignal_Remaining.count(), 0);
sound->play();
QCOMPARE(sound->loopsRemaining(), 30);
QCOMPARE(readSignal_Remaining.count(), 1);
// wait for the sound to be played several times
QTRY_COMPARE(sound->loopsRemaining(), 20);
QVERIFY(readSignal_Remaining.count() >= 10);
readSignal_Count.clear();
readSignal_Remaining.clear();
// change the loop count while playing
sound->setLoopCount(5);
QCOMPARE(sound->loopCount(), 5);
QCOMPARE(readSignal_Count.count(), 1);
QCOMPARE(sound->loopsRemaining(), 5);
QCOMPARE(readSignal_Remaining.count(), 1);
// wait for all the loops to be completed
QTRY_COMPARE(sound->loopsRemaining(), 0);
QVERIFY(readSignal_Remaining.count() >= 6);
QTRY_VERIFY(!sound->isPlaying());
}
{
readSignal_Count.clear();
readSignal_Remaining.clear();
sound->setLoopCount(QSoundEffect::Infinite);
QCOMPARE(sound->loopCount(), int(QSoundEffect::Infinite));
QCOMPARE(readSignal_Count.count(), 1);
QCOMPARE(sound->loopsRemaining(), 0);
QCOMPARE(readSignal_Remaining.count(), 0);
sound->play();
QCOMPARE(sound->loopsRemaining(), int(QSoundEffect::Infinite));
QCOMPARE(readSignal_Remaining.count(), 1);
QTest::qWait(1500);
QVERIFY(sound->isPlaying());
readSignal_Count.clear();
readSignal_Remaining.clear();
// Setting the loop count to 0 should play it one last time
sound->setLoopCount(0);
QCOMPARE(sound->loopCount(), 1);
QCOMPARE(readSignal_Count.count(), 1);
QCOMPARE(sound->loopsRemaining(), 1);
QCOMPARE(readSignal_Remaining.count(), 1);
QTRY_COMPARE(sound->loopsRemaining(), 0);
QVERIFY(readSignal_Remaining.count() >= 2);
QTRY_VERIFY(!sound->isPlaying());
}
}
void tst_QSoundEffect::testVolume()

1
tests/auto/unit/multimedia.pro
View File

@@ -7,6 +7,7 @@ SUBDIRS += \
qaudioformat \
qaudionamespace \
qcamera \
qcamerainfo \
qcameraimagecapture \
qmediabindableinterface \
qmediacontainercontrol \

100
tests/auto/unit/qcamera/tst_qcamera.cpp
View File

@@ -57,6 +57,7 @@
#include <qcameracapturedestinationcontrol.h>
#include <qmediaservice.h>
#include <qcamera.h>
#include <qcamerainfo.h>
#include <qcameraimagecapture.h>
#include <qvideorenderercontrol.h>
@@ -101,7 +102,7 @@ private slots:
void testCaptureDestination();
void testCaptureFormat();
void testConstructorWithDefaultProvider();
void testConstructor();
void testCaptureMode();
void testIsCaptureModeSupported();
void testRequestedLocks();
@@ -330,7 +331,7 @@ void tst_QCamera::testSimpleCameraCapture()
QCOMPARE(imageCapture.error(), QCameraImageCapture::NoError);
QVERIFY(imageCapture.errorString().isEmpty());
QSignalSpy errorSignal(&imageCapture, SIGNAL(error(int, QCameraImageCapture::Error,QString)));
QSignalSpy errorSignal(&imageCapture, SIGNAL(error(int,QCameraImageCapture::Error,QString)));
imageCapture.capture(QString::fromLatin1("/dev/null"));
QCOMPARE(errorSignal.size(), 1);
QCOMPARE(imageCapture.error(), QCameraImageCapture::NotSupportedFeatureError);
@@ -348,7 +349,7 @@ void tst_QCamera::testSimpleCameraLock()
QSignalSpy lockedSignal(&camera, SIGNAL(locked()));
QSignalSpy lockFailedSignal(&camera, SIGNAL(lockFailed()));
QSignalSpy lockStatusChangedSignal(&camera, SIGNAL(lockStatusChanged(QCamera::LockStatus, QCamera::LockChangeReason)));
QSignalSpy lockStatusChangedSignal(&camera, SIGNAL(lockStatusChanged(QCamera::LockStatus,QCamera::LockChangeReason)));
camera.searchAndLock();
QCOMPARE(camera.lockStatus(), QCamera::Locked);
@@ -460,7 +461,7 @@ void tst_QCamera::testCameraCapture()
QVERIFY(!imageCapture.isReadyForCapture());
QSignalSpy capturedSignal(&imageCapture, SIGNAL(imageCaptured(int,QImage)));
QSignalSpy errorSignal(&imageCapture, SIGNAL(error(int, QCameraImageCapture::Error,QString)));
QSignalSpy errorSignal(&imageCapture, SIGNAL(error(int,QCameraImageCapture::Error,QString)));
imageCapture.capture(QString::fromLatin1("/dev/null"));
QCOMPARE(capturedSignal.size(), 0);
@@ -941,7 +942,7 @@ void tst_QCamera::testCameraLockCancel()
QSignalSpy lockedSignal(&camera, SIGNAL(locked()));
QSignalSpy lockFailedSignal(&camera, SIGNAL(lockFailed()));
QSignalSpy lockStatusChangedSignal(&camera, SIGNAL(lockStatusChanged(QCamera::LockStatus, QCamera::LockChangeReason)));
QSignalSpy lockStatusChangedSignal(&camera, SIGNAL(lockStatusChanged(QCamera::LockStatus,QCamera::LockChangeReason)));
camera.searchAndLock();
QCOMPARE(camera.lockStatus(), QCamera::Searching);
QCOMPARE(lockedSignal.count(), 0);
@@ -1141,6 +1142,8 @@ void tst_QCamera::testEnumDebug()
qDebug() << QCamera::NoLock;
QTest::ignoreMessage(QtDebugMsg, "QCamera::LockExposure");
qDebug() << QCamera::LockExposure;
QTest::ignoreMessage(QtDebugMsg, "QCamera::FrontFace ");
qDebug() << QCamera::FrontFace;
}
void tst_QCamera::testCameraControl()
@@ -1149,13 +1152,75 @@ void tst_QCamera::testCameraControl()
QVERIFY(m_cameraControl != NULL);
}
/* Test case for constructor with default provider */
void tst_QCamera::testConstructorWithDefaultProvider()
void tst_QCamera::testConstructor()
{
QCamera *camera = new QCamera(0);
QVERIFY(camera != NULL);
QCOMPARE(camera->state(), QCamera::UnloadedState);
delete camera;
// Service doesn't implement QVideoDeviceSelectorControl
provider->service = mockSimpleCameraService;
{
QCamera camera;
QCOMPARE(camera.availability(), QMultimedia::Available);
QCOMPARE(camera.error(), QCamera::NoError);
}
{
// Requesting a camera at a specific position from a service which doesn't implement
// the QVideoDeviceSelectorControl should result in loading the default camera
QCamera camera(QCamera::FrontFace);
QCOMPARE(camera.availability(), QMultimedia::Available);
QCOMPARE(camera.error(), QCamera::NoError);
}
// Service implements QVideoDeviceSelectorControl
provider->service = mockCameraService;
{
QCamera camera;
QCOMPARE(camera.availability(), QMultimedia::Available);
QCOMPARE(camera.error(), QCamera::NoError);
QCOMPARE(mockCameraService->mockVideoDeviceSelectorControl->selectedDevice(), 1); // default is 1
}
{
QCamera camera(QCameraInfo::defaultCamera());
QCOMPARE(camera.availability(), QMultimedia::Available);
QCOMPARE(camera.error(), QCamera::NoError);
QCOMPARE(mockCameraService->mockVideoDeviceSelectorControl->selectedDevice(), 1);
QCOMPARE(QCameraInfo(camera), QCameraInfo::defaultCamera());
}
{
QCameraInfo cameraInfo = QCameraInfo::availableCameras().at(0);
QCamera camera(cameraInfo);
QCOMPARE(camera.availability(), QMultimedia::Available);
QCOMPARE(camera.error(), QCamera::NoError);
QCOMPARE(mockCameraService->mockVideoDeviceSelectorControl->selectedDevice(), 0);
QCOMPARE(QCameraInfo(camera), cameraInfo);
}
{
// Requesting a camera at a position which is not available should result in
// loading the default camera
QCamera camera(QCamera::FrontFace);
QCOMPARE(camera.availability(), QMultimedia::Available);
QCOMPARE(camera.error(), QCamera::NoError);
QCOMPARE(mockCameraService->mockVideoDeviceSelectorControl->selectedDevice(), 1);
}
{
QCamera camera(QCamera::BackFace);
QCOMPARE(camera.availability(), QMultimedia::Available);
QCOMPARE(camera.error(), QCamera::NoError);
QCOMPARE(mockCameraService->mockVideoDeviceSelectorControl->selectedDevice(), 0);
}
{
// Should load the default camera when UnspecifiedPosition is requested
QCamera camera(QCamera::UnspecifiedPosition);
QCOMPARE(camera.availability(), QMultimedia::Available);
QCOMPARE(camera.error(), QCamera::NoError);
QCOMPARE(mockCameraService->mockVideoDeviceSelectorControl->selectedDevice(), 1);
}
}
/* captureModeChanged Signal test case. */
@@ -1257,8 +1322,8 @@ void tst_QCamera::testSearchAndLockWithLockTypes()
/* Spy the signals */
QSignalSpy lockedSignal(&camera, SIGNAL(locked()));
QSignalSpy lockFailedSignal(&camera, SIGNAL(lockFailed()));
QSignalSpy lockStatusChangedSignal(&camera, SIGNAL(lockStatusChanged(QCamera::LockStatus, QCamera::LockChangeReason)));
QSignalSpy lockStatusChangedSignalWithType(&camera, SIGNAL(lockStatusChanged(QCamera::LockType,QCamera::LockStatus, QCamera::LockChangeReason)));
QSignalSpy lockStatusChangedSignal(&camera, SIGNAL(lockStatusChanged(QCamera::LockStatus,QCamera::LockChangeReason)));
QSignalSpy lockStatusChangedSignalWithType(&camera, SIGNAL(lockStatusChanged(QCamera::LockType,QCamera::LockStatus,QCamera::LockChangeReason)));
/* search and lock the camera with QCamera::LockExposure and verify if the signal is emitted correctly */
camera.searchAndLock(QCamera::LockExposure);
@@ -1292,8 +1357,8 @@ void tst_QCamera::testUnlockWithType()
/* Spy the signal */
QSignalSpy lockedSignal(&camera, SIGNAL(locked()));
QSignalSpy lockFailedSignal(&camera, SIGNAL(lockFailed()));
QSignalSpy lockStatusChangedSignal(&camera, SIGNAL(lockStatusChanged(QCamera::LockStatus, QCamera::LockChangeReason)));
QSignalSpy lockStatusChangedSignalWithType(&camera, SIGNAL(lockStatusChanged(QCamera::LockType,QCamera::LockStatus, QCamera::LockChangeReason)));
QSignalSpy lockStatusChangedSignal(&camera, SIGNAL(lockStatusChanged(QCamera::LockStatus,QCamera::LockChangeReason)));
QSignalSpy lockStatusChangedSignalWithType(&camera, SIGNAL(lockStatusChanged(QCamera::LockType,QCamera::LockStatus,QCamera::LockChangeReason)));
/* lock the camera with QCamera::LockExposure and Verify if the signal is emitted correctly */
camera.searchAndLock(QCamera::LockExposure);
@@ -1373,7 +1438,7 @@ void tst_QCamera::testLockStatusChangedWithTypesSignal()
QCOMPARE(camera.lockStatus(), QCamera::Unlocked);
/* Spy the signal lockStatusChanged(QCamera::LockType,QCamera::LockStatus, QCamera::LockChangeReason) */
QSignalSpy lockStatusChangedSignalWithType(&camera, SIGNAL(lockStatusChanged(QCamera::LockType,QCamera::LockStatus, QCamera::LockChangeReason)));
QSignalSpy lockStatusChangedSignalWithType(&camera, SIGNAL(lockStatusChanged(QCamera::LockType,QCamera::LockStatus,QCamera::LockChangeReason)));
/* Lock the camera with type QCamera::LockExposure */
camera.searchAndLock(QCamera::LockExposure);
@@ -1519,7 +1584,7 @@ void tst_QCamera::testLockChangeReason()
QCamera camera;
QSignalSpy lockStatusChangedSignalWithType(&camera, SIGNAL(lockStatusChanged(QCamera::LockType,QCamera::LockStatus, QCamera::LockChangeReason)));
QSignalSpy lockStatusChangedSignalWithType(&camera, SIGNAL(lockStatusChanged(QCamera::LockType,QCamera::LockStatus,QCamera::LockChangeReason)));
/* Set the lockChangeReason */
service.mockLocksControl->setLockChangeReason(QCamera::LockAcquired);
@@ -1530,6 +1595,7 @@ void tst_QCamera::testLockChangeReason()
QVERIFY(LockChangeReason == QCamera::LockAcquired);
}
/* All the enums test case for QCameraControl class*/
void tst_QCamera::testEnumsOfQCameraControl()
{

10
tests/auto/unit/qcamerainfo/qcamerainfo.pro Normal file
View File

@@ -0,0 +1,10 @@
CONFIG += testcase
TARGET = tst_qcamerainfo
QT += multimedia-private testlib
include (../qmultimedia_common/mock.pri)
include (../qmultimedia_common/mockcamera.pri)
SOURCES += tst_qcamerainfo.cpp
DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0

217
tests/auto/unit/qcamerainfo/tst_qcamerainfo.cpp Normal file
View File

@@ -0,0 +1,217 @@
/****************************************************************************
**
** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <QtTest/QtTest>
#include <QDebug>
#include <qcamera.h>
#include <qcamerainfo.h>
#include "mockcameraservice.h"
#include "mockmediaserviceprovider.h"
QT_USE_NAMESPACE
class tst_QCameraInfo: public QObject
{
Q_OBJECT
public slots:
void initTestCase();
void init();
void cleanup();
private slots:
void constructor();
void defaultCamera();
void availableCameras();
void equality_operators();
private:
MockSimpleCameraService *mockSimpleCameraService;
MockCameraService *mockCameraService;
MockMediaServiceProvider *provider;
};
void tst_QCameraInfo::initTestCase()
{
}
void tst_QCameraInfo::init()
{
provider = new MockMediaServiceProvider;
mockSimpleCameraService = new MockSimpleCameraService;
mockCameraService = new MockCameraService;
provider->service = mockCameraService;
QMediaServiceProvider::setDefaultServiceProvider(provider);
}
void tst_QCameraInfo::cleanup()
{
delete provider;
delete mockCameraService;
delete mockSimpleCameraService;
}
void tst_QCameraInfo::constructor()
{
// Service doesn't implement QVideoDeviceSelectorControl
// QCameraInfo should not be valid in this case
provider->service = mockSimpleCameraService;
{
QCamera camera;
QCameraInfo info(camera);
QVERIFY(info.isNull());
QVERIFY(info.deviceName().isEmpty());
QVERIFY(info.description().isEmpty());
QCOMPARE(info.position(), QCamera::UnspecifiedPosition);
QCOMPARE(info.orientation(), 0);
}
// Service implements QVideoDeviceSelectorControl
provider->service = mockCameraService;
{
// default camera
QCamera camera;
QCameraInfo info(camera);
QVERIFY(!info.isNull());
QCOMPARE(info.deviceName(), QStringLiteral("othercamera"));
QCOMPARE(info.description(), QStringLiteral("othercamera desc"));
QCOMPARE(info.position(), QCamera::UnspecifiedPosition);
QCOMPARE(info.orientation(), 0);
}
QCamera camera("backcamera");
QCameraInfo info(camera);
QVERIFY(!info.isNull());
QCOMPARE(info.deviceName(), QStringLiteral("backcamera"));
QCOMPARE(info.description(), QStringLiteral("backcamera desc"));
QCOMPARE(info.position(), QCamera::BackFace);
QCOMPARE(info.orientation(), 90);
QCameraInfo info2(info);
QVERIFY(!info2.isNull());
QCOMPARE(info2.deviceName(), QStringLiteral("backcamera"));
QCOMPARE(info2.description(), QStringLiteral("backcamera desc"));
QCOMPARE(info2.position(), QCamera::BackFace);
QCOMPARE(info2.orientation(), 90);
}
void tst_QCameraInfo::defaultCamera()
{
provider->service = mockCameraService;
QCameraInfo info = QCameraInfo::defaultCamera();
QVERIFY(!info.isNull());
QCOMPARE(info.deviceName(), QStringLiteral("othercamera"));
QCOMPARE(info.description(), QStringLiteral("othercamera desc"));
QCOMPARE(info.position(), QCamera::UnspecifiedPosition);
QCOMPARE(info.orientation(), 0);
QCamera camera(info);
QCOMPARE(QCameraInfo(camera), info);
}
void tst_QCameraInfo::availableCameras()
{
provider->service = mockCameraService;
QList<QCameraInfo> cameras = QCameraInfo::availableCameras();
QCOMPARE(cameras.count(), 2);
QCameraInfo info = cameras.at(0);
QVERIFY(!info.isNull());
QCOMPARE(info.deviceName(), QStringLiteral("backcamera"));
QCOMPARE(info.description(), QStringLiteral("backcamera desc"));
QCOMPARE(info.position(), QCamera::BackFace);
QCOMPARE(info.orientation(), 90);
info = cameras.at(1);
QVERIFY(!info.isNull());
QCOMPARE(info.deviceName(), QStringLiteral("othercamera"));
QCOMPARE(info.description(), QStringLiteral("othercamera desc"));
QCOMPARE(info.position(), QCamera::UnspecifiedPosition);
QCOMPARE(info.orientation(), 0);
cameras = QCameraInfo::availableCameras(QCamera::BackFace);
QCOMPARE(cameras.count(), 1);
info = cameras.at(0);
QVERIFY(!info.isNull());
QCOMPARE(info.deviceName(), QStringLiteral("backcamera"));
QCOMPARE(info.description(), QStringLiteral("backcamera desc"));
QCOMPARE(info.position(), QCamera::BackFace);
QCOMPARE(info.orientation(), 90);
cameras = QCameraInfo::availableCameras(QCamera::FrontFace);
QCOMPARE(cameras.count(), 0);
}
void tst_QCameraInfo::equality_operators()
{
provider->service = mockCameraService;
QCameraInfo defaultCamera = QCameraInfo::defaultCamera();
QList<QCameraInfo> cameras = QCameraInfo::availableCameras();
QVERIFY(defaultCamera == cameras.at(1));
QVERIFY(defaultCamera != cameras.at(0));
QVERIFY(cameras.at(0) != cameras.at(1));
{
QCamera camera(defaultCamera);
QVERIFY(QCameraInfo(camera) == defaultCamera);
QVERIFY(QCameraInfo(camera) == cameras.at(1));
}
{
QCamera camera(cameras.at(0));
QVERIFY(QCameraInfo(camera) == cameras.at(0));
}
}
QTEST_MAIN(tst_QCameraInfo)
#include "tst_qcamerainfo.moc"

2
tests/auto/unit/qmediaobject/tst_qmediaobject.cpp
View File

@@ -380,7 +380,7 @@ void tst_QMediaObject::metaDataChanged()
QtTestMediaObject object(&service);
QSignalSpy changedSpy(&object, SIGNAL(metaDataChanged()));
QSignalSpy changedWithValueSpy(&object, SIGNAL(metaDataChanged(QString, QVariant)));
QSignalSpy changedWithValueSpy(&object, SIGNAL(metaDataChanged(QString,QVariant)));
service.metaData.setMetaData("key", "Value");
QCOMPARE(changedSpy.count(), 1);

19
tests/auto/unit/qmediaserviceprovider/mockserviceplugin1/mockserviceplugin1.cpp
View File

@@ -44,12 +44,10 @@
#include "../mockservice.h"
class MockServicePlugin1 : public QMediaServiceProviderPlugin,
public QMediaServiceSupportedFormatsInterface,
public QMediaServiceSupportedDevicesInterface
public QMediaServiceSupportedFormatsInterface
{
Q_OBJECT
Q_INTERFACES(QMediaServiceSupportedFormatsInterface)
Q_INTERFACES(QMediaServiceSupportedDevicesInterface)
Q_PLUGIN_METADATA(IID "org.qt-project.qt.mediaserviceproviderfactory/5.0" FILE "mockserviceplugin1.json")
public:
QStringList keys() const
@@ -87,21 +85,6 @@ public:
{
return QStringList("audio/ogg");
}
QList<QByteArray> devices(const QByteArray &service) const
{
Q_UNUSED(service);
QList<QByteArray> res;
return res;
}
QString deviceDescription(const QByteArray &service, const QByteArray &device)
{
if (devices(service).contains(device))
return QString(device)+" description";
else
return QString();
}
};
#include "mockserviceplugin1.moc"

41
tests/auto/unit/qmediaserviceprovider/mockserviceplugin3/mockserviceplugin3.cpp
View File

@@ -44,17 +44,22 @@
#include "../mockservice.h"
class MockServicePlugin3 : public QMediaServiceProviderPlugin,
public QMediaServiceSupportedDevicesInterface
public QMediaServiceSupportedDevicesInterface,
public QMediaServiceDefaultDeviceInterface,
public QMediaServiceCameraInfoInterface
{
Q_OBJECT
Q_INTERFACES(QMediaServiceSupportedDevicesInterface)
Q_INTERFACES(QMediaServiceDefaultDeviceInterface)
Q_INTERFACES(QMediaServiceCameraInfoInterface)
Q_PLUGIN_METADATA(IID "org.qt-project.qt.mediaserviceproviderfactory/5.0" FILE "mockserviceplugin3.json")
public:
QStringList keys() const
{
return QStringList() <<
QLatin1String(Q_MEDIASERVICE_MEDIAPLAYER) <<
QLatin1String(Q_MEDIASERVICE_AUDIOSOURCE);
QLatin1String(Q_MEDIASERVICE_AUDIOSOURCE) <<
QLatin1String(Q_MEDIASERVICE_CAMERA);
}
QMediaService* create(QString const& key)
@@ -70,12 +75,26 @@ public:
delete service;
}
QByteArray defaultDevice(const QByteArray &service) const
{
if (service == Q_MEDIASERVICE_AUDIOSOURCE)
return "audiosource1";
if (service == Q_MEDIASERVICE_CAMERA)
return "frontcamera";
return QByteArray();
}
QList<QByteArray> devices(const QByteArray &service) const
{
QList<QByteArray> res;
if (service == QByteArray(Q_MEDIASERVICE_AUDIOSOURCE))
if (service == Q_MEDIASERVICE_AUDIOSOURCE)
res << "audiosource1" << "audiosource2";
if (service == Q_MEDIASERVICE_CAMERA)
res << "frontcamera";
return res;
}
@@ -86,6 +105,22 @@ public:
else
return QString();
}
QCamera::Position cameraPosition(const QByteArray &device) const
{
if (device == "frontcamera")
return QCamera::FrontFace;
return QCamera::UnspecifiedPosition;
}
int cameraOrientation(const QByteArray &device) const
{
if (device == "frontcamera")
return 270;
return 0;
}
};
#include "mockserviceplugin3.moc"

2
tests/auto/unit/qmediaserviceprovider/mockserviceplugin3/mockserviceplugin3.json
View File

@@ -1,4 +1,4 @@
{
"Keys": ["mockserviceplugin3"],
"Services": ["org.qt-project.qt.mediaplayer", "org.qt-project.qt.audiosource"]
"Services": ["org.qt-project.qt.mediaplayer", "org.qt-project.qt.audiosource", "org.qt-project.qt.camera"]
}

118
tests/auto/unit/qmediaserviceprovider/mockserviceplugin5/mockserviceplugin5.cpp Normal file
View File

@@ -0,0 +1,118 @@
/****************************************************************************
**
** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <qmediaserviceproviderplugin.h>
#include <qmediaservice.h>
#include "../mockservice.h"
class MockServicePlugin5 : public QMediaServiceProviderPlugin,
public QMediaServiceSupportedDevicesInterface,
public QMediaServiceDefaultDeviceInterface,
public QMediaServiceCameraInfoInterface
{
Q_OBJECT
Q_INTERFACES(QMediaServiceSupportedDevicesInterface)
Q_INTERFACES(QMediaServiceDefaultDeviceInterface)
Q_INTERFACES(QMediaServiceCameraInfoInterface)
Q_PLUGIN_METADATA(IID "org.qt-project.qt.mediaserviceproviderfactory/5.0" FILE "mockserviceplugin5.json")
public:
QStringList keys() const
{
return QStringList() << QLatin1String(Q_MEDIASERVICE_CAMERA);
}
QMediaService* create(QString const& key)
{
if (keys().contains(key))
return new MockMediaService("MockServicePlugin5");
else
return 0;
}
void release(QMediaService *service)
{
delete service;
}
QByteArray defaultDevice(const QByteArray &service) const
{
if (service == Q_MEDIASERVICE_CAMERA)
return "backcamera";
return QByteArray();
}
QList<QByteArray> devices(const QByteArray &service) const
{
QList<QByteArray> res;
if (service == Q_MEDIASERVICE_CAMERA)
res << "backcamera" << "somecamera";
return res;
}
QString deviceDescription(const QByteArray &service, const QByteArray &device)
{
if (devices(service).contains(device))
return QString(device)+" description";
else
return QString();
}
QCamera::Position cameraPosition(const QByteArray &device) const
{
if (device == "backcamera")
return QCamera::BackFace;
return QCamera::UnspecifiedPosition;
}
int cameraOrientation(const QByteArray &device) const
{
if (device == "backcamera")
return 90;
return 0;
}
};
#include "mockserviceplugin5.moc"

4
tests/auto/unit/qmediaserviceprovider/mockserviceplugin5/mockserviceplugin5.json Normal file
View File

@@ -0,0 +1,4 @@
{
"Keys": ["mockserviceplugin5"],
"Services": ["org.qt-project.qt.camera"]
}

23
tests/auto/unit/qmediaserviceprovider/mockserviceplugin5/mockserviceplugin5.pro Normal file
View File

@@ -0,0 +1,23 @@
TARGET = mockserviceplugin5
QT += multimedia-private
PLUGIN_TYPE=mediaservice
PLUGIN_CLASS_NAME = MockServicePlugin5
load(qt_plugin)
DESTDIR = ../$${PLUGIN_TYPE}
win32 {
CONFIG(debug, debug|release) {
DESTDIR = ../debug/$${PLUGIN_TYPE}
} else {
DESTDIR = ../release/$${PLUGIN_TYPE}
}
}
HEADERS += ../mockservice.h
SOURCES += mockserviceplugin5.cpp
OTHER_FILES += mockserviceplugin5.json
target.path = $$[QT_INSTALL_TESTS]/tst_qmediaserviceprovider/$${PLUGIN_TYPE}
DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0

1
tests/auto/unit/qmediaserviceprovider/qmediaserviceprovider.pro
View File

@@ -6,6 +6,7 @@ SUBDIRS += \
mockserviceplugin2 \
mockserviceplugin3 \
mockserviceplugin4 \
mockserviceplugin5 \
test
# no special install rule for subdir

116
tests/auto/unit/qmediaserviceprovider/tst_qmediaserviceprovider.cpp
View File

@@ -52,6 +52,8 @@
#include <qmediaservice.h>
#include <qmediaplayer.h>
#include <qaudiorecorder.h>
#include <qcamera.h>
#include <qcamerainfo.h>
QT_USE_NAMESPACE
@@ -83,6 +85,9 @@ private slots:
void testHasSupport();
void testSupportedMimeTypes();
void testProviderHints();
void testDefaultDevice();
void testAvailableDevices();
void testCameraInfo();
private:
QObjectList plugins;
@@ -195,6 +200,7 @@ void tst_QMediaServiceProvider::testProviderHints()
QVERIFY(hint.isNull());
QCOMPARE(hint.type(), QMediaServiceProviderHint::Null);
QVERIFY(hint.device().isEmpty());
QCOMPARE(hint.cameraPosition(), QCamera::UnspecifiedPosition);
QVERIFY(hint.mimeType().isEmpty());
QVERIFY(hint.codecs().isEmpty());
QCOMPARE(hint.features(), 0);
@@ -206,6 +212,18 @@ void tst_QMediaServiceProvider::testProviderHints()
QVERIFY(!hint.isNull());
QCOMPARE(hint.type(), QMediaServiceProviderHint::Device);
QCOMPARE(hint.device(), deviceName);
QCOMPARE(hint.cameraPosition(), QCamera::UnspecifiedPosition);
QVERIFY(hint.mimeType().isEmpty());
QVERIFY(hint.codecs().isEmpty());
QCOMPARE(hint.features(), 0);
}
{
QMediaServiceProviderHint hint(QCamera::FrontFace);
QVERIFY(!hint.isNull());
QCOMPARE(hint.type(), QMediaServiceProviderHint::CameraPosition);
QVERIFY(hint.device().isEmpty());
QCOMPARE(hint.cameraPosition(), QCamera::FrontFace);
QVERIFY(hint.mimeType().isEmpty());
QVERIFY(hint.codecs().isEmpty());
QCOMPARE(hint.features(), 0);
@@ -216,6 +234,7 @@ void tst_QMediaServiceProvider::testProviderHints()
QVERIFY(!hint.isNull());
QCOMPARE(hint.type(), QMediaServiceProviderHint::SupportedFeatures);
QVERIFY(hint.device().isEmpty());
QCOMPARE(hint.cameraPosition(), QCamera::UnspecifiedPosition);
QVERIFY(hint.mimeType().isEmpty());
QVERIFY(hint.codecs().isEmpty());
QCOMPARE(hint.features(), QMediaServiceProviderHint::LowLatencyPlayback);
@@ -226,6 +245,7 @@ void tst_QMediaServiceProvider::testProviderHints()
QVERIFY(!hint.isNull());
QCOMPARE(hint.type(), QMediaServiceProviderHint::SupportedFeatures);
QVERIFY(hint.device().isEmpty());
QCOMPARE(hint.cameraPosition(), QCamera::UnspecifiedPosition);
QVERIFY(hint.mimeType().isEmpty());
QVERIFY(hint.codecs().isEmpty());
QCOMPARE(hint.features(), QMediaServiceProviderHint::RecordingSupport);
@@ -240,6 +260,7 @@ void tst_QMediaServiceProvider::testProviderHints()
QVERIFY(!hint.isNull());
QCOMPARE(hint.type(), QMediaServiceProviderHint::ContentType);
QVERIFY(hint.device().isEmpty());
QCOMPARE(hint.cameraPosition(), QCamera::UnspecifiedPosition);
QCOMPARE(hint.mimeType(), mimeType);
QCOMPARE(hint.codecs(), codecs);
@@ -248,6 +269,7 @@ void tst_QMediaServiceProvider::testProviderHints()
QVERIFY(!hint2.isNull());
QCOMPARE(hint2.type(), QMediaServiceProviderHint::ContentType);
QVERIFY(hint2.device().isEmpty());
QCOMPARE(hint.cameraPosition(), QCamera::UnspecifiedPosition);
QCOMPARE(hint2.mimeType(), mimeType);
QCOMPARE(hint2.codecs(), codecs);
@@ -257,6 +279,7 @@ void tst_QMediaServiceProvider::testProviderHints()
QVERIFY(!hint3.isNull());
QCOMPARE(hint3.type(), QMediaServiceProviderHint::ContentType);
QVERIFY(hint3.device().isEmpty());
QCOMPARE(hint.cameraPosition(), QCamera::UnspecifiedPosition);
QCOMPARE(hint3.mimeType(), mimeType);
QCOMPARE(hint3.codecs(), codecs);
@@ -271,6 +294,99 @@ void tst_QMediaServiceProvider::testProviderHints()
}
}
void tst_QMediaServiceProvider::testDefaultDevice()
{
QMediaServiceProvider *provider = QMediaServiceProvider::defaultServiceProvider();
if (provider == 0)
QSKIP("No default provider");
QCOMPARE(provider->defaultDevice(Q_MEDIASERVICE_AUDIOSOURCE), QByteArray("audiosource1"));
QCOMPARE(provider->defaultDevice(Q_MEDIASERVICE_CAMERA), QByteArray("frontcamera"));
}
void tst_QMediaServiceProvider::testAvailableDevices()
{
QMediaServiceProvider *provider = QMediaServiceProvider::defaultServiceProvider();
if (provider == 0)
QSKIP("No default provider");
QList<QByteArray> devices = provider->devices(Q_MEDIASERVICE_AUDIOSOURCE);
QCOMPARE(devices.count(), 2);
QCOMPARE(devices.at(0), QByteArray("audiosource1"));
QCOMPARE(devices.at(1), QByteArray("audiosource2"));
devices = provider->devices(Q_MEDIASERVICE_CAMERA);
QCOMPARE(devices.count(), 3);
QCOMPARE(devices.at(0), QByteArray("frontcamera"));
QCOMPARE(devices.at(1), QByteArray("backcamera"));
QCOMPARE(devices.at(2), QByteArray("somecamera"));
}
void tst_QMediaServiceProvider::testCameraInfo()
{
QMediaServiceProvider *provider = QMediaServiceProvider::defaultServiceProvider();
if (provider == 0)
QSKIP("No default provider");
QCOMPARE(provider->cameraPosition("backcamera"), QCamera::BackFace);
QCOMPARE(provider->cameraOrientation("backcamera"), 90);
QCOMPARE(provider->cameraPosition("frontcamera"), QCamera::FrontFace);
QCOMPARE(provider->cameraOrientation("frontcamera"), 270);
QCOMPARE(provider->cameraPosition("somecamera"), QCamera::UnspecifiedPosition);
QCOMPARE(provider->cameraOrientation("somecamera"), 0);
{
QCamera camera;
QVERIFY(camera.service());
QCOMPARE(camera.service()->objectName(), QLatin1String("MockServicePlugin3"));
}
{
QCamera camera(QCameraInfo::defaultCamera());
QVERIFY(camera.service());
QCOMPARE(camera.service()->objectName(), QLatin1String("MockServicePlugin3"));
}
{
QCamera camera(QCameraInfo::availableCameras().at(0));
QVERIFY(camera.service());
QCOMPARE(camera.service()->objectName(), QLatin1String("MockServicePlugin3"));
}
{
QCamera camera(QCameraInfo::availableCameras().at(1));
QVERIFY(camera.service());
QCOMPARE(camera.service()->objectName(), QLatin1String("MockServicePlugin5"));
}
{
QCamera camera(QCameraInfo::availableCameras().at(2));
QVERIFY(camera.service());
QCOMPARE(camera.service()->objectName(), QLatin1String("MockServicePlugin5"));
}
{
QCamera camera(QCamera::FrontFace);
QVERIFY(camera.service());
QCOMPARE(camera.service()->objectName(), QLatin1String("MockServicePlugin3"));
}
{
QCamera camera(QCamera::BackFace);
QVERIFY(camera.service());
QCOMPARE(camera.service()->objectName(), QLatin1String("MockServicePlugin5"));
}
{
QCamera camera(QCamera::UnspecifiedPosition);
QVERIFY(camera.service());
QCOMPARE(camera.service()->objectName(), QLatin1String("MockServicePlugin3"));
}
}
QTEST_MAIN(tst_QMediaServiceProvider)
#include "tst_qmediaserviceprovider.moc"

2
tests/auto/unit/qmultimedia_common/mockcamera.pri
View File

@@ -17,6 +17,8 @@ HEADERS *= \
../qmultimedia_common/mockcameracapturebuffercontrol.h \
../qmultimedia_common/mockimageencodercontrol.h \
../qmultimedia_common/mockcameracontrol.h \
../qmultimedia_common/mockvideodeviceselectorcontrol.h \
../qmultimedia_common/mockcamerainfocontrol.h
include(mockvideo.pri)

85
tests/auto/unit/qmultimedia_common/mockcamerainfocontrol.h Normal file
View File

@@ -0,0 +1,85 @@
/****************************************************************************
**
** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef MOCKCAMERAINFOCONTROL_H
#define MOCKCAMERAINFOCONTROL_H
#include <qcamerainfocontrol.h>
class MockCameraInfoControl : public QCameraInfoControl
{
Q_OBJECT
public:
MockCameraInfoControl(QObject *parent)
: QCameraInfoControl(parent)
{
}
~MockCameraInfoControl() { }
QCamera::Position cameraPosition(const QString &deviceName) const
{
return position(deviceName.toLatin1());
}
int cameraOrientation(const QString &deviceName) const
{
return orientation(deviceName.toLatin1());
}
static QCamera::Position position(const QByteArray &camera)
{
if (camera == "backcamera")
return QCamera::BackFace;
else
return QCamera::UnspecifiedPosition;
}
static int orientation(const QByteArray &camera)
{
if (camera == "backcamera")
return 90;
else
return 0;
}
};
#endif // MOCKCAMERAINFOCONTROL_H

12
tests/auto/unit/qmultimedia_common/mockcameraservice.h
View File

@@ -57,6 +57,8 @@
#include "../qmultimedia_common/mockvideosurface.h"
#include "../qmultimedia_common/mockvideorenderercontrol.h"
#include "../qmultimedia_common/mockvideowindowcontrol.h"
#include "../qmultimedia_common/mockvideodeviceselectorcontrol.h"
#include "../qmultimedia_common/mockcamerainfocontrol.h"
class MockSimpleCameraService : public QMediaService
{
@@ -105,6 +107,8 @@ public:
mockImageEncoderControl = new MockImageEncoderControl(this);
rendererControl = new MockVideoRendererControl(this);
windowControl = new MockVideoWindowControl(this);
mockVideoDeviceSelectorControl = new MockVideoDeviceSelectorControl(this);
mockCameraInfoControl = new MockCameraInfoControl(this);
rendererRef = 0;
windowRef = 0;
}
@@ -148,6 +152,12 @@ public:
if (qstrcmp(iid, QImageEncoderControl_iid) == 0)
return mockImageEncoderControl;
if (qstrcmp(iid, QVideoDeviceSelectorControl_iid) == 0)
return mockVideoDeviceSelectorControl;
if (qstrcmp(iid, QCameraInfoControl_iid) == 0)
return mockCameraInfoControl;
if (qstrcmp(iid, QVideoRendererControl_iid) == 0) {
if (rendererRef == 0) {
rendererRef += 1;
@@ -184,6 +194,8 @@ public:
MockImageEncoderControl *mockImageEncoderControl;
MockVideoRendererControl *rendererControl;
MockVideoWindowControl *windowControl;
MockVideoDeviceSelectorControl *mockVideoDeviceSelectorControl;
MockCameraInfoControl *mockCameraInfoControl;
int rendererRef;
int windowRef;
};

36
tests/auto/unit/qmultimedia_common/mockmediaserviceprovider.h
View File

@@ -44,6 +44,8 @@
#include "private/qmediaserviceprovider_p.h"
#include "qmediaservice.h"
#include "mockvideodeviceselectorcontrol.h"
#include "mockcamerainfocontrol.h"
// Simple provider that lets you set the service
class MockMediaServiceProvider : public QMediaServiceProvider
@@ -67,6 +69,40 @@ public:
}
}
QByteArray defaultDevice(const QByteArray &serviceType) const
{
if (serviceType == Q_MEDIASERVICE_CAMERA)
return MockVideoDeviceSelectorControl::defaultCamera();
return QByteArray();
}
QList<QByteArray> devices(const QByteArray &serviceType) const
{
if (serviceType == Q_MEDIASERVICE_CAMERA)
return MockVideoDeviceSelectorControl::availableCameras();
return QList<QByteArray>();
}
QString deviceDescription(const QByteArray &serviceType, const QByteArray &device)
{
if (serviceType == Q_MEDIASERVICE_CAMERA)
return MockVideoDeviceSelectorControl::cameraDescription(device);
return QString();
}
QCamera::Position cameraPosition(const QByteArray &device) const
{
return MockCameraInfoControl::position(device);
}
int cameraOrientation(const QByteArray &device) const
{
return MockCameraInfoControl::orientation(device);
}
QMediaService *service;
bool deleteServiceOnRelease;
};

99
tests/auto/unit/qmultimedia_common/mockvideodeviceselectorcontrol.h Normal file
View File

@@ -0,0 +1,99 @@
/****************************************************************************
**
** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef MOCKVIDEODEVICESELECTORCONTROL_H
#define MOCKVIDEODEVICESELECTORCONTROL_H
#include <qvideodeviceselectorcontrol.h>
class MockVideoDeviceSelectorControl : public QVideoDeviceSelectorControl
{
Q_OBJECT
public:
MockVideoDeviceSelectorControl(QObject *parent)
: QVideoDeviceSelectorControl(parent)
, m_selectedDevice(1)
{
}
~MockVideoDeviceSelectorControl() { }
int deviceCount() const { return availableCameras().count(); }
QString deviceName(int index) const { return QString::fromLatin1(availableCameras().at(index)); }
QString deviceDescription(int index) const { return cameraDescription(availableCameras().at(index)); }
int defaultDevice() const { return availableCameras().indexOf(defaultCamera()); }
int selectedDevice() const { return m_selectedDevice; }
void setSelectedDevice(int index)
{
m_selectedDevice = index;
emit selectedDeviceChanged(m_selectedDevice);
emit selectedDeviceChanged(deviceName(m_selectedDevice));
}
static QByteArray defaultCamera()
{
return "othercamera";
}
static QList<QByteArray> availableCameras()
{
return QList<QByteArray>() << "backcamera" << "othercamera";
}
static QString cameraDescription(const QByteArray &camera)
{
if (camera == "backcamera")
return QStringLiteral("backcamera desc");
else if (camera == "othercamera")
return QStringLiteral("othercamera desc");
else
return QString();
}
private:
int m_selectedDevice;
QStringList m_devices;
QStringList m_descriptions;
};
#endif // MOCKVIDEODEVICESELECTORCONTROL_H