Remove camera locking API

QCamera::lock()/unlock() is something that's not needed
these days anymore. cameras will automatically focus anyway,
there's no real reason to lock the focus (or other properties)
to some specific value in 99% of the cases.

Plus it wasn't supported on Linux or macOS/iOS anyway.

Change-Id: I437d29cbb768da3ece42eea8d753eeafa0c534ae
Reviewed-by: Doris Verria <doris.verria@qt.io>
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

11 files changed, 1 insertions, 747 deletions

diff --git a/src/multimedia/platform/android/mediacapture/qandroidcameracontrol.cpp b/src/multimedia/platform/android/mediacapture/qandroidcameracontrol.cpp
index 700ce2928..d1160d274 100644
--- a/src/multimedia/platform/android/mediacapture/qandroidcameracontrol.cpp
+++ b/src/multimedia/platform/android/mediacapture/qandroidcameracontrol.cpp
@@ -64,8 +64,6 @@ QAndroidCameraControl::QAndroidCameraControl(QAndroidCameraSession *session)
     connect(m_cameraSession, SIGNAL(captureModeChanged(QCamera::CaptureModes)),
             this, SIGNAL(captureModeChanged(QCamera::CaptureModes)));
 
-    connect(m_cameraSession, SIGNAL(opened()), this, SLOT(onCameraOpened()));
-
     m_recalculateTimer = new QTimer(this);
     m_recalculateTimer->setInterval(1000);
     m_recalculateTimer->setSingleShot(true);
@@ -135,109 +133,6 @@ bool QAndroidCameraControl::canChangeProperty(PropertyChangeType changeType, QCa
     }
 }
 
-
-QCamera::LockTypes QAndroidCameraControl::supportedLocks() const
-{
-    return m_supportedLocks;
-}
-
-QCamera::LockStatus QAndroidCameraControl::lockStatus(QCamera::LockType lock) const
-{
-    if (!m_supportedLocks.testFlag(lock) || !m_cameraSession->camera())
-        return QCamera::Unlocked;
-
-    if (lock == QCamera::LockFocus)
-        return m_focusLockStatus;
-
-    if (lock == QCamera::LockExposure)
-        return m_exposureLockStatus;
-
-    if (lock == QCamera::LockWhiteBalance)
-        return m_whiteBalanceLockStatus;
-
-    return QCamera::Unlocked;
-}
-
-void QAndroidCameraControl::searchAndLock(QCamera::LockTypes locks)
-{
-    if (!m_cameraSession->camera())
-        return;
-
-    // filter out unsupported locks
-    locks &= m_supportedLocks;
-
-    if (locks.testFlag(QCamera::LockFocus)) {
-        QString focusMode = m_cameraSession->camera()->getFocusMode();
-        if (focusMode == QLatin1String("auto")
-                || focusMode == QLatin1String("macro")
-                || focusMode == QLatin1String("continuous-picture")
-                || focusMode == QLatin1String("continuous-video")) {
-
-            if (m_focusLockStatus == QCamera::Searching)
-                m_cameraSession->camera()->cancelAutoFocus();
-            else
-                setFocusLockStatus(QCamera::Searching, QCamera::UserRequest);
-
-            m_cameraSession->camera()->autoFocus();
-
-        } else {
-            setFocusLockStatus(QCamera::Locked, QCamera::LockAcquired);
-        }
-    }
-
-    if (locks.testFlag(QCamera::LockExposure) && m_exposureLockStatus != QCamera::Searching) {
-        if (m_cameraSession->camera()->getAutoExposureLock()) {
-            // if already locked, unlock and give some time to recalculate exposure
-            m_cameraSession->camera()->setAutoExposureLock(false);
-            setExposureLockStatus(QCamera::Searching, QCamera::UserRequest);
-        } else {
-            m_cameraSession->camera()->setAutoExposureLock(true);
-            setExposureLockStatus(QCamera::Locked, QCamera::LockAcquired);
-        }
-    }
-
-    if (locks.testFlag(QCamera::LockWhiteBalance) && m_whiteBalanceLockStatus != QCamera::Searching) {
-        if (m_cameraSession->camera()->getAutoWhiteBalanceLock()) {
-            // if already locked, unlock and give some time to recalculate white balance
-            m_cameraSession->camera()->setAutoWhiteBalanceLock(false);
-            setWhiteBalanceLockStatus(QCamera::Searching, QCamera::UserRequest);
-        } else {
-            m_cameraSession->camera()->setAutoWhiteBalanceLock(true);
-            setWhiteBalanceLockStatus(QCamera::Locked, QCamera::LockAcquired);
-        }
-    }
-
-    if (m_exposureLockStatus == QCamera::Searching || m_whiteBalanceLockStatus == QCamera::Searching)
-        m_recalculateTimer->start();
-}
-
-void QAndroidCameraControl::unlock(QCamera::LockTypes locks)
-{
-    if (!m_cameraSession->camera())
-        return;
-
-    if (m_recalculateTimer->isActive())
-        m_recalculateTimer->stop();
-
-    // filter out unsupported locks
-    locks &= m_supportedLocks;
-
-    if (locks.testFlag(QCamera::LockFocus)) {
-        m_cameraSession->camera()->cancelAutoFocus();
-        setFocusLockStatus(QCamera::Unlocked, QCamera::UserRequest);
-    }
-
-    if (locks.testFlag(QCamera::LockExposure)) {
-        m_cameraSession->camera()->setAutoExposureLock(false);
-        setExposureLockStatus(QCamera::Unlocked, QCamera::UserRequest);
-    }
-
-    if (locks.testFlag(QCamera::LockWhiteBalance)) {
-        m_cameraSession->camera()->setAutoWhiteBalanceLock(false);
-        setWhiteBalanceLockStatus(QCamera::Unlocked, QCamera::UserRequest);
-    }
-}
-
 QCameraFocusControl *QAndroidCameraControl::focusControl()
 {
     return m_cameraSession->focusControl();
@@ -253,89 +148,4 @@ QCameraImageProcessingControl *QAndroidCameraControl::imageProcessingControl()
     return m_cameraSession->imageProcessingControl();
 }
 
-void QAndroidCameraControl::onCameraOpened()
-{
-    m_supportedLocks = QCamera::NoLock;
-    m_focusLockStatus = QCamera::Unlocked;
-    m_exposureLockStatus = QCamera::Unlocked;
-    m_whiteBalanceLockStatus = QCamera::Unlocked;
-
-    // check if focus lock is supported
-    QStringList focusModes = m_cameraSession->camera()->getSupportedFocusModes();
-    for (int i = 0; i < focusModes.size(); ++i) {
-        const QString &focusMode = focusModes.at(i);
-        if (focusMode == QLatin1String("auto")
-                || focusMode == QLatin1String("continuous-picture")
-                || focusMode == QLatin1String("continuous-video")
-                || focusMode == QLatin1String("macro")) {
-
-            m_supportedLocks |= QCamera::LockFocus;
-            setFocusLockStatus(QCamera::Unlocked, QCamera::UserRequest);
-
-            connect(m_cameraSession->camera(), SIGNAL(autoFocusComplete(bool)),
-                    this, SLOT(onCameraAutoFocusComplete(bool)));
-
-            break;
-        }
-    }
-
-    if (m_cameraSession->camera()->isAutoExposureLockSupported()) {
-        m_supportedLocks |= QCamera::LockExposure;
-        setExposureLockStatus(QCamera::Unlocked, QCamera::UserRequest);
-    }
-
-    if (m_cameraSession->camera()->isAutoWhiteBalanceLockSupported()) {
-        m_supportedLocks |= QCamera::LockWhiteBalance;
-        setWhiteBalanceLockStatus(QCamera::Unlocked, QCamera::UserRequest);
-
-        connect(m_cameraSession->camera(), SIGNAL(whiteBalanceChanged()),
-                this, SLOT(onWhiteBalanceChanged()));
-    }
-}
-
-void QAndroidCameraControl::onCameraAutoFocusComplete(bool success)
-{
-    m_focusLockStatus = success ? QCamera::Locked : QCamera::Unlocked;
-    QCamera::LockChangeReason reason = success ? QCamera::LockAcquired : QCamera::LockFailed;
-    emit lockStatusChanged(QCamera::LockFocus, m_focusLockStatus, reason);
-}
-
-void QAndroidCameraControl::onRecalculateTimeOut()
-{
-    if (m_exposureLockStatus == QCamera::Searching) {
-        m_cameraSession->camera()->setAutoExposureLock(true);
-        setExposureLockStatus(QCamera::Locked, QCamera::LockAcquired);
-    }
-
-    if (m_whiteBalanceLockStatus == QCamera::Searching) {
-        m_cameraSession->camera()->setAutoWhiteBalanceLock(true);
-        setWhiteBalanceLockStatus(QCamera::Locked, QCamera::LockAcquired);
-    }
-}
-
-void QAndroidCameraControl::onWhiteBalanceChanged()
-{
-    // changing the white balance mode releases the white balance lock
-    if (m_whiteBalanceLockStatus != QCamera::Unlocked)
-        setWhiteBalanceLockStatus(QCamera::Unlocked, QCamera::LockLost);
-}
-
-void QAndroidCameraControl::setFocusLockStatus(QCamera::LockStatus status, QCamera::LockChangeReason reason)
-{
-    m_focusLockStatus = status;
-    emit lockStatusChanged(QCamera::LockFocus, m_focusLockStatus, reason);
-}
-
-void QAndroidCameraControl::setWhiteBalanceLockStatus(QCamera::LockStatus status, QCamera::LockChangeReason reason)
-{
-    m_whiteBalanceLockStatus = status;
-    emit lockStatusChanged(QCamera::LockWhiteBalance, m_whiteBalanceLockStatus, reason);
-}
-
-void QAndroidCameraControl::setExposureLockStatus(QCamera::LockStatus status, QCamera::LockChangeReason reason)
-{
-    m_exposureLockStatus = status;
-    emit lockStatusChanged(QCamera::LockExposure, m_exposureLockStatus, reason);
-}
-
 QT_END_NAMESPACE
diff --git a/src/multimedia/platform/android/mediacapture/qandroidcameracontrol_p.h b/src/multimedia/platform/android/mediacapture/qandroidcameracontrol_p.h
index d313db9fd..02b197616 100644
--- a/src/multimedia/platform/android/mediacapture/qandroidcameracontrol_p.h
+++ b/src/multimedia/platform/android/mediacapture/qandroidcameracontrol_p.h
@@ -78,35 +78,14 @@ public:
 
     bool canChangeProperty(PropertyChangeType changeType, QCamera::Status status) const override;
 
-    QCamera::LockTypes supportedLocks() const override;
-    QCamera::LockStatus lockStatus(QCamera::LockType lock) const override;
-    void searchAndLock(QCamera::LockTypes locks) override;
-    void unlock(QCamera::LockTypes locks) override;
-
     QCameraFocusControl *focusControl() override;
     QCameraExposureControl *exposureControl() override;
     QCameraImageProcessingControl *imageProcessingControl() override;
 
-private Q_SLOTS:
-    void onCameraOpened();
-    void onCameraAutoFocusComplete(bool success);
-    void onRecalculateTimeOut();
-    void onWhiteBalanceChanged();
-
 private:
-    void setFocusLockStatus(QCamera::LockStatus status, QCamera::LockChangeReason reason);
-    void setWhiteBalanceLockStatus(QCamera::LockStatus status, QCamera::LockChangeReason reason);
-    void setExposureLockStatus(QCamera::LockStatus status, QCamera::LockChangeReason reason);
-
     QAndroidCameraSession *m_cameraSession;
 
     QTimer *m_recalculateTimer;
-
-    QCamera::LockTypes m_supportedLocks;
-
-    QCamera::LockStatus m_focusLockStatus;
-    QCamera::LockStatus m_exposureLockStatus;
-    QCamera::LockStatus m_whiteBalanceLockStatus;
 };
 
 QT_END_NAMESPACE
diff --git a/src/multimedia/platform/darwin/camera/avfcameracontrol.mm b/src/multimedia/platform/darwin/camera/avfcameracontrol.mm
index ae492257e..77f394221 100644
--- a/src/multimedia/platform/darwin/camera/avfcameracontrol.mm
+++ b/src/multimedia/platform/darwin/camera/avfcameracontrol.mm
@@ -136,26 +136,6 @@ bool AVFCameraControl::canChangeProperty(QCameraControl::PropertyChangeType chan
     return true;
 }
 
-QCamera::LockTypes AVFCameraControl::supportedLocks() const
-{
-    return {};
-}
-
-QCamera::LockStatus AVFCameraControl::lockStatus(QCamera::LockType) const
-{
-    return QCamera::Unlocked;
-}
-
-void AVFCameraControl::searchAndLock(QCamera::LockTypes locks)
-{
-    Q_UNUSED(locks);
-}
-
-void AVFCameraControl::unlock(QCamera::LockTypes locks)
-{
-    Q_UNUSED(locks);
-}
-
 QVideoFrame::PixelFormat AVFCameraControl::QtPixelFormatFromCVFormat(unsigned avPixelFormat)
 {
     // BGRA <-> ARGB "swap" is intentional:
diff --git a/src/multimedia/platform/darwin/camera/avfcameracontrol_p.h b/src/multimedia/platform/darwin/camera/avfcameracontrol_p.h
index d0a7bba01..8c78a367c 100644
--- a/src/multimedia/platform/darwin/camera/avfcameracontrol_p.h
+++ b/src/multimedia/platform/darwin/camera/avfcameracontrol_p.h
@@ -82,13 +82,6 @@ public:
 
     bool canChangeProperty(PropertyChangeType changeType, QCamera::Status status) const override;
 
-    QCamera::LockTypes supportedLocks() const override;
-
-    QCamera::LockStatus lockStatus(QCamera::LockType lock) const override;
-
-    void searchAndLock(QCamera::LockTypes locks) override;
-    void unlock(QCamera::LockTypes locks) override;
-
     QCameraFocusControl *focusControl() override;
     QCameraExposureControl *exposureControl() override;
     QCameraImageProcessingControl *imageProcessingControl() override;
diff --git a/src/multimedia/platform/gstreamer/camerabin/camerabincontrol.cpp b/src/multimedia/platform/gstreamer/camerabin/camerabincontrol.cpp
index d303142ac..0b7b014f5 100644
--- a/src/multimedia/platform/gstreamer/camerabin/camerabincontrol.cpp
+++ b/src/multimedia/platform/gstreamer/camerabin/camerabincontrol.cpp
@@ -239,182 +239,4 @@ void CameraBinControl::setViewfinderColorSpaceConversion(bool enabled)
     g_object_set(G_OBJECT(m_session->cameraBin()), "flags", flags, NULL);
 }
 
-QCamera::LockTypes CameraBinControl::supportedLocks() const
-{
-    QCamera::LockTypes locks = QCamera::LockFocus;
-
-    if (GstPhotography *photography = m_session->photography()) {
-        if (gst_photography_get_capabilities(photography) & GST_PHOTOGRAPHY_CAPS_WB_MODE)
-            locks |= QCamera::LockWhiteBalance;
-
-    if (GstElement *source = m_session->cameraSource()) {
-            if (g_object_class_find_property(
-                        G_OBJECT_GET_CLASS(source), "exposure-mode")) {
-                locks |= QCamera::LockExposure;
-            }
-        }
-    }
-
-    return locks;
-}
-
-QCamera::LockStatus CameraBinControl::lockStatus(QCamera::LockType lock) const
-{
-    switch (lock) {
-    case QCamera::LockFocus:
-        return m_focus->focusStatus();
-    case QCamera::LockExposure:
-        if (m_pendingLocks & QCamera::LockExposure)
-            return QCamera::Searching;
-        return isExposureLocked() ? QCamera::Locked : QCamera::Unlocked;
-    case QCamera::LockWhiteBalance:
-        if (m_pendingLocks & QCamera::LockWhiteBalance)
-            return QCamera::Searching;
-        return isWhiteBalanceLocked() ? QCamera::Locked : QCamera::Unlocked;
-    default:
-        return QCamera::Unlocked;
-    }
-}
-
-void CameraBinControl::searchAndLock(QCamera::LockTypes locks)
-{
-    m_pendingLocks &= ~locks;
-
-    if (locks & QCamera::LockFocus) {
-        m_pendingLocks |= QCamera::LockFocus;
-        m_focus->_q_startFocusing();
-    }
-    if (!m_pendingLocks)
-        m_lockTimer.stop();
-
-    if (locks & QCamera::LockExposure) {
-        if (isExposureLocked()) {
-            unlockExposure(QCamera::Searching, QCamera::UserRequest);
-            m_pendingLocks |= QCamera::LockExposure;
-            m_lockTimer.start(1000, this);
-        } else {
-            lockExposure(QCamera::UserRequest);
-        }
-    }
-    if (locks & QCamera::LockWhiteBalance) {
-        if (isWhiteBalanceLocked()) {
-            unlockWhiteBalance(QCamera::Searching, QCamera::UserRequest);
-            m_pendingLocks |= QCamera::LockWhiteBalance;
-            m_lockTimer.start(1000, this);
-        } else {
-            lockWhiteBalance(QCamera::UserRequest);
-        }
-    }
-}
-
-void CameraBinControl::unlock(QCamera::LockTypes locks)
-{
-    m_pendingLocks &= ~locks;
-
-    if (locks & QCamera::LockFocus)
-        m_focus->_q_stopFocusing();
-
-    if (!m_pendingLocks)
-        m_lockTimer.stop();
-
-    if (locks & QCamera::LockExposure)
-        unlockExposure(QCamera::Unlocked, QCamera::UserRequest);
-    if (locks & QCamera::LockWhiteBalance)
-        unlockWhiteBalance(QCamera::Unlocked, QCamera::UserRequest);
-}
-
-void CameraBinControl::updateFocusStatus(QCamera::LockStatus status, QCamera::LockChangeReason reason)
-{
-    if (status != QCamera::Searching)
-        m_pendingLocks &= ~QCamera::LockFocus;
-
-    if (status == QCamera::Locked && !m_lockTimer.isActive()) {
-        if (m_pendingLocks & QCamera::LockExposure)
-            lockExposure(QCamera::LockAcquired);
-        if (m_pendingLocks & QCamera::LockWhiteBalance)
-            lockWhiteBalance(QCamera::LockAcquired);
-    }
-    emit lockStatusChanged(QCamera::LockFocus, status, reason);
-}
-
-void CameraBinControl::timerEvent(QTimerEvent *event)
-{
-    if (event->timerId() != m_lockTimer.timerId())
-        return QCameraControl::timerEvent(event);
-
-    m_lockTimer.stop();
-
-    if (!(m_pendingLocks & QCamera::LockFocus)) {
-        if (m_pendingLocks & QCamera::LockExposure)
-            lockExposure(QCamera::LockAcquired);
-        if (m_pendingLocks & QCamera::LockWhiteBalance)
-            lockWhiteBalance(QCamera::LockAcquired);
-    }
-}
-
-bool CameraBinControl::isExposureLocked() const
-{
-    if (GstElement *source = m_session->cameraSource()) {
-        GstPhotographyExposureMode exposureMode = GST_PHOTOGRAPHY_EXPOSURE_MODE_AUTO;
-        g_object_get (G_OBJECT(source), "exposure-mode", &exposureMode, NULL);
-        return exposureMode == GST_PHOTOGRAPHY_EXPOSURE_MODE_MANUAL;
-    }
-
-    return false;
-}
-
-void CameraBinControl::lockExposure(QCamera::LockChangeReason reason)
-{
-    GstElement *source = m_session->cameraSource();
-    if (!source)
-        return;
-
-    m_pendingLocks &= ~QCamera::LockExposure;
-    g_object_set(
-                G_OBJECT(source),
-                "exposure-mode",
-                GST_PHOTOGRAPHY_EXPOSURE_MODE_MANUAL,
-                NULL);
-    emit lockStatusChanged(QCamera::LockExposure, QCamera::Locked, reason);
-}
-
-void CameraBinControl::unlockExposure(QCamera::LockStatus status, QCamera::LockChangeReason reason)
-{
-    GstElement *source = m_session->cameraSource();
-    if (!source)
-        return;
-
-    g_object_set(
-                G_OBJECT(source),
-                "exposure-mode",
-                GST_PHOTOGRAPHY_EXPOSURE_MODE_AUTO,
-                NULL);
-    emit lockStatusChanged(QCamera::LockExposure, status, reason);
-}
-
-bool CameraBinControl::isWhiteBalanceLocked() const
-{
-    if (GstPhotography *photography = m_session->photography()) {
-        GstPhotographyWhiteBalanceMode whiteBalanceMode;
-        return gst_photography_get_white_balance_mode(photography, &whiteBalanceMode)
-                && whiteBalanceMode == GST_PHOTOGRAPHY_WB_MODE_MANUAL;
-    }
-
-    return false;
-}
-
-void CameraBinControl::lockWhiteBalance(QCamera::LockChangeReason reason)
-{
-    m_pendingLocks &= ~QCamera::LockWhiteBalance;
-    m_session->imageProcessingControl()->lockWhiteBalance();
-    emit lockStatusChanged(QCamera::LockWhiteBalance, QCamera::Locked, reason);
-}
-
-void CameraBinControl::unlockWhiteBalance(
-        QCamera::LockStatus status, QCamera::LockChangeReason reason)
-{
-    m_session->imageProcessingControl()->lockWhiteBalance();
-    emit lockStatusChanged(QCamera::LockWhiteBalance, status, reason);
-}
-
 QT_END_NAMESPACE
diff --git a/src/multimedia/platform/gstreamer/camerabin/camerabincontrol_p.h b/src/multimedia/platform/gstreamer/camerabin/camerabincontrol_p.h
index 46f0a2934..0ea4ee73e 100644
--- a/src/multimedia/platform/gstreamer/camerabin/camerabincontrol_p.h
+++ b/src/multimedia/platform/gstreamer/camerabin/camerabincontrol_p.h
@@ -83,13 +83,6 @@ public:
     bool canChangeProperty(PropertyChangeType changeType, QCamera::Status status) const override;
     bool viewfinderColorSpaceConversion() const;
 
-    QCamera::LockTypes supportedLocks() const override;
-
-    QCamera::LockStatus lockStatus(QCamera::LockType lock) const override;
-
-    void searchAndLock(QCamera::LockTypes locks) override;
-    void unlock(QCamera::LockTypes locks) override;
-
 public slots:
     void reloadLater();
     void setViewfinderColorSpaceConversion(bool enabled);
@@ -106,26 +99,12 @@ private:
 protected:
     void timerEvent(QTimerEvent *event) override;
 
-private slots:
-    void updateFocusStatus(QCamera::LockStatus status, QCamera::LockChangeReason reason);
-
-private:
-    bool isExposureLocked() const;
-    void lockExposure(QCamera::LockChangeReason reason);
-    void unlockExposure(QCamera::LockStatus status, QCamera::LockChangeReason reason);
-
-    bool isWhiteBalanceLocked() const;
-    void lockWhiteBalance(QCamera::LockChangeReason reason);
-    void unlockWhiteBalance(QCamera::LockStatus status, QCamera::LockChangeReason reason);
-
     CameraBinSession *m_session;
     QCamera::State m_state;
 
     bool m_reloadPending;
 
     CameraBinFocus *m_focus;
-    QBasicTimer m_lockTimer;
-    QCamera::LockTypes m_pendingLocks;
 };
 
 QT_END_NAMESPACE
diff --git a/src/multimedia/platform/gstreamer/camerabin/camerabinfocus.cpp b/src/multimedia/platform/gstreamer/camerabin/camerabinfocus.cpp
index f795b0f2f..235bde6b5 100644
--- a/src/multimedia/platform/gstreamer/camerabin/camerabinfocus.cpp
+++ b/src/multimedia/platform/gstreamer/camerabin/camerabinfocus.cpp
@@ -248,72 +248,6 @@ QCameraFocusZoneList CameraBinFocus::focusZones() const
     return zones;
 }
 
-void CameraBinFocus::handleFocusMessage(GstMessage *gm)
-{
-    //it's a sync message, so it's called from non main thread
-    const GstStructure *structure = gst_message_get_structure(gm);
-    if (gst_structure_has_name(structure, GST_PHOTOGRAPHY_AUTOFOCUS_DONE)) {
-        gint status = GST_PHOTOGRAPHY_FOCUS_STATUS_NONE;
-        gst_structure_get_int (structure, "status", &status);
-        QCamera::LockStatus focusStatus = m_focusStatus;
-        QCamera::LockChangeReason reason = QCamera::UserRequest;
-
-        switch (status) {
-            case GST_PHOTOGRAPHY_FOCUS_STATUS_FAIL:
-                focusStatus = QCamera::Unlocked;
-                reason = QCamera::LockFailed;
-                break;
-            case GST_PHOTOGRAPHY_FOCUS_STATUS_SUCCESS:
-                focusStatus = QCamera::Locked;
-                break;
-            case GST_PHOTOGRAPHY_FOCUS_STATUS_NONE:
-                break;
-            case GST_PHOTOGRAPHY_FOCUS_STATUS_RUNNING:
-                focusStatus = QCamera::Searching;
-                break;
-            default:
-                break;
-        }
-
-        static int signalIndex = metaObject()->indexOfSlot(
-                    "_q_setFocusStatus(QCamera::LockStatus,QCamera::LockChangeReason)");
-        metaObject()->method(signalIndex).invoke(this,
-                                                 Qt::QueuedConnection,
-                                                 Q_ARG(QCamera::LockStatus,focusStatus),
-                                                 Q_ARG(QCamera::LockChangeReason,reason));
-    }
-}
-
-void CameraBinFocus::_q_setFocusStatus(QCamera::LockStatus status, QCamera::LockChangeReason reason)
-{
-#ifdef CAMERABIN_DEBUG
-    qDebug() << Q_FUNC_INFO << "Current:"
-                << m_focusStatus
-                << "New:"
-                << status << reason;
-#endif
-
-    if (m_focusStatus != status) {
-        m_focusStatus = status;
-
-        QCameraFocusZone::FocusZoneStatus zonesStatus =
-                m_focusStatus == QCamera::Locked ?
-                    QCameraFocusZone::Focused : QCameraFocusZone::Selected;
-
-        if (m_focusZoneStatus != zonesStatus) {
-            m_focusZoneStatus = zonesStatus;
-            emit focusZonesChanged();
-        }
-
-        if (m_focusPointMode == QCameraFocus::FocusPointFaceDetection
-                && m_focusStatus == QCamera::Unlocked) {
-            _q_updateFaces();
-        }
-
-        emit _q_focusStatusChanged(m_focusStatus, reason);
-    }
-}
-
 void CameraBinFocus::_q_handleCameraStatusChange(QCamera::Status status)
 {
     m_cameraStatus = status;
@@ -341,18 +275,6 @@ void CameraBinFocus::_q_handleCameraStatusChange(QCamera::Status status)
     }
 }
 
-void CameraBinFocus::_q_startFocusing()
-{
-    _q_setFocusStatus(QCamera::Searching, QCamera::UserRequest);
-    gst_photography_set_autofocus(m_session->photography(), TRUE);
-}
-
-void CameraBinFocus::_q_stopFocusing()
-{
-    gst_photography_set_autofocus(m_session->photography(), FALSE);
-    _q_setFocusStatus(QCamera::Unlocked, QCamera::UserRequest);
-}
-
 void CameraBinFocus::setViewfinderResolution(const QSize &resolution)
 {
     if (resolution != m_viewfinderResolution) {
@@ -455,10 +377,8 @@ void CameraBinFocus::updateRegionOfInterest(const QList<QRect> &rectangles)
 
 void CameraBinFocus::_q_updateFaces()
 {
-    if (m_focusPointMode != QCameraFocus::FocusPointFaceDetection
-            || m_focusStatus != QCamera::Unlocked) {
+    if (m_focusPointMode != QCameraFocus::FocusPointFaceDetection)
         return;
-    }
 
     QList<QRect> faces;
 
diff --git a/src/multimedia/platform/gstreamer/camerabin/camerabinfocus_p.h b/src/multimedia/platform/gstreamer/camerabin/camerabinfocus_p.h
index 4ffef7a3a..4f18adbca 100644
--- a/src/multimedia/platform/gstreamer/camerabin/camerabinfocus_p.h
+++ b/src/multimedia/platform/gstreamer/camerabin/camerabinfocus_p.h
@@ -100,23 +100,12 @@ public:
 
     void zoomTo(qreal optical, qreal digital) override;
 
-    void handleFocusMessage(GstMessage*);
-    QCamera::LockStatus focusStatus() const { return m_focusStatus; }
-
-Q_SIGNALS:
-    void _q_focusStatusChanged(QCamera::LockStatus status, QCamera::LockChangeReason reason);
-
-public Q_SLOTS:
-    void _q_startFocusing();
-    void _q_stopFocusing();
-
     void setViewfinderResolution(const QSize &resolution);
 
 protected:
     void timerEvent(QTimerEvent *event) override;
 
 private Q_SLOTS:
-    void _q_setFocusStatus(QCamera::LockStatus status, QCamera::LockChangeReason reason);
     void _q_handleCameraStatusChange(QCamera::Status status);
     void _q_updateFaces();
 
@@ -130,7 +119,6 @@ private:
     QCamera::Status m_cameraStatus;
     QCameraFocus::FocusModes m_focusMode;
     QCameraFocus::FocusPointMode m_focusPointMode;
-    QCamera::LockStatus m_focusStatus;
     QCameraFocusZone::FocusZoneStatus m_focusZoneStatus;
     QPointF m_focusPoint;
     QRectF m_focusRect;
diff --git a/src/multimedia/platform/gstreamer/mediacapture/qgstreamercameracontrol_p.h b/src/multimedia/platform/gstreamer/mediacapture/qgstreamercameracontrol_p.h
index 618439b4c..6a41aabc4 100644
--- a/src/multimedia/platform/gstreamer/mediacapture/qgstreamercameracontrol_p.h
+++ b/src/multimedia/platform/gstreamer/mediacapture/qgstreamercameracontrol_p.h
@@ -81,16 +81,6 @@ public:
 
     bool canChangeProperty(PropertyChangeType changeType, QCamera::Status status) const override;
 
-    QCamera::LockTypes supportedLocks() const override
-    {
-        return QCamera::NoLock;
-    }
-
-    QCamera::LockStatus lockStatus(QCamera::LockType /*lock*/) const override { return QCamera::Unlocked; }
-
-    void searchAndLock(QCamera::LockTypes /*locks*/) override {}
-    void unlock(QCamera::LockTypes /*locks*/) override {}
-
 public slots:
     void reloadLater();
 
diff --git a/src/multimedia/platform/qnx/camera/bbcameracontrol.cpp b/src/multimedia/platform/qnx/camera/bbcameracontrol.cpp
index 423a5b8ac..bafa14c0c 100644
--- a/src/multimedia/platform/qnx/camera/bbcameracontrol.cpp
+++ b/src/multimedia/platform/qnx/camera/bbcameracontrol.cpp
@@ -53,7 +53,6 @@ BbCameraControl::BbCameraControl(BbCameraSession *session, QObject *parent)
     connect(m_session, SIGNAL(captureModeChanged(QCamera::CaptureModes)), this, SIGNAL(captureModeChanged(QCamera::CaptureModes)));
 
     connect(m_session, SIGNAL(cameraOpened()), SLOT(cameraOpened()));
-    connect(m_session, SIGNAL(focusStatusChanged(int)), SLOT(focusStatusChanged(int)));
 }
 
 QCamera::State BbCameraControl::state() const
@@ -96,201 +95,8 @@ bool BbCameraControl::canChangeProperty(PropertyChangeType /* changeType */, QCa
     return false;
 }
 
-QCamera::LockTypes BbCameraControl::supportedLocks() const
-{
-    return (QCamera::LockFocus | QCamera::LockExposure | QCamera::LockWhiteBalance);
-}
-
-QCamera::LockStatus BbCameraControl::lockStatus(QCamera::LockType lock) const
-{
-    if (!m_supportedLockTypes.testFlag(lock) || (m_session->handle() == CAMERA_HANDLE_INVALID))
-        return QCamera::Locked;
-
-    switch (lock) {
-    case QCamera::LockExposure:
-        return m_exposureLockStatus;
-    case QCamera::LockWhiteBalance:
-        return m_whiteBalanceLockStatus;
-    case QCamera::LockFocus:
-        return m_focusLockStatus;
-    default:
-        return QCamera::Locked;
-    }
-}
-
-void BbCameraControl::searchAndLock(QCamera::LockTypes locks)
-{
-    if (m_session->handle() == CAMERA_HANDLE_INVALID)
-        return;
-
-    // filter out unsupported locks
-    locks &= m_supportedLockTypes;
-
-    m_currentLockTypes |= locks;
-
-    uint32_t lockModes = CAMERA_3A_NONE;
-
-    switch (m_locksApplyMode) {
-    case IndependentMode:
-        if (m_currentLockTypes & QCamera::LockExposure)
-            lockModes |= CAMERA_3A_AUTOEXPOSURE;
-        if (m_currentLockTypes & QCamera::LockWhiteBalance)
-            lockModes |= CAMERA_3A_AUTOWHITEBALANCE;
-        if (m_currentLockTypes & QCamera::LockFocus)
-            lockModes |= CAMERA_3A_AUTOFOCUS;
-        break;
-    case FocusExposureBoundMode:
-        if ((m_currentLockTypes & QCamera::LockExposure) || (m_currentLockTypes & QCamera::LockFocus))
-            lockModes = (CAMERA_3A_AUTOEXPOSURE | CAMERA_3A_AUTOFOCUS);
-        break;
-    case AllBoundMode:
-        lockModes = (CAMERA_3A_AUTOEXPOSURE | CAMERA_3A_AUTOFOCUS | CAMERA_3A_AUTOWHITEBALANCE);
-        break;
-    case FocusOnlyMode:
-        lockModes = CAMERA_3A_AUTOFOCUS;
-        break;
-    }
-
-    const camera_error_t result = camera_set_3a_lock(m_session->handle(), lockModes);
-
-    if (result != CAMERA_EOK) {
-        qWarning() << "Unable to set lock modes:" << result;
-    } else {
-        if (lockModes & CAMERA_3A_AUTOFOCUS) {
-            // handled by focusStatusChanged()
-        }
-
-        if (lockModes & CAMERA_3A_AUTOEXPOSURE) {
-            m_exposureLockStatus = QCamera::Locked;
-            emit lockStatusChanged(QCamera::LockExposure, QCamera::Locked, QCamera::LockAcquired);
-        }
-
-        if (lockModes & CAMERA_3A_AUTOWHITEBALANCE) {
-            m_whiteBalanceLockStatus = QCamera::Locked;
-            emit lockStatusChanged(QCamera::LockWhiteBalance, QCamera::Locked, QCamera::LockAcquired);
-        }
-    }
-}
-
-void BbCameraControl::unlock(QCamera::LockTypes locks)
-{
-    // filter out unsupported locks
-    locks &= m_supportedLockTypes;
-
-    m_currentLockTypes &= ~locks;
-
-    uint32_t lockModes = CAMERA_3A_NONE;
-
-    switch (m_locksApplyMode) {
-    case IndependentMode:
-        if (m_currentLockTypes & QCamera::LockExposure)
-            lockModes |= CAMERA_3A_AUTOEXPOSURE;
-        if (m_currentLockTypes & QCamera::LockWhiteBalance)
-            lockModes |= CAMERA_3A_AUTOWHITEBALANCE;
-        if (m_currentLockTypes & QCamera::LockFocus)
-            lockModes |= CAMERA_3A_AUTOFOCUS;
-        break;
-    case FocusExposureBoundMode:
-        if ((m_currentLockTypes & QCamera::LockExposure) || (m_currentLockTypes & QCamera::LockFocus))
-            lockModes = (CAMERA_3A_AUTOEXPOSURE | CAMERA_3A_AUTOFOCUS);
-        break;
-    case AllBoundMode:
-            lockModes = (CAMERA_3A_AUTOEXPOSURE | CAMERA_3A_AUTOFOCUS | CAMERA_3A_AUTOWHITEBALANCE);
-        break;
-    case FocusOnlyMode:
-            lockModes = CAMERA_3A_AUTOFOCUS;
-        break;
-    }
-
-    const camera_error_t result = camera_set_3a_lock(m_session->handle(), lockModes);
-
-    if (result != CAMERA_EOK) {
-        qWarning() << "Unable to set lock modes:" << result;
-    } else {
-        if (locks.testFlag(QCamera::LockFocus)) {
-            // handled by focusStatusChanged()
-        }
-
-        if (locks.testFlag(QCamera::LockExposure)) {
-            m_exposureLockStatus = QCamera::Unlocked;
-            emit lockStatusChanged(QCamera::LockExposure, QCamera::Unlocked, QCamera::UserRequest);
-        }
-
-        if (locks.testFlag(QCamera::LockWhiteBalance)) {
-            m_whiteBalanceLockStatus = QCamera::Unlocked;
-            emit lockStatusChanged(QCamera::LockWhiteBalance, QCamera::Unlocked, QCamera::UserRequest);
-        }
-    }
-}
-
 void BbCameraControl::cameraOpened()
 {
-    // retrieve information about lock apply modes
-    int supported = 0;
-    uint32_t modes[20];
-
-    const camera_error_t result = camera_get_3a_lock_modes(m_session->handle(), 20, &supported, modes);
-
-    if (result == CAMERA_EOK) {
-        // see API documentation of camera_get_3a_lock_modes for explanation of case discrimination below
-        if (supported == 4) {
-            m_locksApplyMode = IndependentMode;
-        } else if (supported == 3) {
-            m_locksApplyMode = FocusExposureBoundMode;
-        } else if (supported == 2) {
-            if (modes[0] == (CAMERA_3A_AUTOFOCUS | CAMERA_3A_AUTOEXPOSURE | CAMERA_3A_AUTOWHITEBALANCE))
-                m_locksApplyMode = AllBoundMode;
-            else
-                m_locksApplyMode = FocusOnlyMode;
-        }
-    }
-
-    // retrieve information about supported lock types
-    m_supportedLockTypes = QCamera::NoLock;
-
-    if (camera_has_feature(m_session->handle(), CAMERA_FEATURE_AUTOFOCUS))
-        m_supportedLockTypes |= QCamera::LockFocus;
-
-    if (camera_has_feature(m_session->handle(), CAMERA_FEATURE_AUTOEXPOSURE))
-        m_supportedLockTypes |= QCamera::LockExposure;
-
-    if (camera_has_feature(m_session->handle(), CAMERA_FEATURE_AUTOWHITEBALANCE))
-        m_supportedLockTypes |= QCamera::LockWhiteBalance;
-
-    m_focusLockStatus = QCamera::Unlocked;
-    m_exposureLockStatus = QCamera::Unlocked;
-    m_whiteBalanceLockStatus = QCamera::Unlocked;
-}
-
-void BbCameraControl::focusStatusChanged(int value)
-{
-    const camera_focusstate_t focusState = static_cast<camera_focusstate_t>(value);
-
-    switch (focusState) {
-    case CAMERA_FOCUSSTATE_NONE:
-        m_focusLockStatus = QCamera::Unlocked;
-        emit lockStatusChanged(QCamera::LockFocus, QCamera::Unlocked, QCamera::UserRequest);
-        break;
-    case CAMERA_FOCUSSTATE_WAITING:
-    case CAMERA_FOCUSSTATE_SEARCHING:
-        m_focusLockStatus = QCamera::Searching;
-        emit lockStatusChanged(QCamera::LockFocus, QCamera::Searching, QCamera::UserRequest);
-        break;
-    case CAMERA_FOCUSSTATE_FAILED:
-        m_focusLockStatus = QCamera::Unlocked;
-        emit lockStatusChanged(QCamera::LockFocus, QCamera::Unlocked, QCamera::LockFailed);
-        break;
-    case CAMERA_FOCUSSTATE_LOCKED:
-        m_focusLockStatus = QCamera::Locked;
-        emit lockStatusChanged(QCamera::LockFocus, QCamera::Locked, QCamera::LockAcquired);
-        break;
-    case CAMERA_FOCUSSTATE_SCENECHANGE:
-        m_focusLockStatus = QCamera::Unlocked;
-        emit lockStatusChanged(QCamera::LockFocus, QCamera::Unlocked, QCamera::LockTemporaryLost);
-        break;
-    default:
-        break;
-    }
 }
 
 QT_END_NAMESPACE
diff --git a/src/multimedia/platform/qnx/camera/bbcameracontrol_p.h b/src/multimedia/platform/qnx/camera/bbcameracontrol_p.h
index 277560c58..65996190e 100644
--- a/src/multimedia/platform/qnx/camera/bbcameracontrol_p.h
+++ b/src/multimedia/platform/qnx/camera/bbcameracontrol_p.h
@@ -83,25 +83,12 @@ public:
         FocusOnlyMode
     };
 
-    QCamera::LockTypes supportedLocks() const override;
-    QCamera::LockStatus lockStatus(QCamera::LockType lock) const override;
-    void searchAndLock(QCamera::LockTypes locks) override;
-    void unlock(QCamera::LockTypes locks) override;
-
 private Q_SLOTS:
     void cameraOpened();
-    void focusStatusChanged(int value);
 
 private:
     BbCameraSession *m_session;
 
-    LocksApplyMode m_locksApplyMode = IndependentMode;
-    QCamera::LockStatus m_focusLockStatus = QCamera::Unlocked;
-    QCamera::LockStatus m_exposureLockStatus = QCamera::Unlocked;
-    QCamera::LockStatus m_whiteBalanceLockStatus = QCamera::Unlocked;
-    QCamera::LockTypes m_currentLockTypes = QCamera::NoLock;
-    QCamera::LockTypes m_supportedLockTypes = QCamera::NoLock;
-
 private:
     BbCameraSession *m_session;
 };