1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include <QtTest/QtTest>

    43 #include <QDebug>

    44 

    45 #include <experimental/qcameracontrol.h>

    46 #include <experimental/qcameraexposurecontrol.h>

    47 #include <experimental/qcamerafocuscontrol.h>

    48 #include <experimental/qimagecapturecontrol.h>

    49 #include <qimageencodercontrol.h>

    50 #include <experimental/qimageprocessingcontrol.h>

    51 #include <qmediaservice.h>

    52 #include <experimental/qcamera.h>

    53 #include <experimental/qstillimagecapture.h>

    54 

    55 QTM_USE_NAMESPACE

    56 class MockCaptureControl;

    57 

    58 class MockCameraControl : public QCameraControl

    59 {

    60     friend class MockCaptureControl;

    61     Q_OBJECT

    62 public:

    63     MockCameraControl(QObject *parent = 0):

    64             QCameraControl(parent),

    65             m_state(QCamera::StoppedState),

    66             m_captureMode(QCamera::CaptureStillImage)

    67     {

    68     }

    69 

    70     ~MockCameraControl() {}

    71 

    72     void start() { m_state = QCamera::ActiveState; }

    73     virtual void stop() { m_state = QCamera::StoppedState; }

    74     QCamera::State state() const { return m_state; }

    75 

    76     QCamera::CaptureMode captureMode() const { return m_captureMode; }

    77     void setCaptureMode(QCamera::CaptureMode mode)

    78     {

    79         if (m_captureMode != mode) {

    80             m_captureMode = mode;

    81             emit captureModeChanged(mode);

    82         }

    83     }

    84 

    85     QCamera::CaptureModes supportedCaptureModes() const

    86     {

    87         return QCamera::CaptureStillImage | QCamera::CaptureVideo;

    88     }

    89 

    90 

    91     QCamera::State m_state;

    92     QCamera::CaptureMode m_captureMode;

    93 };

    94 

    95 class MockCaptureControl : public QImageCaptureControl

    96 {

    97     Q_OBJECT

    98 public:

    99     MockCaptureControl(MockCameraControl *cameraControl, QObject *parent = 0)

   100         :QImageCaptureControl(parent), m_cameraControl(cameraControl)

   101     {

   102     }

   103 

   104     ~MockCaptureControl()

   105     {

   106     }

   107 

   108     bool isReadyForCapture() const { return m_cameraControl->state() == QCamera::ActiveState; }

   109 

   110     void capture(const QString &fileName)

   111     {

   112         if (isReadyForCapture())

   113             emit imageCaptured(fileName, QImage());

   114         else

   115             emit error(QStillImageCapture::NotReadyError,

   116                        QLatin1String("Could not capture in stopped state"));

   117     }

   118 

   119     MockCameraControl *m_cameraControl;

   120 

   121 };

   122 

   123 class MockCameraExposureControl : public QCameraExposureControl

   124 {

   125     Q_OBJECT

   126 public:

   127     MockCameraExposureControl(QObject *parent = 0):

   128         QCameraExposureControl(parent),

   129         m_exposureLocked(false),

   130         m_aperture(2.8),

   131         m_shutterSpeed(0.01),

   132         m_isoSensitivity(100),

   133         m_meteringMode(QCamera::MeteringMatrix),

   134         m_exposureCompensation(0),

   135         m_exposureMode(QCamera::ExposureAuto),

   136         m_flashMode(QCamera::FlashAuto)

   137     {

   138     }

   139 

   140     ~MockCameraExposureControl() {}

   141 

   142     QCamera::FlashMode flashMode() const

   143     {

   144         return m_flashMode;

   145     }

   146 

   147     void setFlashMode(QCamera::FlashMode mode)

   148     {

   149         if (supportedFlashModes() & mode) {

   150             m_flashMode = mode;

   151         }

   152     }

   153 

   154     QCamera::FlashModes supportedFlashModes() const

   155     {

   156         return QCamera::FlashAuto | QCamera::FlashOff | QCamera::FlashOn;

   157     }

   158 

   159     bool isFlashReady() const

   160     {

   161         return true;

   162     }

   163 

   164     QCamera::ExposureMode exposureMode() const

   165     {

   166         return m_exposureMode;

   167     }

   168 

   169     void setExposureMode(QCamera::ExposureMode mode)

   170     {

   171         if (supportedExposureModes() & mode)

   172             m_exposureMode = mode;

   173     }

   174 

   175     QCamera::ExposureModes supportedExposureModes() const

   176     {

   177         return QCamera::ExposureAuto | QCamera::ExposureManual;

   178     }

   179 

   180     qreal exposureCompensation() const

   181     {

   182         return m_exposureCompensation;

   183     }

   184 

   185     void setExposureCompensation(qreal ev)

   186     {

   187         m_exposureCompensation = ev;

   188     }

   189 

   190     QCamera::MeteringMode meteringMode() const

   191     {

   192         return m_meteringMode;

   193     }

   194 

   195     void setMeteringMode(QCamera::MeteringMode mode)

   196     {

   197         if (supportedMeteringModes() & mode)

   198             m_meteringMode = mode;

   199     }

   200 

   201     QCamera::MeteringModes supportedMeteringModes() const

   202     {

   203         return QCamera::MeteringAverage | QCamera::MeteringMatrix;

   204     }

   205 

   206     int isoSensitivity() const

   207     {

   208         return m_isoSensitivity;

   209     }

   210 

   211     QList<int> supportedIsoSensitivities(bool * continuous) const

   212     {

   213         if (continuous)

   214             *continuous = false;

   215         return QList<int>() << 100 << 200 << 400 << 800;

   216     }

   217 

   218 

   219     void setManualIsoSensitivity(int iso)

   220     {

   221         m_isoSensitivity = 100*qRound(qBound(100, iso, 800)/100.0);

   222     }

   223 

   224     void setAutoIsoSensitivity()

   225     {

   226         m_isoSensitivity = 100;

   227     }

   228 

   229     qreal aperture() const

   230     {

   231         return m_aperture;

   232     }

   233 

   234     QList<qreal> supportedApertures(bool *continuous) const

   235     {

   236         if (continuous)

   237             *continuous = true;

   238         return QList<qreal>() << 2.8 << 4 << 5.6 << 8 << 11 << 16;

   239     }

   240 

   241     void setManualAperture(qreal aperture)

   242     {

   243         m_aperture = qBound<qreal>(2.8, aperture, 16.0);

   244     }

   245 

   246     void setAutoAperture()

   247     {

   248         m_aperture = 2.8;

   249     }

   250 

   251     qreal shutterSpeed() const

   252     {

   253         return m_shutterSpeed;

   254     }

   255 

   256     QList<qreal> supportedShutterSpeeds(bool *continuous) const

   257     {

   258         if (continuous)

   259             *continuous = false;

   260 

   261         return QList<qreal>() << 0.001 << 0.01 << 0.1 << 1.0;

   262     }

   263 

   264     void setManualShutterSpeed(qreal shutterSpeed)

   265     {

   266         m_shutterSpeed = qBound<qreal>(0.001, shutterSpeed, 1.0);

   267     }

   268 

   269     void setAutoShutterSpeed()

   270     {

   271         m_shutterSpeed = 0.01;

   272     }

   273 

   274     bool isExposureLocked() const

   275     {

   276         return m_exposureLocked;

   277     }

   278 

   279 public Q_SLOTS:

   280     void lockExposure()

   281     {

   282         if (!m_exposureLocked) {

   283             m_exposureLocked = true;

   284             emit exposureLocked();

   285         }

   286     }

   287 

   288     void unlockExposure()

   289     {

   290         m_exposureLocked = false;

   291     }

   292 

   293 

   294 private:

   295     bool m_exposureLocked;

   296     qreal m_aperture;

   297     qreal m_shutterSpeed;

   298     int m_isoSensitivity;

   299     QCamera::MeteringMode m_meteringMode;

   300     qreal m_exposureCompensation;

   301     QCamera::ExposureMode m_exposureMode;

   302     QCamera::FlashMode m_flashMode;

   303 };

   304 

   305 class MockCameraFocusControl : public QCameraFocusControl

   306 {

   307     Q_OBJECT

   308 public:

   309     MockCameraFocusControl(QObject *parent = 0):

   310         QCameraFocusControl(parent),

   311         m_opticalZoom(1.0),

   312         m_digitalZoom(1.0),

   313         m_macroFocusingEnabled(false),

   314         m_focusMode(QCamera::AutoFocus),

   315         m_focusStatus(QCamera::FocusInitial)

   316     {

   317     }

   318 

   319     ~MockCameraFocusControl() {}

   320 

   321     QCamera::FocusMode focusMode() const

   322     {

   323         return m_focusMode;

   324     }

   325 

   326     void setFocusMode(QCamera::FocusMode mode)

   327     {

   328         if (supportedFocusModes() & mode)

   329             m_focusMode = mode;

   330     }

   331 

   332     QCamera::FocusModes supportedFocusModes() const

   333     {

   334         return QCamera::AutoFocus | QCamera::ContinuousFocus;

   335     }

   336 

   337     QCamera::FocusStatus focusStatus() const

   338     {

   339         return m_focusStatus;

   340     }

   341 

   342     bool macroFocusingEnabled() const

   343     {

   344         return m_macroFocusingEnabled;

   345     }

   346 

   347     bool isMacroFocusingSupported() const

   348     {

   349         return true;

   350     }

   351 

   352     void setMacroFocusingEnabled(bool flag)

   353     {

   354         if (isMacroFocusingSupported())

   355             m_macroFocusingEnabled = flag;

   356     }

   357 

   358     qreal maximumOpticalZoom() const

   359     {

   360         return 3.0;

   361     }

   362 

   363     qreal maximumDigitalZoom() const

   364     {

   365         return 4.0;

   366     }

   367 

   368     qreal opticalZoom() const

   369     {

   370         return m_opticalZoom;

   371     }

   372 

   373     qreal digitalZoom() const

   374     {

   375         return m_digitalZoom;

   376     }

   377 

   378     void zoomTo(qreal optical, qreal digital)

   379     {

   380         optical = qBound<qreal>(1.0, optical, maximumOpticalZoom());

   381         digital = qBound<qreal>(1.0, digital, maximumDigitalZoom());

   382 

   383         if (!qFuzzyCompare(digital, m_digitalZoom)) {

   384             m_digitalZoom = digital;

   385             emit digitalZoomChanged(m_digitalZoom);

   386         }

   387 

   388         if (!qFuzzyCompare(optical, m_opticalZoom)) {

   389             m_opticalZoom = optical;

   390             emit opticalZoomChanged(m_opticalZoom);

   391         }

   392     }

   393 

   394 public Q_SLOTS:

   395     void startFocusing()

   396     {

   397     }

   398 

   399     void cancelFocusing()

   400     {

   401     }

   402 

   403 private:

   404     qreal m_opticalZoom;

   405     qreal m_digitalZoom;

   406     bool m_macroFocusingEnabled;

   407     QCamera::FocusMode m_focusMode;

   408     QCamera::FocusStatus m_focusStatus;

   409 };

   410 

   411 class MockImageProcessingControl : public QImageProcessingControl

   412 {

   413 public:

   414     MockImageProcessingControl(QObject *parent = 0)

   415         : QImageProcessingControl(parent)

   416         , m_supportedWhiteBalance(QCamera::WhiteBalanceAuto)

   417         , m_contrast(0.0)

   418         , m_saturation(0.0)

   419         , m_sharpeningLevel(0.0)

   420         , m_denoisingLevel(0.0)

   421         , m_sharpeningSupported(false)

   422         , m_denoisingSupported(true)

   423     {

   424     }

   425 

   426     QCamera::WhiteBalanceMode whiteBalanceMode() const { return m_whiteBalanceMode; }

   427     void setWhiteBalanceMode(QCamera::WhiteBalanceMode mode) { m_whiteBalanceMode = mode; }

   428 

   429     QCamera::WhiteBalanceModes supportedWhiteBalanceModes() const {

   430         return m_supportedWhiteBalance; }

   431     void setSupportedWhiteBalanceModes(QCamera::WhiteBalanceModes modes) {

   432         m_supportedWhiteBalance = modes; }

   433 

   434     int manualWhiteBalance() const { return m_manualWhiteBalance; }

   435     void setManualWhiteBalance(int colorTemperature) { m_manualWhiteBalance = colorTemperature; }

   436 

   437     qreal contrast() const { return m_contrast; }

   438     void setContrast(qreal value) { m_contrast = value; }

   439 

   440     qreal saturation() const { return m_saturation; }

   441     void setSaturation(qreal value) { m_saturation = value; }

   442 

   443     bool isSharpeningSupported() const { return m_sharpeningSupported; }

   444     void setSharpendingSupported(bool supported) { m_sharpeningSupported = supported; }

   445 

   446     qreal sharpeningLevel() const { return m_sharpeningLevel; }

   447     void setSharpeningLevel(qreal value) { m_sharpeningLevel = value; }

   448 

   449     bool isDenoisingSupported() const { return m_denoisingSupported; }

   450     void setDenoisingSupported(bool supported) { m_denoisingSupported = supported; }

   451     qreal denoisingLevel() const { return m_denoisingLevel; }

   452     void setDenoisingLevel(qreal value) { m_denoisingLevel = value; }

   453 

   454 private:

   455     QCamera::WhiteBalanceMode m_whiteBalanceMode;

   456     QCamera::WhiteBalanceModes m_supportedWhiteBalance;

   457     int m_manualWhiteBalance;

   458     qreal m_contrast;

   459     qreal m_saturation;

   460     qreal m_sharpeningLevel;

   461     qreal m_denoisingLevel;

   462     bool m_sharpeningSupported;

   463     bool m_denoisingSupported;

   464 };

   465 

   466 class MockImageEncoderControl : public QImageEncoderControl

   467 {

   468 public:

   469     MockImageEncoderControl(QObject *parent = 0)

   470         : QImageEncoderControl(parent)

   471     {

   472     }

   473 

   474     QList<QSize> supportedResolutions(const QImageEncoderSettings & = QImageEncoderSettings(),

   475                                       bool *continuous = 0) const

   476     {

   477         if (continuous)

   478             *continuous = true;

   479 

   480         return m_supportedResolutions;

   481     }

   482 

   483     void setSupportedResolutions(const QList<QSize> &resolutions) {

   484         m_supportedResolutions = resolutions; }

   485 

   486     QStringList supportedImageCodecs() const { return m_supportedCodecs; }

   487     void setSupportedImageCodecs(const QStringList &codecs) { m_supportedCodecs = codecs; }

   488 

   489     QString imageCodecDescription(const QString &codecName) const {

   490         return m_codecDescriptions.value(codecName); }

   491     void setImageCodecDescriptions(const QMap<QString, QString> &descriptions) {

   492         m_codecDescriptions = descriptions; }

   493 

   494     QImageEncoderSettings imageSettings() const { return m_settings; }

   495     void setImageSettings(const QImageEncoderSettings &settings) { m_settings = settings; }

   496 

   497 private:

   498     QImageEncoderSettings m_settings;

   499 

   500     QList<QSize> m_supportedResolutions;

   501     QStringList m_supportedCodecs;

   502     QMap<QString, QString> m_codecDescriptions;

   503 };

   504 

   505 class MockSimpleCameraService : public QMediaService

   506 {

   507     Q_OBJECT

   508 

   509 public:

   510     MockSimpleCameraService(): QMediaService(0)

   511     {

   512         mockControl = new MockCameraControl(this);

   513     }

   514 

   515     ~MockSimpleCameraService()

   516     {

   517     }

   518 

   519     QMediaControl* control(const char *iid) const

   520     {

   521         if (qstrcmp(iid, QCameraControl_iid) == 0)

   522             return mockControl;

   523         return 0;

   524     }

   525 

   526     MockCameraControl *mockControl;

   527 };

   528 

   529 class MockCameraService : public QMediaService

   530 {

   531     Q_OBJECT

   532 

   533 public:

   534     MockCameraService(): QMediaService(0)

   535     {

   536         mockControl = new MockCameraControl(this);

   537         mockExposureControl = new MockCameraExposureControl(this);

   538         mockFocusControl = new MockCameraFocusControl(this);

   539         mockCaptureControl = new MockCaptureControl(mockControl, this);

   540         mockImageProcessingControl = new MockImageProcessingControl(this);

   541         mockImageEncoderControl = new MockImageEncoderControl(this);

   542     }

   543 

   544     ~MockCameraService()

   545     {

   546     }

   547 

   548     QMediaControl* control(const char *iid) const

   549     {

   550         if (qstrcmp(iid, QCameraControl_iid) == 0)

   551             return mockControl;

   552 

   553         if (qstrcmp(iid, QCameraExposureControl_iid) == 0)

   554             return mockExposureControl;

   555 

   556         if (qstrcmp(iid, QCameraFocusControl_iid) == 0)

   557             return mockFocusControl;

   558 

   559         if (qstrcmp(iid, QImageCaptureControl_iid) == 0)

   560             return mockCaptureControl;

   561 

   562         if (qstrcmp(iid, QImageProcessingControl_iid) == 0)

   563             return mockImageProcessingControl;

   564 

   565         if (qstrcmp(iid, QImageEncoderControl_iid) == 0)

   566             return mockImageEncoderControl;

   567 

   568         return 0;

   569     }

   570 

   571     MockCameraControl *mockControl;

   572     MockCaptureControl *mockCaptureControl;

   573     MockCameraExposureControl *mockExposureControl;

   574     MockCameraFocusControl *mockFocusControl;

   575     MockImageProcessingControl *mockImageProcessingControl;

   576     MockImageEncoderControl *mockImageEncoderControl;

   577 };

   578 

   579 class MockProvider : public QMediaServiceProvider

   580 {

   581 public:

   582     QMediaService *requestService(const QByteArray &, const QMediaServiceProviderHint &)

   583     {

   584         return service;

   585     }

   586 

   587     void releaseService(QMediaService *) {}

   588 

   589     QMediaService *service;

   590 };

   591 

   592 

   593 class tst_QCamera: public QObject

   594 {

   595     Q_OBJECT

   596 

   597 public slots:

   598     void initTestCase();

   599     void cleanupTestCase();

   600 

   601 private slots:

   602     void testAvailableDevices();

   603     void testDeviceDescription();

   604     void testCtorWithDevice();

   605     void testSimpleCamera();

   606     void testSimpleCameraWhiteBalance();

   607     void testSimpleCameraExposure();

   608     void testSimpleCameraFocus();

   609     void testSimpleCameraCapture();

   610 

   611     void testCameraWhiteBalance();

   612     void testCameraExposure();

   613     void testCameraFocus();

   614     void testCameraCapture();

   615     void testImageSettings();

   616 

   617 private:

   618     MockSimpleCameraService  *mockSimpleCameraService;

   619     MockProvider *provider;

   620 };

   621 

   622 void tst_QCamera::initTestCase()

   623 {

   624     provider = new MockProvider;

   625     mockSimpleCameraService = new MockSimpleCameraService;

   626     provider->service = mockSimpleCameraService;

   627 

   628     qRegisterMetaType<QCamera::Error>("QCamera::Error");

   629 }

   630 

   631 void tst_QCamera::cleanupTestCase()

   632 {

   633     delete mockSimpleCameraService;

   634     delete provider;

   635 }

   636 

   637 void tst_QCamera::testAvailableDevices()

   638 {

   639     int deviceCount = QMediaServiceProvider::defaultServiceProvider()->devices(QByteArray(Q_MEDIASERVICE_CAMERA)).count();

   640 

   641     QVERIFY(QCamera::availableDevices().count() == deviceCount);

   642 }

   643 

   644 void tst_QCamera::testDeviceDescription()

   645 {

   646     int deviceCount = QMediaServiceProvider::defaultServiceProvider()->devices(QByteArray(Q_MEDIASERVICE_CAMERA)).count();

   647 

   648     if (deviceCount == 0)

   649         QVERIFY(QCamera::deviceDescription(QByteArray("random")).isNull());

   650     else {

   651         foreach (const QByteArray &device, QCamera::availableDevices())

   652             QVERIFY(QCamera::deviceDescription(device).length() > 0);

   653     }

   654 }

   655 

   656 void tst_QCamera::testCtorWithDevice()

   657 {

   658     int deviceCount = QMediaServiceProvider::defaultServiceProvider()->devices(QByteArray(Q_MEDIASERVICE_CAMERA)).count();

   659     QCamera *camera = 0;

   660 

   661     if (deviceCount == 0) {

   662         camera = new QCamera("random");

   663         QVERIFY(camera->error() == QCamera::ServiceMissingError);

   664     }

   665     else {

   666         camera = new QCamera(QCamera::availableDevices().first());

   667         QVERIFY(camera->error() == QCamera::NoError);

   668     }

   669 

   670     delete camera;

   671 }

   672 

   673 void tst_QCamera::testSimpleCamera()

   674 {

   675     QCamera camera(0, provider);

   676     QCOMPARE(camera.service(), (QMediaService*)mockSimpleCameraService);

   677 

   678     QCOMPARE(camera.state(), QCamera::StoppedState);

   679     camera.start();

   680     QCOMPARE(camera.state(), QCamera::ActiveState);

   681     camera.stop();

   682     QCOMPARE(camera.state(), QCamera::StoppedState);

   683 }

   684 

   685 void tst_QCamera::testSimpleCameraWhiteBalance()

   686 {

   687     QCamera camera(0, provider);

   688 

   689     //only WhiteBalanceAuto is supported

   690     QCOMPARE(camera.supportedWhiteBalanceModes(), QCamera::WhiteBalanceAuto);

   691     QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceAuto);

   692     camera.setWhiteBalanceMode(QCamera::WhiteBalanceCloudy);

   693     QCOMPARE(camera.supportedWhiteBalanceModes(), QCamera::WhiteBalanceAuto);

   694     QCOMPARE(camera.manualWhiteBalance(), -1);

   695     camera.setManualWhiteBalance(5000);

   696     QCOMPARE(camera.manualWhiteBalance(), -1);

   697 }

   698 

   699 void tst_QCamera::testSimpleCameraExposure()

   700 {

   701     QCamera camera(0, provider);

   702 

   703     QCOMPARE(camera.supportedExposureModes(), QCamera::ExposureAuto);

   704     QCOMPARE(camera.exposureMode(), QCamera::ExposureAuto);

   705     camera.setExposureMode(QCamera::ExposureManual);//should be ignored

   706     QCOMPARE(camera.exposureMode(), QCamera::ExposureAuto);

   707 

   708     QCOMPARE(camera.supportedFlashModes(), QCamera::FlashOff);

   709     QCOMPARE(camera.flashMode(), QCamera::FlashOff);

   710     QCOMPARE(camera.isFlashReady(), false);

   711     camera.setFlashMode(QCamera::FlashOn);

   712     QCOMPARE(camera.flashMode(), QCamera::FlashOff);

   713 

   714     QCOMPARE(camera.supportedMeteringModes(), QCamera::MeteringMatrix);

   715     QCOMPARE(camera.meteringMode(), QCamera::MeteringMatrix);

   716     camera.setMeteringMode(QCamera::MeteringSpot);

   717     QCOMPARE(camera.meteringMode(), QCamera::MeteringMatrix);

   718 

   719     QCOMPARE(camera.exposureCompensation(), 0.0);

   720     camera.setExposureCompensation(2.0);

   721     QCOMPARE(camera.exposureCompensation(), 0.0);

   722 

   723     QCOMPARE(camera.isoSensitivity(), -1);    

   724     QVERIFY(camera.supportedIsoSensitivities().isEmpty());

   725     camera.setManualIsoSensitivity(100);

   726     QCOMPARE(camera.isoSensitivity(), -1);

   727     camera.setAutoIsoSensitivity();

   728     QCOMPARE(camera.isoSensitivity(), -1);

   729 

   730     QVERIFY(camera.aperture() < 0);

   731     QVERIFY(camera.supportedApertures().isEmpty());

   732     camera.setAutoAperture();

   733     QVERIFY(camera.aperture() < 0);

   734     camera.setManualAperture(5.6);

   735     QVERIFY(camera.aperture() < 0);

   736 

   737     QVERIFY(camera.shutterSpeed() < 0);

   738     QVERIFY(camera.supportedShutterSpeeds().isEmpty());

   739     camera.setAutoShutterSpeed();

   740     QVERIFY(camera.shutterSpeed() < 0);

   741     camera.setManualShutterSpeed(1/128.0);

   742     QVERIFY(camera.shutterSpeed() < 0);

   743 

   744     QCOMPARE(camera.isExposureLocked(), true);

   745 

   746 }

   747 

   748 void tst_QCamera::testSimpleCameraFocus()

   749 {

   750     QCamera camera(0, provider);

   751 

   752     QCOMPARE(camera.supportedFocusModes(), QCamera::AutoFocus);

   753     QCOMPARE(camera.focusMode(), QCamera::AutoFocus);

   754     camera.setFocusMode(QCamera::ContinuousFocus);

   755     QCOMPARE(camera.focusMode(), QCamera::AutoFocus);

   756     QCOMPARE(camera.focusStatus(), QCamera::FocusInitial);

   757 

   758     QVERIFY(!camera.isMacroFocusingSupported());

   759     QVERIFY(!camera.macroFocusingEnabled());

   760     camera.setMacroFocusingEnabled(true);

   761     QVERIFY(!camera.macroFocusingEnabled());

   762 

   763     QCOMPARE(camera.maximumOpticalZoom(), 1.0);

   764     QCOMPARE(camera.maximumDigitalZoom(), 1.0);

   765     QCOMPARE(camera.opticalZoom(), 1.0);

   766     QCOMPARE(camera.digitalZoom(), 1.0);

   767     QSignalSpy errorSignal(&camera, SIGNAL(error(QCamera::Error)));

   768     camera.zoomTo(100.0, 100.0);

   769     QCOMPARE(camera.opticalZoom(), 1.0);

   770     QCOMPARE(camera.digitalZoom(), 1.0);

   771     QCOMPARE(errorSignal.count(), 1);

   772     QCOMPARE(camera.error(), QCamera::NotSupportedFeatureError);

   773 }

   774 

   775 void tst_QCamera::testSimpleCameraCapture()

   776 {

   777     QCamera camera(0, provider);

   778     QStillImageCapture imageCapture(&camera);

   779 

   780     QVERIFY(!imageCapture.isReadyForCapture());

   781     QVERIFY(!imageCapture.isAvailable());

   782 

   783     QCOMPARE(imageCapture.error(), QStillImageCapture::NoError);

   784     QVERIFY(imageCapture.errorString().isEmpty());

   785 

   786     QSignalSpy errorSignal(&imageCapture, SIGNAL(error(QStillImageCapture::Error)));

   787     imageCapture.capture(QString::fromLatin1("/dev/null"));

   788     QCOMPARE(errorSignal.size(), 1);

   789     QCOMPARE(imageCapture.error(), QStillImageCapture::NotSupportedFeatureError);

   790     QVERIFY(!imageCapture.errorString().isEmpty());

   791 }

   792 

   793 void tst_QCamera::testCameraCapture()

   794 {

   795     MockCameraService service;

   796     provider->service = &service;

   797     QCamera camera(0, provider);

   798     QStillImageCapture imageCapture(&camera);

   799 

   800 

   801     QVERIFY(!imageCapture.isReadyForCapture());

   802 

   803     QSignalSpy capturedSignal(&imageCapture, SIGNAL(imageCaptured(QString,QImage)));

   804     QSignalSpy errorSignal(&imageCapture, SIGNAL(error(QStillImageCapture::Error)));

   805 

   806     imageCapture.capture(QString::fromLatin1("/dev/null"));

   807     QCOMPARE(capturedSignal.size(), 0);

   808     QCOMPARE(errorSignal.size(), 1);

   809     QCOMPARE(imageCapture.error(), QStillImageCapture::NotReadyError);

   810 

   811     errorSignal.clear();

   812 

   813     camera.start();

   814     QVERIFY(imageCapture.isReadyForCapture());

   815     QCOMPARE(errorSignal.size(), 0);

   816 

   817     imageCapture.capture(QString::fromLatin1("/dev/null"));

   818     QCOMPARE(capturedSignal.size(), 1);

   819     QCOMPARE(errorSignal.size(), 0);

   820     QCOMPARE(imageCapture.error(), QStillImageCapture::NoError);

   821 }

   822 

   823 void tst_QCamera::testCameraWhiteBalance()

   824 {

   825     QCamera::WhiteBalanceModes whiteBalanceModes

   826             = QCamera::WhiteBalanceAuto

   827             | QCamera::WhiteBalanceFlash

   828             | QCamera::WhiteBalanceIncandescent;

   829 

   830     MockCameraService service;

   831     service.mockImageProcessingControl->setWhiteBalanceMode(QCamera::WhiteBalanceFlash);

   832     service.mockImageProcessingControl->setSupportedWhiteBalanceModes(whiteBalanceModes);

   833     service.mockImageProcessingControl->setManualWhiteBalance(34);

   834 

   835     MockProvider provider;

   836     provider.service = &service;

   837 

   838     QCamera camera(0, &provider);

   839 

   840     QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceFlash);

   841     QCOMPARE(camera.supportedWhiteBalanceModes(), whiteBalanceModes);

   842 

   843     camera.setWhiteBalanceMode(QCamera::WhiteBalanceIncandescent);

   844     QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceIncandescent);

   845 

   846     camera.setWhiteBalanceMode(QCamera::WhiteBalanceManual);

   847     QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceManual);

   848     QCOMPARE(camera.manualWhiteBalance(), 34);

   849 

   850     camera.setManualWhiteBalance(432);

   851     QCOMPARE(camera.manualWhiteBalance(), 432);

   852 }

   853 

   854 void tst_QCamera::testCameraExposure()

   855 {

   856     MockCameraService service;

   857     provider->service = &service;

   858     QCamera camera(0, provider);

   859 

   860     QVERIFY(camera.supportedExposureModes() & QCamera::ExposureAuto);

   861     QCOMPARE(camera.exposureMode(), QCamera::ExposureAuto);

   862     camera.setExposureMode(QCamera::ExposureManual);

   863     QCOMPARE(camera.exposureMode(), QCamera::ExposureManual);

   864 

   865     QCOMPARE(camera.flashMode(), QCamera::FlashAuto);

   866     QCOMPARE(camera.isFlashReady(), true);

   867     camera.setFlashMode(QCamera::FlashOn);

   868     QCOMPARE(camera.flashMode(), QCamera::FlashOn);

   869 

   870     camera.setFlashMode(QCamera::FlashRedEyeReduction); // not expected to be supported

   871     QCOMPARE(camera.flashMode(), QCamera::FlashOn);

   872 

   873     QCOMPARE(camera.meteringMode(), QCamera::MeteringMatrix);

   874     camera.setMeteringMode(QCamera::MeteringAverage);

   875     QCOMPARE(camera.meteringMode(), QCamera::MeteringAverage);

   876     camera.setMeteringMode(QCamera::MeteringSpot);

   877     QCOMPARE(camera.meteringMode(), QCamera::MeteringAverage);

   878 

   879 

   880     QCOMPARE(camera.exposureCompensation(), 0.0);

   881     camera.setExposureCompensation(2.0);

   882     QCOMPARE(camera.exposureCompensation(), 2.0);

   883 

   884     int minIso = camera.supportedIsoSensitivities().first();

   885     int maxIso = camera.supportedIsoSensitivities().last();

   886     QVERIFY(camera.isoSensitivity() > 0);

   887     QVERIFY(minIso > 0);

   888     QVERIFY(maxIso > 0);

   889     camera.setManualIsoSensitivity(minIso);

   890     QCOMPARE(camera.isoSensitivity(), minIso);

   891     camera.setManualIsoSensitivity(maxIso*10);

   892     QCOMPARE(camera.isoSensitivity(), maxIso);

   893     camera.setManualIsoSensitivity(-10);

   894     QCOMPARE(camera.isoSensitivity(), minIso);

   895     camera.setAutoIsoSensitivity();

   896     QCOMPARE(camera.isoSensitivity(), 100);

   897 

   898     qreal minAperture = camera.supportedApertures().first();

   899     qreal maxAperture = camera.supportedApertures().last();

   900     QVERIFY(minAperture > 0);

   901     QVERIFY(maxAperture > 0);

   902     QVERIFY(camera.aperture() >= minAperture);

   903     QVERIFY(camera.aperture() <= maxAperture);

   904 

   905     camera.setAutoAperture();

   906     QVERIFY(camera.aperture() >= minAperture);

   907     QVERIFY(camera.aperture() <= maxAperture);

   908 

   909     camera.setManualAperture(0);

   910     QCOMPARE(camera.aperture(), minAperture);

   911 

   912     camera.setManualAperture(10000);

   913     QCOMPARE(camera.aperture(), maxAperture);

   914 

   915 

   916     qreal minShutterSpeed = camera.supportedShutterSpeeds().first();

   917     qreal maxShutterSpeed = camera.supportedShutterSpeeds().last();

   918     QVERIFY(minShutterSpeed > 0);

   919     QVERIFY(maxShutterSpeed > 0);

   920     QVERIFY(camera.shutterSpeed() >= minShutterSpeed);

   921     QVERIFY(camera.shutterSpeed() <= maxShutterSpeed);

   922 

   923     camera.setAutoShutterSpeed();

   924     QVERIFY(camera.shutterSpeed() >= minShutterSpeed);

   925     QVERIFY(camera.shutterSpeed() <= maxShutterSpeed);

   926 

   927     camera.setManualShutterSpeed(0);

   928     QCOMPARE(camera.shutterSpeed(), minShutterSpeed);

   929 

   930     camera.setManualShutterSpeed(10000);

   931     QCOMPARE(camera.shutterSpeed(), maxShutterSpeed);

   932 

   933     QCOMPARE(camera.isExposureLocked(), false);

   934 

   935     camera.lockExposure();

   936     QCOMPARE(camera.isExposureLocked(), true);

   937 

   938     camera.unlockExposure();

   939     QCOMPARE(camera.isExposureLocked(), false);

   940 }

   941 

   942 void tst_QCamera::testCameraFocus()

   943 {

   944     MockCameraService service;

   945     provider->service = &service;

   946     QCamera camera(0, provider);

   947 

   948     QCOMPARE(camera.supportedFocusModes(), QCamera::AutoFocus | QCamera::ContinuousFocus);

   949     QCOMPARE(camera.focusMode(), QCamera::AutoFocus);

   950     camera.setFocusMode(QCamera::ManualFocus);

   951     QCOMPARE(camera.focusMode(), QCamera::AutoFocus);

   952     camera.setFocusMode(QCamera::ContinuousFocus);

   953     QCOMPARE(camera.focusMode(), QCamera::ContinuousFocus);

   954     QCOMPARE(camera.focusStatus(), QCamera::FocusInitial);

   955 

   956     QVERIFY(camera.isMacroFocusingSupported());

   957     QVERIFY(!camera.macroFocusingEnabled());

   958     camera.setMacroFocusingEnabled(true);

   959     QVERIFY(camera.macroFocusingEnabled());

   960 

   961     QVERIFY(camera.maximumOpticalZoom() >= 1.0);

   962     QVERIFY(camera.maximumDigitalZoom() >= 1.0);

   963     QCOMPARE(camera.opticalZoom(), 1.0);

   964     QCOMPARE(camera.digitalZoom(), 1.0);

   965     camera.zoomTo(0.5, 1.0);

   966     QCOMPARE(camera.opticalZoom(), 1.0);

   967     QCOMPARE(camera.digitalZoom(), 1.0);

   968     camera.zoomTo(2.0, 0.5);

   969     QCOMPARE(camera.opticalZoom(), 2.0);

   970     QCOMPARE(camera.digitalZoom(), 1.0);

   971     camera.zoomTo(2.0, 2.5);

   972     QCOMPARE(camera.opticalZoom(), 2.0);

   973     QCOMPARE(camera.digitalZoom(), 2.5);

   974     camera.zoomTo(2000000.0, 1000000.0);

   975     QVERIFY(qFuzzyCompare(camera.opticalZoom(), camera.maximumOpticalZoom()));

   976     QVERIFY(qFuzzyCompare(camera.digitalZoom(), camera.maximumDigitalZoom()));

   977 }

   978 

   979 void tst_QCamera::testImageSettings()

   980 {

   981     QImageEncoderSettings settings;

   982     QVERIFY(settings.isNull());

   983     QVERIFY(settings == QImageEncoderSettings());

   984 

   985     QCOMPARE(settings.codec(), QString());

   986     settings.setCodec(QLatin1String("codecName"));

   987     QCOMPARE(settings.codec(), QLatin1String("codecName"));

   988     QVERIFY(!settings.isNull());

   989     QVERIFY(settings != QImageEncoderSettings());

   990 

   991     settings = QImageEncoderSettings();

   992     QCOMPARE(settings.quality(), QtMedia::NormalQuality);

   993     settings.setQuality(QtMedia::HighQuality);

   994     QCOMPARE(settings.quality(), QtMedia::HighQuality);

   995     QVERIFY(!settings.isNull());

   996 

   997     settings = QImageEncoderSettings();

   998     QCOMPARE(settings.resolution(), QSize());

   999     settings.setResolution(QSize(320,240));

  1000     QCOMPARE(settings.resolution(), QSize(320,240));

  1001     settings.setResolution(800,600);

  1002     QCOMPARE(settings.resolution(), QSize(800,600));

  1003     QVERIFY(!settings.isNull());

  1004 

  1005     settings = QImageEncoderSettings();

  1006     QVERIFY(settings.isNull());

  1007     QCOMPARE(settings.codec(), QString());

  1008     QCOMPARE(settings.quality(), QtMedia::NormalQuality);

  1009     QCOMPARE(settings.resolution(), QSize());

  1010 

  1011     {

  1012         QImageEncoderSettings settings1;

  1013         QImageEncoderSettings settings2;

  1014         QCOMPARE(settings2, settings1);

  1015 

  1016         settings2 = settings1;

  1017         QCOMPARE(settings2, settings1);

  1018         QVERIFY(settings2.isNull());

  1019 

  1020         settings1.setQuality(QtMedia::HighQuality);

  1021 

  1022         QVERIFY(settings2.isNull());

  1023         QVERIFY(!settings1.isNull());

  1024         QVERIFY(settings1 != settings2);

  1025     }

  1026 

  1027     {

  1028         QImageEncoderSettings settings1;

  1029         QImageEncoderSettings settings2(settings1);

  1030         QCOMPARE(settings2, settings1);

  1031 

  1032         settings2 = settings1;

  1033         QCOMPARE(settings2, settings1);

  1034         QVERIFY(settings2.isNull());

  1035 

  1036         settings1.setQuality(QtMedia::HighQuality);

  1037 

  1038         QVERIFY(settings2.isNull());

  1039         QVERIFY(!settings1.isNull());

  1040         QVERIFY(settings1 != settings2);

  1041     }

  1042 

  1043     QImageEncoderSettings settings1;

  1044     QImageEncoderSettings settings2;

  1045 

  1046     settings1 = QImageEncoderSettings();

  1047     settings1.setResolution(800,600);

  1048     settings2 = QImageEncoderSettings();

  1049     settings2.setResolution(QSize(800,600));

  1050     QVERIFY(settings1 == settings2);

  1051     settings2.setResolution(QSize(400,300));

  1052     QVERIFY(settings1 != settings2);

  1053 

  1054     settings1 = QImageEncoderSettings();

  1055     settings1.setCodec("codec1");

  1056     settings2 = QImageEncoderSettings();

  1057     settings2.setCodec("codec1");

  1058     QVERIFY(settings1 == settings2);

  1059     settings2.setCodec("codec2");

  1060     QVERIFY(settings1 != settings2);

  1061 

  1062     settings1 = QImageEncoderSettings();

  1063     settings1.setQuality(QtMedia::NormalQuality);

  1064     settings2 = QImageEncoderSettings();

  1065     settings2.setQuality(QtMedia::NormalQuality);

  1066     QVERIFY(settings1 == settings2);

  1067     settings2.setQuality(QtMedia::LowQuality);

  1068     QVERIFY(settings1 != settings2);

  1069 }

  1070 

  1071 

  1072 

  1073 QTEST_MAIN(tst_QCamera)

  1074 

  1075 #include "tst_qcamera.moc"