qandroidcamera.cpp

Go to the documentation of this file.

// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include <QtFFmpegMediaPluginImpl/private/qandroidcamera_p.h>
 
#include <jni.h>
 
#include <memory>
#include <optional>
#include <utility>
 
#include <QtCore/qdebug.h>
#include <QtCore/qloggingcategory.h>
#include <QtCore/qmetaobject.h>
#include <QtCore/qpermissions.h>
#include <QtCore/qreadwritelock.h>
#include <QtCore/private/qandroidextras_p.h>
 
#include <QtGui/qguiapplication.h>
#include <QtGui/qscreen.h>
 
#include <QtFFmpegMediaPluginImpl/private/qandroidvideoframefactory_p.h>
#include <QtFFmpegMediaPluginImpl/private/qffmpegvideobuffer_p.h>
 
#include <QtMultimedia/qmediaformat.h>
#include <QtMultimedia/qmediadevices.h>
#include <QtMultimedia/private/qcameradevice_p.h>
#include <QtMultimedia/private/qmultimediautils_p.h>
#include <QtMultimedia/private/qvideoframe_p.h>
#include <QtMultimedia/private/qvideoframeconverter_p.h>
#include <QtMultimedia/private/qvideotexturehelper_p.h>
 
extern "C" {
#include "libavutil/hwcontext.h"
}
 
QT_BEGIN_NAMESPACE
Q_STATIC_LOGGING_CATEGORY(qLCAndroidCamera, "qt.multimedia.ffmpeg.androidCamera");
 
// TODO: Should be reworked to just pass a pointer of the QAndroidCamera object into the QtCamera2
// Java instance.
typedef QMap<QString, QFFmpeg::QAndroidCamera *> QAndroidCameraMap;
Q_GLOBAL_STATIC(QAndroidCameraMap, g_qcameras)
Q_GLOBAL_STATIC(QReadWriteLock, rwLock)
 
namespace {
 
// TODO: Unify format selection with cross-platform layer
QCameraFormat getDefaultCameraFormat(const QCameraDevice & cameraDevice)
{
    // default settings
    const auto defaultFrameFormat = QVideoFrameFormat::Format_YUV420P;
    const auto defaultResolution = QSize(1920, 1080);
    QCameraFormatPrivate *defaultFormat = new QCameraFormatPrivate{
        .pixelFormat = defaultFrameFormat,
        .resolution = defaultResolution,
        .minFrameRate = 12,
        .maxFrameRate = 30,
    };
 
    QCameraFormat resultFormat = defaultFormat->create();
    const auto &supportedFormats = cameraDevice.videoFormats();
 
    if (supportedFormats.empty() || supportedFormats.contains(resultFormat))
        return resultFormat;
 
    auto pixelCount = [](const QSize& resolution) {
        Q_ASSERT(resolution.isValid());
        return resolution.width() * resolution.height();
    };
 
    const int defaultPixelCount = pixelCount(defaultResolution);
 
    // The lower the score, the better the format suits
    int differenceScore = std::numeric_limits<int>::max();
 
    auto calcDifferenceScore = [defaultPixelCount, pixelCount](const QCameraFormat& format) {
        const int pixelDifference = pixelCount(format.resolution()) - defaultPixelCount;
        // prefer:
        // 1. 'pixels count >= default' over 'pixels count < default'
        // 2. lower abs(pixelDifference)
        return pixelDifference < 0
                  ? -pixelDifference
                  : std::numeric_limits<int>::min() + pixelDifference;
    };
 
    for (const auto &supportedFormat : supportedFormats) {
        if (supportedFormat.pixelFormat() == defaultFrameFormat) {
            if (supportedFormat.resolution() == defaultResolution)
                return supportedFormat;
 
            const int currentDifferenceScore = calcDifferenceScore(supportedFormat);
 
            if (currentDifferenceScore < differenceScore) {
                differenceScore = currentDifferenceScore;
                resultFormat = supportedFormat;
            }
        }
    }
 
    return resultFormat;
}
 
bool checkCameraPermission()
{
    QCameraPermission permission;
 
    const bool granted = qApp->checkPermission(permission) == Qt::PermissionStatus::Granted;
    if (!granted)
        qCWarning(qLCAndroidCamera) << "Access to camera not granted!";
 
    return granted;
}
 
int sensorOrientation(QString cameraId)
{
    QJniObject deviceManager(QtJniTypes::Traits<QtJniTypes::QtVideoDeviceManager>::className(),
                             QNativeInterface::QAndroidApplication::context());
 
    if (!deviceManager.isValid()) {
        qCWarning(qLCAndroidCamera) << "Failed to connect to Qt Video Device Manager.";
        return 0;
    }
 
    return deviceManager.callMethod<jint>("getSensorOrientation",
                                          QJniObject::fromString(cameraId).object<jstring>());
}
 
// Returns the FocusModes that are available on the physical device, for which we also have
// an implementation.
[[nodiscard]] static QList<QCamera::FocusMode> qGetSupportedFocusModesFromAndroidCamera(
    const QJniObject &deviceManager,
    const QCameraDevice &cameraDevice)
{
    QList<QCamera::FocusMode> returnValue;
 
    const QStringList focusModeStrings = deviceManager.callMethod<QStringList>(
            "getSupportedQCameraFocusModesAsStrings",
            QJniObject::fromString(QString::fromUtf8(cameraDevice.id())).object<jstring>());
 
    // Translate the strings into enums if possible.
    for (const QString &focusModeString : focusModeStrings) {
        bool ok = false;
        const auto focusMode = static_cast<QCamera::FocusMode>(
            QMetaEnum::fromType<QCamera::FocusMode>()
                .keyToValue(
                    focusModeString.toLatin1().data(),
                    &ok));
        if (ok)
            returnValue.push_back(focusMode);
        else
            qCDebug(qLCAndroidCamera) <<
                "received a QCamera::FocusMode string from Android "
                "QtVideoDeviceManager.java that was not recognized.";
    }
 
    return returnValue;
}
 
} // namespace
 
namespace QFFmpeg {
 
// QAndroidCamera
 
QAndroidCamera::QAndroidCamera(QCamera *camera)
    : QPlatformCamera(camera)
    , m_jniCamera(QNativeInterface::QAndroidApplication::context())
{
 
    m_hwAccel = QFFmpeg::HWAccel::create(AVHWDeviceType::AV_HWDEVICE_TYPE_MEDIACODEC);
    if (camera) {
        m_cameraDevice = camera->cameraDevice();
        m_cameraFormat = !camera->cameraFormat().isNull() ? camera->cameraFormat()
                                                          : getDefaultCameraFormat(m_cameraDevice);
        updateCameraCharacteristics();
    }
 
    if (qApp) {
        connect(qApp, &QGuiApplication::applicationStateChanged,
                this, &QAndroidCamera::onApplicationStateChanged);
    }
};
 
QAndroidCamera::~QAndroidCamera()
{
    // stopAndClose() waits for onClosed(), possibly queued behind other calls
    // which need rwLock
    m_jniCamera.callMethod<void>("stopAndClose");
    setState(State::Closed);
 
    {
        QWriteLocker locker(rwLock);
        g_qcameras->remove(QString::fromUtf8(m_cameraDevice.id()));
    }
 
    m_jniCamera.callMethod<void>("stopBackgroundThread");
}
 
void QAndroidCamera::setCamera(const QCameraDevice &camera)
{
    const bool oldActive = isActive();
    if (oldActive)
        setActive(false);
 
    // Reset all our control-members on the Java-side to default
    // values. Then populate them again during updateCameraCharacteristics()
    m_jniCamera.callMethod<void>("resetControlProperties");
 
    m_cameraDevice = camera;
    updateCameraCharacteristics();
    m_cameraFormat = getDefaultCameraFormat(camera);
 
    if (oldActive)
        setActive(true);
}
 
std::optional<int> QAndroidCamera::ffmpegHWPixelFormat() const
{
    // TODO: m_androidFramePixelFormat is continuously being written to by
    // the Java-side capture-processing background thread when receiving frame, while this
    // function is commonly called by the media recording engine on other threads.
    // A potential solution might include a mutex-lock and/or determining
    // the pixelFormat ahead of time by checking what format we request
    // when starting the Android camera capture session.
    return QFFmpegVideoBuffer::toAVPixelFormat(m_androidFramePixelFormat);
}
 
QVideoFrameFormat QAndroidCamera::frameFormat() const
{
    QVideoFrameFormat result = QPlatformCamera::frameFormat();
    // Apply rotation for surface only
    result.setRotation(rotation());
    return result;
}
 
// Called by the Java-side processing background thread.
void QAndroidCamera::frameAvailable(QJniObject image, bool takePhoto)
{
    if ((!(m_state == State::WaitingStart || m_state == State::Started) && !m_waitingForFirstFrame)
            || m_frameFactory == nullptr) {
        qCWarning(qLCAndroidCamera) << "Received frame when not active... ignoring";
        qCWarning(qLCAndroidCamera) << "state:" << m_state;
        image.callMethod<void>("close");
        return;
    }
 
    QVideoFrame videoFrame = m_frameFactory->createVideoFrame(image, rotation());
    if (!videoFrame.isValid())
        return;
 
    // TODO: m_androidFramePixelFormat is written by the Java-side processing
    // background thread, but read by the QCamera thread during QAndroid::ffmpegHWPixelFormat().
    // This causes a race condition (not severe). We should eventually implement some
    // synchronization strategy.
    m_androidFramePixelFormat = videoFrame.pixelFormat(); // NOTE: Should this be updated on stills?
    if (m_waitingForFirstFrame) {
        m_waitingForFirstFrame = false;
        setState(State::Started);
        // Apply a still resolution changed during startup
        QMetaObject::invokeMethod(this, &QAndroidCamera::applyStillResolution,
                                  Qt::QueuedConnection);
    }
 
    videoFrame.setMirrored(m_cameraDevice.position() == QCameraDevice::Position::FrontFace);
 
    if (!takePhoto)
        Q_EMIT newVideoFrame(videoFrame);
    else
        Q_EMIT onStillPhotoCaptured(videoFrame);
}
 
QtVideo::Rotation QAndroidCamera::rotation() const
{
    // If the camera is not attached to the main display, we don't want to apply rotation
    // based on primary screen. We assume we are an external camera.
    const QCameraDevice::Position cameraPosition = m_cameraDevice.position();
    const bool isExternalCamera = cameraPosition == QCameraDevice::Position::UnspecifiedPosition;
    if (isExternalCamera)
        return QtVideo::Rotation::None;
 
    auto screen = QGuiApplication::primaryScreen();
    auto screenOrientation = screen->orientation();
    if (screenOrientation == Qt::PrimaryOrientation)
        screenOrientation = screen->primaryOrientation();
 
    // Display rotation is the opposite direction of the physical device rotation. We need the
    // device rotation, that's why Landscape is 270 and InvertedLandscape is 90
    int deviceOrientation = 0;
    switch (screenOrientation) {
    case Qt::PrimaryOrientation:
    case Qt::PortraitOrientation:
        break;
    case Qt::LandscapeOrientation:
        deviceOrientation = 270;
        break;
    case Qt::InvertedPortraitOrientation:
        deviceOrientation = 180;
        break;
    case Qt::InvertedLandscapeOrientation:
        deviceOrientation = 90;
        break;
    }
 
    const int sign = (cameraPosition == QCameraDevice::Position::FrontFace) ? 1 : -1;
    int rotation = (sensorOrientation(QString::fromUtf8(m_cameraDevice.id()))
            - deviceOrientation * sign + 360) % 360;
 
    return QtVideo::Rotation(rotation);
}
 
void QAndroidCamera::setActive(bool active)
{
    Q_ASSERT(thread()->isCurrentThread());
    if (isActive() == active)
        return;
 
    if (!m_jniCamera.isValid()) {
        updateError(QCamera::CameraError, QStringLiteral("No connection to Android Camera2 API"));
        return;
    }
 
    if (!active || !checkCameraPermission()) {
        m_jniCamera.callMethod<void>("stopAndClose");
        m_jniCamera.callMethod<void>("clearSurfaces");
        setState(State::Closed);
        return;
    }
 
    QWriteLocker locker(rwLock);
    QString cameraId = QString::fromUtf8(m_cameraDevice.id());
    int width = m_cameraFormat.resolution().width();
    int height = m_cameraFormat.resolution().height();
 
    if (width < 0 || height < 0) {
        m_cameraFormat = getDefaultCameraFormat(m_cameraDevice);
        width = m_cameraFormat.resolution().width();
        height = m_cameraFormat.resolution().height();
    }
 
    m_videoResolution = { FFALIGN(width, 16), FFALIGN(height, 16) };
    m_stillReaderSize = stillResolution();
 
    setState(State::WaitingOpen);
    g_qcameras->insert(cameraId, this);
 
    // Create frameFactory when ImageReader is created;
    m_frameFactory = QAndroidVideoFrameFactory::create();
 
    // Most supported format combination for ImageReaders in a session is YUV_420_888 for
    // preview/video, and JPEG for stills
    // TODO: Set session combinations based on device capabilities:
    // https://developer.android.com/reference/android/hardware/camera2/CameraDevice#regular-capture
    m_jniCamera.callMethod<void>("prepareCamera", static_cast<jint>(m_videoResolution.width()),
                                 static_cast<jint>(m_videoResolution.height()),
                                 static_cast<jint>(m_cameraFormat.minFrameRate()),
                                 static_cast<jint>(m_cameraFormat.maxFrameRate()),
                                 static_cast<jint>(m_stillReaderSize.width()),
                                 static_cast<jint>(m_stillReaderSize.height()));
 
    bool canOpen = m_jniCamera.callMethod<jboolean>("open", cameraId);
 
    if (!canOpen) {
        g_qcameras->remove(cameraId);
        setState(State::Closed);
        updateError(QCamera::CameraError,
                    QString(u"Failed to start camera: ").append(m_cameraDevice.description()));
    }
}
 
// TODO: setState is currently being used by the C++ thread owning
// the QCamera object, and the Java-side capture-processing background thread.
// This can lead to race conditions and the m_state ending up in inconsistent states.
// We should have a synchronization strategy in the future.
void QAndroidCamera::setState(QAndroidCamera::State newState)
{
    if (newState == m_state)
        return;
 
    bool wasActive = isActive();
 
    if (newState == State::Started)
        m_state = State::Started;
 
    if (m_state == State::Started && newState == State::Closed)
        m_state = State::Closed;
 
    if ((m_state == State::WaitingOpen || m_state == State::WaitingStart)
        && newState == State::Closed) {
 
        m_state = State::Closed;
 
        updateError(QCamera::CameraError,
                    QString(u"Failed to start Camera %1").arg(m_cameraDevice.description()));
    }
 
    if (m_state == State::Closed && newState == State::WaitingOpen)
        m_state = State::WaitingOpen;
 
    if (m_state == State::WaitingOpen && newState == State::WaitingStart)
        m_state = State::WaitingStart;
 
    if (wasActive != isActive())
        Q_EMIT activeChanged(isActive());
}
 
bool QAndroidCamera::setCameraFormat(const QCameraFormat &format)
{
    const auto chosenFormat = format.isNull() ? getDefaultCameraFormat(m_cameraDevice) : format;
 
    if (chosenFormat == m_cameraFormat)
        return true;
    if (!m_cameraDevice.videoFormats().contains(chosenFormat))
        return false;
 
    m_cameraFormat = chosenFormat;
 
    restartCamera();
 
    return true;
}
 
void QAndroidCamera::updateCameraCharacteristics()
{
    if (m_cameraDevice.id().isEmpty()) {
        cleanCameraCharacteristics();
        return;
    }
 
    QJniObject deviceManager(QtJniTypes::Traits<QtJniTypes::QtVideoDeviceManager>::className(),
                             QNativeInterface::QAndroidApplication::context());
 
    if (!deviceManager.isValid()) {
        qCWarning(qLCAndroidCamera) << "Failed to connect to Qt Video Device Manager.";
        cleanCameraCharacteristics();
        return;
    }
 
 
    // Gather capabilities.
    QCamera::Features newSupportedFeatures = {};
 
    float newMaxZoom = 1.f;
    float newMinZoom = 1.f;
    const auto newZoomRange = deviceManager.callMethod<jfloat[]>(
            "getZoomRange",
            QJniObject::fromString(QString::fromUtf8(m_cameraDevice.id())).object<jstring>());
    if (newZoomRange.isValid() && newZoomRange.size() == 2) {
        newMinZoom = newZoomRange[0];
        newMaxZoom = newZoomRange[1];
    } else {
        qCDebug(qLCAndroidCamera) <<
            "received invalid float array when querying zoomRange from Android Camera2. "
            "Likely Qt developer bug";
    }
 
    m_supportedFlashModes.clear();
    m_supportedFlashModes.append(QCamera::FlashOff);
    const QStringList flashModes = deviceManager.callMethod<QStringList>(
            "getSupportedFlashModes",
            QJniObject::fromString(QString::fromUtf8(m_cameraDevice.id())).object<jstring>());
    for (const auto &flashMode : flashModes) {
        if (flashMode == QLatin1String("auto"))
            m_supportedFlashModes.append(QCamera::FlashAuto);
        else if (flashMode == QLatin1String("on"))
            m_supportedFlashModes.append(QCamera::FlashOn);
    }
 
    m_TorchModeSupported = deviceManager.callMethod<jboolean>(
            "isTorchModeSupported",
            QJniObject::fromString(QString::fromUtf8(m_cameraDevice.id())).object<jstring>());
 
    m_supportedFocusModes = qGetSupportedFocusModesFromAndroidCamera(
        deviceManager,
        m_cameraDevice);
 
    if (m_supportedFocusModes.contains(QCamera::FocusMode::FocusModeManual))
        newSupportedFeatures |= QCamera::Feature::FocusDistance;
 
 
    // Signal capability changes
    minimumZoomFactorChanged(newMinZoom);
    maximumZoomFactorChanged(newMaxZoom);
    supportedFeaturesChanged(newSupportedFeatures);
 
 
    // Apply properties
    if (minZoomFactor() < maxZoomFactor()) {
        // New device supports zooming. Clamp it and apply it to new camera device.
        const float newZoomFactor = qBound(minZoomFactor(), zoomFactor(), maxZoomFactor());
        zoomTo(newZoomFactor, -1);
    }
 
    if (isFlashModeSupported(flashMode()))
        setFlashMode(flashMode());
 
    if (isTorchModeSupported(torchMode()))
        setTorchMode(torchMode());
 
    if (isFocusModeSupported(focusMode()))
        setFocusMode(focusMode());
 
 
    // Reset properties if needed.
    if (minZoomFactor() >= maxZoomFactor())
        zoomFactorChanged(defaultZoomFactor());
 
    if (!isFlashModeSupported(flashMode()))
        flashModeChanged(defaultFlashMode());
 
    if (!isTorchModeSupported(torchMode()))
        torchModeChanged(defaultTorchMode());
 
    if (!isFocusModeSupported(focusMode()))
        focusModeChanged(defaultFocusMode());
}
 
// Should only be called when the camera device is set to null.
void QAndroidCamera::cleanCameraCharacteristics()
{
    maximumZoomFactorChanged(1.0);
    if (zoomFactor() != 1.0) {
        zoomTo(1.0, -1.0);
    }
    if (torchMode() != QCamera::TorchOff) {
        setTorchMode(QCamera::TorchOff);
    }
    m_TorchModeSupported = false;
 
    if (flashMode() != QCamera::FlashOff) {
        setFlashMode(QCamera::FlashOff);
    }
    m_supportedFlashModes.clear();
    m_supportedFlashModes.append(QCamera::FlashOff);
 
 
    // Reset focus mode.
    if (focusMode() != QCamera::FocusModeAuto)
        setFocusMode(QCamera::FocusModeAuto);
    m_supportedFocusModes.clear();
 
    supportedFeaturesChanged({});
}
 
QSize QAndroidCamera::stillResolution() const
{
    if (m_requestedStillResolution.isEmpty())
        return m_videoResolution; // Not set, will use video resolution
 
    const QList<QSize> photoResolutions = m_cameraDevice.photoResolutions();
 
    // Use as-is with empty list, might fail
    if (photoResolutions.isEmpty() || photoResolutions.contains(m_requestedStillResolution))
        return m_requestedStillResolution;
 
    return qClosestSupportedResolution(m_requestedStillResolution, photoResolutions);
}
 
// Restart camera now, must be called from owning thread
void QAndroidCamera::restartCamera()
{
    if (!isActive())
        return;
 
    setActive(false);
    setActive(true);
}
 
// Queue a camera restart, can be called from a background Java thread
void QAndroidCamera::queueCameraRestart()
{
    if (m_restartPending.exchange(true))
        return;
 
    // NOTE: Queued on event loop to avoid re-entering onVideoSourceChanged
    QMetaObject::invokeMethod(
            this,
            [this]() {
                m_restartPending = false;
                restartCamera(); // No-op if inactive
            },
            Qt::QueuedConnection);
}
 
void QAndroidCamera::setFocusDistance(float distance)
{
    if (QtPrivate::fuzzyCompare(focusDistance(), distance))
        return;
 
    if (!(supportedFeatures() & QCamera::Feature::FocusDistance)) {
        qCWarning(qLCAndroidCamera) <<
            Q_FUNC_INFO <<
            "attmpted to set focus-distance on camera without support for FocusDistance feature";
        return;
    }
 
    if (distance < 0 || distance > 1) {
        qCWarning(qLCAndroidCamera) <<
            Q_FUNC_INFO <<
            "attempted to set camera focus-distance with out-of-bounds value";
        return;
    }
 
    // focusDistance should only be applied if the focusMode is currently set to Manual.
    // The Java function will handle this behavior. Either way, the value should be accepted so
    // we can apply it if FocusModeManual is activated
    m_jniCamera.callMethod<void>("setFocusDistance", distance);
 
    focusDistanceChanged(distance);
}
 
void QAndroidCamera::setFocusMode(QCamera::FocusMode mode)
{
    if (focusMode() == mode)
        return;
 
    if (!isFocusModeSupported(mode)) {
        qCWarning(qLCAndroidCamera) <<
            Q_FUNC_INFO <<
            QLatin1String("attempted to set focus-mode '%1' on camera where it is unsupported.")
                .arg(QMetaEnum::fromType<QCamera::FocusMode>().valueToKey(mode));
        return;
    }
 
    // If the new focus-mode is Manual, then the focusDistance
    // needs to be applied as well. The Java function handles this.
    m_jniCamera.callMethod<void>(
        "setFocusMode",
        static_cast<jint>(mode));
 
    focusModeChanged(mode);
}
 
void QAndroidCamera::setFlashMode(QCamera::FlashMode mode)
{
    if (!isFlashModeSupported(mode))
        return;
 
    QString flashMode;
    switch (mode) {
        case QCamera::FlashAuto:
            flashMode = QLatin1String("auto");
            break;
        case QCamera::FlashOn:
            flashMode = QLatin1String("on");
            break;
        case QCamera::FlashOff:
        default:
            flashMode = QLatin1String("off");
            break;
    }
 
    m_jniCamera.callMethod<void>("setFlashMode", QJniObject::fromString(flashMode).object<jstring>());
    flashModeChanged(mode);
}
 
bool QAndroidCamera::isFlashModeSupported(QCamera::FlashMode mode) const
{
    return m_supportedFlashModes.contains(mode);
}
 
bool QAndroidCamera::isFlashReady() const
{
    // Android doesn't have an API for that.
    // Only check if device supports more flash modes than just FlashOff.
    return m_supportedFlashModes.size() > 1;
}
 
bool QAndroidCamera::isFocusModeSupported(QCamera::FocusMode mode) const
{
    return QPlatformCamera::isFocusModeSupported(mode) || m_supportedFocusModes.contains(mode);
}
 
bool QAndroidCamera::isTorchModeSupported(QCamera::TorchMode mode) const
{
    if (mode == QCamera::TorchOff)
        return true;
    else if (mode == QCamera::TorchOn)
        return m_TorchModeSupported;
 
    return false;
}
 
void QAndroidCamera::setTorchMode(QCamera::TorchMode mode)
{
    bool torchMode;
    if (mode == QCamera::TorchOff) {
        torchMode = false;
    } else if (mode == QCamera::TorchOn) {
        torchMode = true;
    } else {
        qWarning() << "Unknown Torch mode";
        return;
    }
    m_jniCamera.callMethod<void>("setTorchMode", jboolean(torchMode));
    torchModeChanged(mode);
}
 
void QAndroidCamera::zoomTo(float factor, float rate)
{
    Q_UNUSED(rate);
 
    if (!m_cameraDevice.id().isEmpty()) {
        m_jniCamera.callMethod<void>("zoomTo", factor);
    }
    zoomFactorChanged(factor);
}
 
void QAndroidCamera::onApplicationStateChanged()
{
    switch (QGuiApplication::applicationState()) {
        case Qt::ApplicationInactive:
            if (isActive()) {
                setActive(false);
                m_wasActive = true;
            }
            break;
        case Qt::ApplicationActive:
            if (m_wasActive) {
                setActive(true);
                m_wasActive = false;
            }
            break;
        default:
            break;
    }
}
 
// Called by Java-side processing background thread.
void QAndroidCamera::onCaptureSessionConfigured()
{
    bool canStart = m_jniCamera.callMethod<jboolean>("start");
    setState(canStart ? State::WaitingStart : State::Closed);
}
 
// Called by Java-side processing background thread.
void QAndroidCamera::onCaptureSessionConfigureFailed()
{
    setState(State::Closed);
}
 
// Called by Java-side processing background thread.
// The session rebuilt for a new still reader size failed. Fall back to a full restart.
void QAndroidCamera::onStillReaderSwapFailed()
{
    queueCameraRestart();
}
 
// Called by Java-side processing background thread.
void QAndroidCamera::onCameraOpened()
{
    bool canStart = m_jniCamera.callMethod<jboolean>("createSession");
    setState(canStart ? State::WaitingStart : State::Closed);
}
 
// Called by Java-side processing background thread.
void QAndroidCamera::onCameraDisconnect()
{
    setState(State::Closed);
}
 
// Called by Java-side processing background thread.
void QAndroidCamera::onCameraError(int reason)
{
    updateError(QCamera::CameraError,
                QString(u"Capture error with Camera %1. Camera2 Api error code: %2")
                        .arg(m_cameraDevice.description())
                        .arg(reason));
}
 
// Called by Java-side processing background thread.
void QAndroidCamera::onSessionActive()
{
    m_waitingForFirstFrame = true;
}
 
// Called by Java-side processing background thread.
void QAndroidCamera::onSessionClosed()
{
    m_waitingForFirstFrame = false;
    setState(State::Closed);
}
 
void QAndroidCamera::capture()
{
    m_jniCamera.callMethod<void>("beginStillPhotoCapture");
}
 
void QAndroidCamera::updateExif(const QString &filename)
{
    m_jniCamera.callMethod<void>("saveExifToFile", QJniObject::fromString(filename).object<jstring>());
}
 
void QAndroidCamera::setStillCaptureResolution(QSize resolution)
{
    Q_ASSERT(thread()->isCurrentThread());
 
    if (resolution != m_requestedStillResolution && !resolution.isEmpty()
        && m_cameraDevice.photoResolutions().isEmpty()) {
        qCWarning(qLCAndroidCamera) << "Image capture resolution set to" << resolution
                                    << "while list of valid photo resolutions is empty. Image "
                                       "capture can fail if resolution is not supported by device.";
    }
    m_requestedStillResolution = resolution;
    applyStillResolution();
}
 
void QAndroidCamera::applyStillResolution()
{
    Q_ASSERT(thread()->isCurrentThread());
 
    const QSize newSize = stillResolution();
    // Not started: the next start uses the new size or re-runs this, see frameAvailable()
    if (!isActive() || m_stillReaderSize == newSize)
        return;
 
    if (m_jniCamera.callMethod<jboolean>("updateStillImageReader", newSize.width(),
                                         newSize.height())) {
        m_stillReaderSize = newSize;
        return;
    }
 
    queueCameraRestart();
}
 
void QAndroidCamera::onCaptureSessionFailed(int reason, long frameNumber)
{
    Q_UNUSED(frameNumber);
 
    updateError(QCamera::CameraError,
                QStringLiteral("Capture session failure with Camera %1. Camera2 Api error code: %2")
                        .arg(m_cameraDevice.description())
                        .arg(reason));
}
 
// Called by Java background thread if the on-going still-photo capture fails.
void QAndroidCamera::onStillPhotoCaptureFailed()
{
    // TODO: Emit a more descriptive error signal. At the time of writing, there is no
    // suitable QImageCapture::Error enumerator for this scenario.
    Q_EMIT onImageCaptureFailed(
        QImageCapture::Error::ResourceError,
        QStringLiteral("Unknown error"));
}
 
} // namespace QFFmpeg
 
// JNI logic
// The following static functions can only be called by the Java-side processing background
// thread.
 
#define GET_CAMERA(cameraId)
  QString key = QJniObject(cameraId).toString();
  QReadLocker locker(rwLock);
  if (!g_qcameras->contains(key)) {
    qCWarning(qLCAndroidCamera) << "Calling back a QtCamera2 after being destroyed.";
    return;
  }
  QFFmpeg::QAndroidCamera *camera = g_qcameras->find(key).value();
 
static void onPreviewFrameAvailable(JNIEnv *env, jobject obj, jstring cameraId,
                             QtJniTypes::Image image)
{
    Q_UNUSED(env);
    Q_UNUSED(obj);
    GET_CAMERA(cameraId);
 
    camera->frameAvailable(QJniObject(image));
}
Q_DECLARE_JNI_NATIVE_METHOD(onPreviewFrameAvailable)
 
static void onStillPhotoAvailable(JNIEnv *env, jobject obj, jstring cameraId,
                             QtJniTypes::Image image)
{
    Q_UNUSED(env);
    Q_UNUSED(obj);
    GET_CAMERA(cameraId);
 
    camera->frameAvailable(QJniObject(image), true);
}
Q_DECLARE_JNI_NATIVE_METHOD(onStillPhotoAvailable)
 
 
static void onCameraOpened(JNIEnv *env, jobject obj, jstring cameraId)
{
    Q_UNUSED(env);
    Q_UNUSED(obj);
    GET_CAMERA(cameraId);
 
    camera->onCameraOpened();
}
Q_DECLARE_JNI_NATIVE_METHOD(onCameraOpened)
 
static void onCameraDisconnect(JNIEnv *env, jobject obj, jstring cameraId)
{
    Q_UNUSED(env);
    Q_UNUSED(obj);
    GET_CAMERA(cameraId);
 
    camera->onCameraDisconnect();
}
Q_DECLARE_JNI_NATIVE_METHOD(onCameraDisconnect)
 
static void onCameraError(JNIEnv *env, jobject obj, jstring cameraId, jint error)
{
    Q_UNUSED(env);
    Q_UNUSED(obj);
    GET_CAMERA(cameraId);
 
    camera->onCameraError(error);
}
Q_DECLARE_JNI_NATIVE_METHOD(onCameraError)
 
static void onCaptureSessionConfigured(JNIEnv *env, jobject obj, jstring cameraId)
{
    Q_UNUSED(env);
    Q_UNUSED(obj);
    GET_CAMERA(cameraId);
 
    camera->onCaptureSessionConfigured();
}
Q_DECLARE_JNI_NATIVE_METHOD(onCaptureSessionConfigured)
 
static void onCaptureSessionConfigureFailed(JNIEnv *env, jobject obj, jstring cameraId)
{
    Q_UNUSED(env);
    Q_UNUSED(obj);
    GET_CAMERA(cameraId);
 
    camera->onCaptureSessionConfigureFailed();
}
Q_DECLARE_JNI_NATIVE_METHOD(onCaptureSessionConfigureFailed)
 
static void onStillReaderSwapFailed(JNIEnv *env, jobject obj, jstring cameraId)
{
    Q_UNUSED(env);
    Q_UNUSED(obj);
    GET_CAMERA(cameraId);
 
    camera->onStillReaderSwapFailed();
}
Q_DECLARE_JNI_NATIVE_METHOD(onStillReaderSwapFailed)
 
static void onSessionActive(JNIEnv *env, jobject obj, jstring cameraId)
{
    Q_UNUSED(env);
    Q_UNUSED(obj);
    GET_CAMERA(cameraId);
 
    camera->onSessionActive();
}
Q_DECLARE_JNI_NATIVE_METHOD(onSessionActive)
 
static void onSessionClosed(JNIEnv *env, jobject obj, jstring cameraId)
{
    Q_UNUSED(env);
    Q_UNUSED(obj);
    GET_CAMERA(cameraId);
 
    camera->onSessionClosed();
}
Q_DECLARE_JNI_NATIVE_METHOD(onSessionClosed)
 
static void onCaptureSessionFailed(JNIEnv *env, jobject obj, jstring cameraId, jint reason,
                                   jlong framenumber)
{
    Q_UNUSED(env);
    Q_UNUSED(obj);
    GET_CAMERA(cameraId);
 
    camera->onCaptureSessionFailed(reason, framenumber);
}
Q_DECLARE_JNI_NATIVE_METHOD(onCaptureSessionFailed)
 
static void onStillPhotoCaptureFailed(JNIEnv *env, jobject obj, jstring cameraId)
{
    Q_UNUSED(env);
    Q_UNUSED(obj);
    GET_CAMERA(cameraId);
 
    camera->onStillPhotoCaptureFailed();
}
Q_DECLARE_JNI_NATIVE_METHOD(onStillPhotoCaptureFailed)
 
bool QFFmpeg::QAndroidCamera::registerNativeMethods()
{
    static const bool registered = []() {
        return QtJniCamera2::registerNativeMethods({
            Q_JNI_NATIVE_METHOD(onCameraOpened),
            Q_JNI_NATIVE_METHOD(onCameraDisconnect),
            Q_JNI_NATIVE_METHOD(onCameraError),
            Q_JNI_NATIVE_METHOD(onCaptureSessionConfigured),
            Q_JNI_NATIVE_METHOD(onCaptureSessionConfigureFailed),
            Q_JNI_NATIVE_METHOD(onStillReaderSwapFailed),
            Q_JNI_NATIVE_METHOD(onCaptureSessionFailed),
            Q_JNI_NATIVE_METHOD(onPreviewFrameAvailable),
            Q_JNI_NATIVE_METHOD(onStillPhotoAvailable),
            Q_JNI_NATIVE_METHOD(onSessionActive),
            Q_JNI_NATIVE_METHOD(onSessionClosed),
            Q_JNI_NATIVE_METHOD(onStillPhotoCaptureFailed),
        });
    }();
    return registered;
}
 
QT_END_NAMESPACE