androidcamera.cpp

Go to the documentation of this file.

// Copyright (C) 2021 The Qt Company Ltd.
// Copyright (C) 2016 Ruslan Baratov
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "androidcamera_p.h"
#include "androidsurfacetexture_p.h"
#include "androidsurfaceview_p.h"
#include "qandroidmultimediautils_p.h"
#include "qandroidglobal_p.h"
 
#include <private/qvideoframe_p.h>
 
#include <qhash.h>
#include <qstringlist.h>
#include <qdebug.h>
#include <QtCore/qthread.h>
#include <QtCore/qreadwritelock.h>
#include <QtCore/qmutex.h>
#include <QtMultimedia/private/qmemoryvideobuffer_p.h>
#include <QtCore/qcoreapplication.h>
 
#include <mutex>
 
QT_BEGIN_NAMESPACE
 
Q_STATIC_LOGGING_CATEGORY(lcAndroidCamera, "qt.multimedia.android.camera");
 
static const char QtCameraListenerClassName[] = "org/qtproject/qt/android/multimedia/QtCameraListener";
 
typedef QHash<int, AndroidCamera *> CameraMap;
Q_GLOBAL_STATIC(CameraMap, cameras)
Q_GLOBAL_STATIC(QReadWriteLock, rwLock)
 
static QRect areaToRect(jobject areaObj)
{
    QJniObject area(areaObj);
    QJniObject rect = area.getObjectField("rect", "Landroid/graphics/Rect;");
 
    return QRect(rect.getField<jint>("left"),
                 rect.getField<jint>("top"),
                 rect.callMethod<jint>("width"),
                 rect.callMethod<jint>("height"));
}
 
static QJniObject rectToArea(const QRect &rect)
{
    QJniObject jrect("android/graphics/Rect",
                     "(IIII)V",
                     rect.left(), rect.top(), rect.right(), rect.bottom());
 
    QJniObject area("android/hardware/Camera$Area",
                    "(Landroid/graphics/Rect;I)V",
                    jrect.object(), 500);
 
    return area;
}
 
// native method for QtCameraLisener.java
static void notifyAutoFocusComplete(JNIEnv* , jobject, int id, jboolean success)
{
    QReadLocker locker(rwLock);
    const auto it = cameras->constFind(id);
    if (Q_UNLIKELY(it == cameras->cend()))
        return;
 
    Q_EMIT (*it)->autoFocusComplete(success);
}
 
static void notifyPictureExposed(JNIEnv* , jobject, int id)
{
    QReadLocker locker(rwLock);
    const auto it = cameras->constFind(id);
    if (Q_UNLIKELY(it == cameras->cend()))
        return;
 
    Q_EMIT (*it)->pictureExposed();
}
 
static void notifyPictureCaptured(JNIEnv *env, jobject, int id, jbyteArray data)
{
    QReadLocker locker(rwLock);
    const auto it = cameras->constFind(id);
    if (Q_UNLIKELY(it == cameras->cend())) {
        qCWarning(lcAndroidCamera) << "Could not obtain camera!";
        return;
    }
 
    AndroidCamera *camera = (*it);
 
    const int arrayLength = env->GetArrayLength(data);
    QByteArray bytes(arrayLength, Qt::Uninitialized);
    env->GetByteArrayRegion(data, 0, arrayLength, reinterpret_cast<jbyte *>(bytes.data()));
 
    auto parameters = camera->getParametersObject();
 
    QJniObject size =
            parameters.callObjectMethod("getPictureSize", "()Landroid/hardware/Camera$Size;");
 
    if (!size.isValid()) {
        qCWarning(lcAndroidCamera) << "Picture Size is not valid!";
        return;
    }
 
    QSize pictureSize(size.getField<jint>("width"), size.getField<jint>("height"));
 
    auto format = AndroidCamera::ImageFormat(parameters.callMethod<jint>("getPictureFormat"));
 
    if (format == AndroidCamera::ImageFormat::UnknownImageFormat) {
        qCWarning(lcAndroidCamera) << "Android Camera Image Format is UnknownImageFormat!";
        return;
    }
 
    int bytesPerLine = 0;
 
    switch (format) {
    case AndroidCamera::ImageFormat::YV12:
        bytesPerLine = (pictureSize.width() + 15) & ~15;
        break;
    case AndroidCamera::ImageFormat::NV21:
        bytesPerLine = pictureSize.width();
        break;
    case AndroidCamera::ImageFormat::RGB565:
    case AndroidCamera::ImageFormat::YUY2:
        bytesPerLine = pictureSize.width() * 2;
        break;
    default:
        bytesPerLine = -1;
    }
 
    auto pictureFormat = qt_pixelFormatFromAndroidImageFormat(format);
 
    emit camera->pictureCaptured(bytes, pictureFormat, pictureSize, bytesPerLine);
}
 
static void notifyNewPreviewFrame(JNIEnv *env, jobject, int id, jbyteArray data,
                                  int width, int height, int format, int bpl)
{
    QReadLocker locker(rwLock);
    const auto it = cameras->constFind(id);
    if (Q_UNLIKELY(it == cameras->cend()))
        return;
 
    const int arrayLength = env->GetArrayLength(data);
    if (arrayLength == 0)
        return;
 
    QByteArray bytes(arrayLength, Qt::Uninitialized);
    env->GetByteArrayRegion(data, 0, arrayLength, (jbyte*)bytes.data());
 
    QVideoFrameFormat frameFormat(
            QSize(width, height),
            qt_pixelFormatFromAndroidImageFormat(AndroidCamera::ImageFormat(format)));
 
    QVideoFrame frame = QVideoFramePrivate::createFrame(
            std::make_unique<QMemoryVideoBuffer>(std::move(bytes), bpl), std::move(frameFormat));
 
    Q_EMIT (*it)->newPreviewFrame(frame);
}
 
static void notifyFrameAvailable(JNIEnv *, jobject, int id)
{
    QReadLocker locker(rwLock);
    const auto it = cameras->constFind(id);
    if (Q_UNLIKELY(it == cameras->cend()))
        return;
 
    (*it)->fetchLastPreviewFrame();
}
 
class AndroidCameraPrivate : public QObject
{
    Q_OBJECT
public:
    AndroidCameraPrivate();
    ~AndroidCameraPrivate();
 
    Q_INVOKABLE bool init(int cameraId);
 
    Q_INVOKABLE void release();
    Q_INVOKABLE bool lock();
    Q_INVOKABLE bool unlock();
    Q_INVOKABLE bool reconnect();
 
    Q_INVOKABLE AndroidCamera::CameraFacing getFacing();
    Q_INVOKABLE int getNativeOrientation();
 
    Q_INVOKABLE QSize getPreferredPreviewSizeForVideo();
    Q_INVOKABLE QList<QSize> getSupportedPreviewSizes();
    static QList<QSize> getSupportedPreviewSizes(QJniObject &parameters);
 
    Q_INVOKABLE QList<AndroidCamera::FpsRange> getSupportedPreviewFpsRange();
 
    Q_INVOKABLE AndroidCamera::FpsRange getPreviewFpsRange();
    static AndroidCamera::FpsRange getPreviewFpsRange(QJniObject &parameters);
    Q_INVOKABLE void setPreviewFpsRange(int min, int max);
 
    Q_INVOKABLE AndroidCamera::ImageFormat getPreviewFormat();
    Q_INVOKABLE void setPreviewFormat(AndroidCamera::ImageFormat fmt);
    Q_INVOKABLE QList<AndroidCamera::ImageFormat> getSupportedPreviewFormats();
    static QList<AndroidCamera::ImageFormat> getSupportedPreviewFormats(QJniObject &parameters);
 
    Q_INVOKABLE QSize previewSize() const { return m_previewSize; }
    Q_INVOKABLE QSize getPreviewSize();
    Q_INVOKABLE void updatePreviewSize();
    Q_INVOKABLE bool setPreviewTexture(void *surfaceTexture);
    Q_INVOKABLE bool setPreviewDisplay(void *surfaceHolder);
    Q_INVOKABLE void setDisplayOrientation(int degrees);
 
    Q_INVOKABLE bool isZoomSupported();
    Q_INVOKABLE int getMaxZoom();
    Q_INVOKABLE QList<int> getZoomRatios();
    Q_INVOKABLE int getZoom();
    Q_INVOKABLE void setZoom(int value);
 
    Q_INVOKABLE QString getFlashMode();
    Q_INVOKABLE void setFlashMode(const QString &value);
 
    Q_INVOKABLE QString getFocusMode();
    Q_INVOKABLE void setFocusMode(const QString &value);
 
    Q_INVOKABLE int getMaxNumFocusAreas();
    Q_INVOKABLE QList<QRect> getFocusAreas();
    Q_INVOKABLE void setFocusAreas(const QList<QRect> &areas);
 
    Q_INVOKABLE void autoFocus();
    Q_INVOKABLE void cancelAutoFocus();
 
    Q_INVOKABLE bool isAutoExposureLockSupported();
    Q_INVOKABLE bool getAutoExposureLock();
    Q_INVOKABLE void setAutoExposureLock(bool toggle);
 
    Q_INVOKABLE bool isAutoWhiteBalanceLockSupported();
    Q_INVOKABLE bool getAutoWhiteBalanceLock();
    Q_INVOKABLE void setAutoWhiteBalanceLock(bool toggle);
 
    Q_INVOKABLE int getExposureCompensation();
    Q_INVOKABLE void setExposureCompensation(int value);
    Q_INVOKABLE float getExposureCompensationStep();
    Q_INVOKABLE int getMinExposureCompensation();
    Q_INVOKABLE int getMaxExposureCompensation();
 
    Q_INVOKABLE QString getSceneMode();
    Q_INVOKABLE void setSceneMode(const QString &value);
 
    Q_INVOKABLE QString getWhiteBalance();
    Q_INVOKABLE void setWhiteBalance(const QString &value);
 
    Q_INVOKABLE void updateRotation();
 
    Q_INVOKABLE QList<QSize> getSupportedPictureSizes();
    Q_INVOKABLE QList<QSize> getSupportedVideoSizes();
    Q_INVOKABLE void setPictureSize(const QSize &size);
    Q_INVOKABLE void setJpegQuality(int quality);
 
    Q_INVOKABLE void startPreview();
    Q_INVOKABLE void stopPreview();
 
    Q_INVOKABLE void takePicture();
 
    Q_INVOKABLE void setupPreviewFrameCallback();
    Q_INVOKABLE void notifyNewFrames(bool notify);
    Q_INVOKABLE void fetchLastPreviewFrame();
 
    Q_INVOKABLE void applyParameters();
 
    Q_INVOKABLE QStringList callParametersStringListMethod(const QByteArray &methodName);
 
    int m_cameraId;
    QRecursiveMutex m_parametersMutex;
    QSize m_previewSize;
    int m_rotation;
    QJniObject m_info;
    QJniObject m_parameters;
    QJniObject m_camera;
    QJniObject m_cameraListener;
 
Q_SIGNALS:
    void previewSizeChanged();
    void previewStarted();
    void previewFailedToStart();
    void previewStopped();
 
    void autoFocusStarted();
 
    void whiteBalanceChanged();
 
    void takePictureFailed();
 
    void lastPreviewFrameFetched(const QVideoFrame &frame);
};
 
AndroidCamera::AndroidCamera(AndroidCameraPrivate *d, QThread *worker)
    : QObject(),
      d_ptr(d),
      m_worker(worker)
 
{
    connect(d, &AndroidCameraPrivate::previewSizeChanged, this, &AndroidCamera::previewSizeChanged);
    connect(d, &AndroidCameraPrivate::previewStarted, this, &AndroidCamera::previewStarted);
    connect(d, &AndroidCameraPrivate::previewFailedToStart, this, &AndroidCamera::previewFailedToStart);
    connect(d, &AndroidCameraPrivate::previewStopped, this, &AndroidCamera::previewStopped);
    connect(d, &AndroidCameraPrivate::autoFocusStarted, this, &AndroidCamera::autoFocusStarted);
    connect(d, &AndroidCameraPrivate::whiteBalanceChanged, this, &AndroidCamera::whiteBalanceChanged);
    connect(d, &AndroidCameraPrivate::takePictureFailed, this, &AndroidCamera::takePictureFailed);
    connect(d, &AndroidCameraPrivate::lastPreviewFrameFetched, this, &AndroidCamera::lastPreviewFrameFetched);
}
 
AndroidCamera::~AndroidCamera()
{
    Q_D(AndroidCamera);
    if (d->m_camera.isValid()) {
        release();
        QWriteLocker locker(rwLock);
        cameras->remove(cameraId());
    }
 
    m_worker->exit();
    m_worker->wait(5000);
}
 
AndroidCamera *AndroidCamera::open(int cameraId)
{
    if (!qt_androidCheckCameraPermission())
        return nullptr;
 
    AndroidCameraPrivate *d = new AndroidCameraPrivate();
    QThread *worker = new QThread;
    worker->start();
    d->moveToThread(worker);
    connect(worker, &QThread::finished, d, &AndroidCameraPrivate::deleteLater);
    bool ok = true;
    QMetaObject::invokeMethod(d, "init", Qt::BlockingQueuedConnection, Q_RETURN_ARG(bool, ok), Q_ARG(int, cameraId));
    if (!ok) {
        worker->quit();
        worker->wait(5000);
        delete worker;
        return 0;
    }
 
    AndroidCamera *q = new AndroidCamera(d, worker);
    QWriteLocker locker(rwLock);
    cameras->insert(cameraId, q);
 
    return q;
}
 
int AndroidCamera::cameraId() const
{
    Q_D(const AndroidCamera);
    return d->m_cameraId;
}
 
bool AndroidCamera::lock()
{
    Q_D(AndroidCamera);
    bool ok = true;
    QMetaObject::invokeMethod(d, "lock", Qt::BlockingQueuedConnection, Q_RETURN_ARG(bool, ok));
    return ok;
}
 
bool AndroidCamera::unlock()
{
    Q_D(AndroidCamera);
    bool ok = true;
    QMetaObject::invokeMethod(d, "unlock", Qt::BlockingQueuedConnection, Q_RETURN_ARG(bool, ok));
    return ok;
}
 
bool AndroidCamera::reconnect()
{
    Q_D(AndroidCamera);
    bool ok = true;
    QMetaObject::invokeMethod(d, "reconnect", Qt::BlockingQueuedConnection, Q_RETURN_ARG(bool, ok));
    return ok;
}
 
void AndroidCamera::release()
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "release", Qt::BlockingQueuedConnection);
}
 
AndroidCamera::CameraFacing AndroidCamera::getFacing()
{
    Q_D(AndroidCamera);
    return d->getFacing();
}
 
int AndroidCamera::getNativeOrientation()
{
    Q_D(AndroidCamera);
    return d->getNativeOrientation();
}
 
QSize AndroidCamera::getPreferredPreviewSizeForVideo()
{
    Q_D(AndroidCamera);
    return d->getPreferredPreviewSizeForVideo();
}
 
QList<QSize> AndroidCamera::getSupportedPreviewSizes()
{
    Q_D(AndroidCamera);
    return d->getSupportedPreviewSizes();
}
 
QList<AndroidCamera::FpsRange> AndroidCamera::getSupportedPreviewFpsRange()
{
    Q_D(AndroidCamera);
    return d->getSupportedPreviewFpsRange();
}
 
AndroidCamera::FpsRange AndroidCamera::getPreviewFpsRange()
{
    Q_D(AndroidCamera);
    return d->getPreviewFpsRange();
}
 
void AndroidCamera::setPreviewFpsRange(FpsRange range)
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "setPreviewFpsRange", Q_ARG(int, range.min), Q_ARG(int, range.max));
}
 
AndroidCamera::ImageFormat AndroidCamera::getPreviewFormat()
{
    Q_D(AndroidCamera);
    return d->getPreviewFormat();
}
 
void AndroidCamera::setPreviewFormat(ImageFormat fmt)
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "setPreviewFormat", Q_ARG(AndroidCamera::ImageFormat, fmt));
}
 
QList<AndroidCamera::ImageFormat> AndroidCamera::getSupportedPreviewFormats()
{
    Q_D(AndroidCamera);
    return d->getSupportedPreviewFormats();
}
 
QSize AndroidCamera::previewSize() const
{
    Q_D(const AndroidCamera);
    return d->m_previewSize;
}
 
QSize AndroidCamera::actualPreviewSize()
{
    Q_D(AndroidCamera);
    return d->getPreviewSize();
}
 
void AndroidCamera::setPreviewSize(const QSize &size)
{
    Q_D(AndroidCamera);
    d->m_parametersMutex.lock();
    bool areParametersValid = d->m_parameters.isValid();
    d->m_parametersMutex.unlock();
    if (!areParametersValid)
        return;
 
    d->m_previewSize = size;
    QMetaObject::invokeMethod(d, "updatePreviewSize");
}
 
bool AndroidCamera::setPreviewTexture(AndroidSurfaceTexture *surfaceTexture)
{
    Q_D(AndroidCamera);
    bool ok = true;
    QMetaObject::invokeMethod(d,
                              "setPreviewTexture",
                              Qt::BlockingQueuedConnection,
                              Q_RETURN_ARG(bool, ok),
                              Q_ARG(void *, surfaceTexture ? surfaceTexture->surfaceTexture() : 0));
    return ok;
}
 
bool AndroidCamera::setPreviewDisplay(AndroidSurfaceHolder *surfaceHolder)
{
    Q_D(AndroidCamera);
    bool ok = true;
    QMetaObject::invokeMethod(d,
                              "setPreviewDisplay",
                              Qt::BlockingQueuedConnection,
                              Q_RETURN_ARG(bool, ok),
                              Q_ARG(void *, surfaceHolder ? surfaceHolder->surfaceHolder() : 0));
    return ok;
}
 
void AndroidCamera::setDisplayOrientation(int degrees)
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "setDisplayOrientation", Qt::QueuedConnection, Q_ARG(int, degrees));
}
 
bool AndroidCamera::isZoomSupported()
{
    Q_D(AndroidCamera);
    return d->isZoomSupported();
}
 
int AndroidCamera::getMaxZoom()
{
    Q_D(AndroidCamera);
    return d->getMaxZoom();
}
 
QList<int> AndroidCamera::getZoomRatios()
{
    Q_D(AndroidCamera);
    return d->getZoomRatios();
}
 
int AndroidCamera::getZoom()
{
    Q_D(AndroidCamera);
    return d->getZoom();
}
 
void AndroidCamera::setZoom(int value)
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "setZoom", Q_ARG(int, value));
}
 
QStringList AndroidCamera::getSupportedFlashModes()
{
    Q_D(AndroidCamera);
    return d->callParametersStringListMethod("getSupportedFlashModes");
}
 
QString AndroidCamera::getFlashMode()
{
    Q_D(AndroidCamera);
    return d->getFlashMode();
}
 
void AndroidCamera::setFlashMode(const QString &value)
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "setFlashMode", Q_ARG(QString, value));
}
 
QStringList AndroidCamera::getSupportedFocusModes()
{
    Q_D(AndroidCamera);
    return d->callParametersStringListMethod("getSupportedFocusModes");
}
 
QString AndroidCamera::getFocusMode()
{
    Q_D(AndroidCamera);
    return d->getFocusMode();
}
 
void AndroidCamera::setFocusMode(const QString &value)
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "setFocusMode", Q_ARG(QString, value));
}
 
int AndroidCamera::getMaxNumFocusAreas()
{
    Q_D(AndroidCamera);
    return d->getMaxNumFocusAreas();
}
 
QList<QRect> AndroidCamera::getFocusAreas()
{
    Q_D(AndroidCamera);
    return d->getFocusAreas();
}
 
void AndroidCamera::setFocusAreas(const QList<QRect> &areas)
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "setFocusAreas", Q_ARG(QList<QRect>, areas));
}
 
void AndroidCamera::autoFocus()
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "autoFocus");
}
 
void AndroidCamera::cancelAutoFocus()
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "cancelAutoFocus", Qt::QueuedConnection);
}
 
bool AndroidCamera::isAutoExposureLockSupported()
{
    Q_D(AndroidCamera);
    return d->isAutoExposureLockSupported();
}
 
bool AndroidCamera::getAutoExposureLock()
{
    Q_D(AndroidCamera);
    return d->getAutoExposureLock();
}
 
void AndroidCamera::setAutoExposureLock(bool toggle)
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "setAutoExposureLock", Q_ARG(bool, toggle));
}
 
bool AndroidCamera::isAutoWhiteBalanceLockSupported()
{
    Q_D(AndroidCamera);
    return d->isAutoWhiteBalanceLockSupported();
}
 
bool AndroidCamera::getAutoWhiteBalanceLock()
{
    Q_D(AndroidCamera);
    return d->getAutoWhiteBalanceLock();
}
 
void AndroidCamera::setAutoWhiteBalanceLock(bool toggle)
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "setAutoWhiteBalanceLock", Q_ARG(bool, toggle));
}
 
int AndroidCamera::getExposureCompensation()
{
    Q_D(AndroidCamera);
    return d->getExposureCompensation();
}
 
void AndroidCamera::setExposureCompensation(int value)
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "setExposureCompensation", Q_ARG(int, value));
}
 
float AndroidCamera::getExposureCompensationStep()
{
    Q_D(AndroidCamera);
    return d->getExposureCompensationStep();
}
 
int AndroidCamera::getMinExposureCompensation()
{
    Q_D(AndroidCamera);
    return d->getMinExposureCompensation();
}
 
int AndroidCamera::getMaxExposureCompensation()
{
    Q_D(AndroidCamera);
    return d->getMaxExposureCompensation();
}
 
QStringList AndroidCamera::getSupportedSceneModes()
{
    Q_D(AndroidCamera);
    return d->callParametersStringListMethod("getSupportedSceneModes");
}
 
QString AndroidCamera::getSceneMode()
{
    Q_D(AndroidCamera);
    return d->getSceneMode();
}
 
void AndroidCamera::setSceneMode(const QString &value)
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "setSceneMode", Q_ARG(QString, value));
}
 
QStringList AndroidCamera::getSupportedWhiteBalance()
{
    Q_D(AndroidCamera);
    return d->callParametersStringListMethod("getSupportedWhiteBalance");
}
 
QString AndroidCamera::getWhiteBalance()
{
    Q_D(AndroidCamera);
    return d->getWhiteBalance();
}
 
void AndroidCamera::setWhiteBalance(const QString &value)
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "setWhiteBalance", Q_ARG(QString, value));
}
 
void AndroidCamera::setRotation(int rotation)
{
    Q_D(AndroidCamera);
    //We need to do it here and not in worker class because we cache rotation
    d->m_parametersMutex.lock();
    bool areParametersValid = d->m_parameters.isValid();
    d->m_parametersMutex.unlock();
    if (!areParametersValid)
        return;
 
    d->m_rotation = rotation;
    QMetaObject::invokeMethod(d, "updateRotation");
}
 
int AndroidCamera::getRotation() const
{
    Q_D(const AndroidCamera);
    return d->m_rotation;
}
 
QList<QSize> AndroidCamera::getSupportedPictureSizes()
{
    Q_D(AndroidCamera);
    return d->getSupportedPictureSizes();
}
 
QList<QSize> AndroidCamera::getSupportedVideoSizes()
{
    Q_D(AndroidCamera);
    return d->getSupportedVideoSizes();
}
 
void AndroidCamera::setPictureSize(const QSize &size)
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "setPictureSize", Q_ARG(QSize, size));
}
 
void AndroidCamera::setJpegQuality(int quality)
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "setJpegQuality", Q_ARG(int, quality));
}
 
void AndroidCamera::takePicture()
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "takePicture", Qt::BlockingQueuedConnection);
}
 
void AndroidCamera::setupPreviewFrameCallback()
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "setupPreviewFrameCallback");
}
 
void AndroidCamera::notifyNewFrames(bool notify)
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "notifyNewFrames", Q_ARG(bool, notify));
}
 
void AndroidCamera::fetchLastPreviewFrame()
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "fetchLastPreviewFrame");
}
 
QJniObject AndroidCamera::getCameraObject()
{
    Q_D(AndroidCamera);
    return d->m_camera;
}
 
int AndroidCamera::getNumberOfCameras()
{
    if (!qt_androidCheckCameraPermission())
        return 0;
 
    return QJniObject::callStaticMethod<jint>("android/hardware/Camera",
                                                     "getNumberOfCameras");
}
 
void AndroidCamera::getCameraInfo(int id, QCameraDevicePrivate *info)
{
    Q_ASSERT(info);
 
    QJniObject cameraInfo("android/hardware/Camera$CameraInfo");
    QJniObject::callStaticMethod<void>("android/hardware/Camera",
                                              "getCameraInfo",
                                              "(ILandroid/hardware/Camera$CameraInfo;)V",
                                              id, cameraInfo.object());
 
    AndroidCamera::CameraFacing facing = AndroidCamera::CameraFacing(cameraInfo.getField<jint>("facing"));
    // The orientation provided by Android is counter-clockwise, we need it clockwise
    info->orientation = (360 - cameraInfo.getField<jint>("orientation")) % 360;
 
    switch (facing) {
    case AndroidCamera::CameraFacingBack:
        info->id = QByteArray("back");
        info->description = QStringLiteral("Rear-facing camera");
        info->position = QCameraDevice::BackFace;
        info->isDefault = true;
        break;
    case AndroidCamera::CameraFacingFront:
        info->id = QByteArray("front");
        info->description = QStringLiteral("Front-facing camera");
        info->position = QCameraDevice::FrontFace;
        break;
    default:
        break;
    }
    // Add a number to allow correct access to cameras on systems with two
    // (and more) front/back cameras
    if (id > 1) {
        info->id.append(QByteArray::number(id));
        info->description.append(QStringLiteral(" %1").arg(id));
    }
}
 
QVideoFrameFormat::PixelFormat AndroidCamera::QtPixelFormatFromAndroidImageFormat(AndroidCamera::ImageFormat format)
{
    switch (format) {
    case AndroidCamera::NV21:
        return QVideoFrameFormat::Format_NV21;
    case AndroidCamera::YUY2:
        return QVideoFrameFormat::Format_YUYV;
    case AndroidCamera::JPEG:
        return QVideoFrameFormat::Format_Jpeg;
    case AndroidCamera::YV12:
        return QVideoFrameFormat::Format_YV12;
    default:
        return QVideoFrameFormat::Format_Invalid;
    }
}
 
AndroidCamera::ImageFormat AndroidCamera::AndroidImageFormatFromQtPixelFormat(QVideoFrameFormat::PixelFormat format)
{
    switch (format) {
    case QVideoFrameFormat::Format_NV21:
        return AndroidCamera::NV21;
    case QVideoFrameFormat::Format_YUYV:
        return AndroidCamera::YUY2;
    case QVideoFrameFormat::Format_Jpeg:
        return AndroidCamera::JPEG;
    case QVideoFrameFormat::Format_YV12:
        return AndroidCamera::YV12;
    default:
        return AndroidCamera::UnknownImageFormat;
    }
}
 
QList<QCameraFormat> AndroidCamera::getSupportedFormats()
{
    QList<QCameraFormat> formats;
    AndroidCamera::FpsRange range = getPreviewFpsRange();
    for (const auto &previewSize : getSupportedVideoSizes()) {
        for (const auto &previewFormat : getSupportedPreviewFormats()) {
            QCameraFormatPrivate * format = new QCameraFormatPrivate();
            format->pixelFormat = QtPixelFormatFromAndroidImageFormat(previewFormat);
            format->resolution = previewSize;
            format->minFrameRate = range.min;
            format->maxFrameRate = range.max;
            formats.append(format->create());
        }
    }
 
    return formats;
}
 
void AndroidCamera::startPreview()
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "startPreview");
}
 
void AndroidCamera::stopPreview()
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "stopPreview");
}
 
void AndroidCamera::stopPreviewSynchronous()
{
    Q_D(AndroidCamera);
    QMetaObject::invokeMethod(d, "stopPreview", Qt::BlockingQueuedConnection);
}
 
QJniObject AndroidCamera::getParametersObject()
{
    Q_D(AndroidCamera);
    return d->m_parameters;
}
 
AndroidCameraPrivate::AndroidCameraPrivate()
    : QObject()
{
}
 
AndroidCameraPrivate::~AndroidCameraPrivate()
{
}
 
static qint32 s_activeCameras = 0;
 
bool AndroidCameraPrivate::init(int cameraId)
{
    m_cameraId = cameraId;
    QJniEnvironment env;
 
    const bool opened = s_activeCameras & (1 << cameraId);
    if (opened)
        return false;
 
    m_camera = QJniObject::callStaticObjectMethod("android/hardware/Camera",
                                                  "open",
                                                  "(I)Landroid/hardware/Camera;",
                                                  cameraId);
    if (!m_camera.isValid())
        return false;
 
    m_cameraListener = QJniObject(QtCameraListenerClassName, "(I)V", m_cameraId);
    m_info = QJniObject("android/hardware/Camera$CameraInfo");
    m_camera.callStaticMethod<void>("android/hardware/Camera",
                                    "getCameraInfo",
                                    "(ILandroid/hardware/Camera$CameraInfo;)V",
                                    cameraId,
                                    m_info.object());
 
    QJniObject params = m_camera.callObjectMethod("getParameters",
                                                         "()Landroid/hardware/Camera$Parameters;");
    m_parameters = QJniObject(params);
    s_activeCameras |= 1 << cameraId;
 
    return true;
}
 
void AndroidCameraPrivate::release()
{
    m_previewSize = QSize();
    m_parametersMutex.lock();
    m_parameters = QJniObject();
    m_parametersMutex.unlock();
    if (m_camera.isValid()) {
        m_camera.callMethod<void>("release");
        s_activeCameras &= ~(1 << m_cameraId);
    }
}
 
bool AndroidCameraPrivate::lock()
{
    QJniEnvironment env;
    auto methodId = env->GetMethodID(m_camera.objectClass(), "lock", "()V");
    env->CallVoidMethod(m_camera.object(), methodId);
 
    if (env.checkAndClearExceptions())
        return false;
    return true;
}
 
bool AndroidCameraPrivate::unlock()
{
    QJniEnvironment env;
    auto methodId = env->GetMethodID(m_camera.objectClass(), "unlock", "()V");
    env->CallVoidMethod(m_camera.object(), methodId);
 
    if (env.checkAndClearExceptions())
        return false;
    return true;
}
 
bool AndroidCameraPrivate::reconnect()
{
    QJniEnvironment env;
    auto methodId = env->GetMethodID(m_camera.objectClass(), "reconnect", "()V");
    env->CallVoidMethod(m_camera.object(), methodId);
 
    if (env.checkAndClearExceptions())
        return false;
    return true;
}
 
AndroidCamera::CameraFacing AndroidCameraPrivate::getFacing()
{
    return AndroidCamera::CameraFacing(m_info.getField<jint>("facing"));
}
 
int AndroidCameraPrivate::getNativeOrientation()
{
    return m_info.getField<jint>("orientation");
}
 
QSize AndroidCameraPrivate::getPreferredPreviewSizeForVideo()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return QSize();
 
    QJniObject size = m_parameters.callObjectMethod("getPreferredPreviewSizeForVideo",
                                                    "()Landroid/hardware/Camera$Size;");
 
    if (!size.isValid())
        return QSize();
 
    return QSize(size.getField<jint>("width"), size.getField<jint>("height"));
}
 
QList<QSize> AndroidCameraPrivate::getSupportedPreviewSizes()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
    return getSupportedPreviewSizes(m_parameters);
}
 
QList<QSize> AndroidCameraPrivate::getSupportedPreviewSizes(QJniObject &parameters)
{
    QList<QSize> list;
 
    if (parameters.isValid()) {
        QJniObject sizeList = parameters.callObjectMethod("getSupportedPreviewSizes",
                                                            "()Ljava/util/List;");
        int count = sizeList.callMethod<jint>("size");
        for (int i = 0; i < count; ++i) {
            QJniObject size = sizeList.callObjectMethod("get",
                                                        "(I)Ljava/lang/Object;",
                                                        i);
            list.append(QSize(size.getField<jint>("width"), size.getField<jint>("height")));
        }
 
        std::sort(list.begin(), list.end(), qt_sizeLessThan);
    }
 
    return list;
}
 
QList<AndroidCamera::FpsRange> AndroidCameraPrivate::getSupportedPreviewFpsRange()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    QJniEnvironment env;
 
    QList<AndroidCamera::FpsRange> rangeList;
 
    if (m_parameters.isValid()) {
        QJniObject rangeListNative = m_parameters.callObjectMethod("getSupportedPreviewFpsRange",
                                                                   "()Ljava/util/List;");
        int count = rangeListNative.callMethod<jint>("size");
 
        rangeList.reserve(count);
 
        for (int i = 0; i < count; ++i) {
            QJniObject range = rangeListNative.callObjectMethod("get",
                                                                "(I)Ljava/lang/Object;",
                                                                i);
 
            jintArray jRange = static_cast<jintArray>(range.object());
            jint* rangeArray = env->GetIntArrayElements(jRange, 0);
 
            AndroidCamera::FpsRange fpsRange;
 
            fpsRange.min = rangeArray[0];
            fpsRange.max = rangeArray[1];
 
            env->ReleaseIntArrayElements(jRange, rangeArray, 0);
 
            rangeList << fpsRange;
        }
    }
 
    return rangeList;
}
 
AndroidCamera::FpsRange AndroidCameraPrivate::getPreviewFpsRange()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
    return getPreviewFpsRange(m_parameters);
}
 
AndroidCamera::FpsRange AndroidCameraPrivate::getPreviewFpsRange(QJniObject &parameters)
{
    QJniEnvironment env;
 
    AndroidCamera::FpsRange range;
 
    if (!parameters.isValid())
        return range;
 
    jintArray jRangeArray = env->NewIntArray(2);
    parameters.callMethod<void>("getPreviewFpsRange", "([I)V", jRangeArray);
 
    jint* jRangeElements = env->GetIntArrayElements(jRangeArray, 0);
 
    // Android Camera API returns values scaled by 1000, so divide here to report
    // normal values for Qt
    range.min = jRangeElements[0] / 1000;
    range.max = jRangeElements[1] / 1000;
 
    env->ReleaseIntArrayElements(jRangeArray, jRangeElements, 0);
    env->DeleteLocalRef(jRangeArray);
 
    return range;
}
 
void AndroidCameraPrivate::setPreviewFpsRange(int min, int max)
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return;
 
    // Android Camera API returns values scaled by 1000, so multiply here to
    // give Android API the scale is expects
    m_parameters.callMethod<void>("setPreviewFpsRange", "(II)V", min * 1000, max * 1000);
}
 
AndroidCamera::ImageFormat AndroidCameraPrivate::getPreviewFormat()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return AndroidCamera::UnknownImageFormat;
 
    return AndroidCamera::ImageFormat(m_parameters.callMethod<jint>("getPreviewFormat"));
}
 
void AndroidCameraPrivate::setPreviewFormat(AndroidCamera::ImageFormat fmt)
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return;
 
    m_parameters.callMethod<void>("setPreviewFormat", "(I)V", jint(fmt));
    applyParameters();
}
 
QList<AndroidCamera::ImageFormat> AndroidCameraPrivate::getSupportedPreviewFormats()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
    return getSupportedPreviewFormats(m_parameters);
}
 
QList<AndroidCamera::ImageFormat> AndroidCameraPrivate::getSupportedPreviewFormats(QJniObject &parameters)
{
    QList<AndroidCamera::ImageFormat> list;
 
    if (parameters.isValid()) {
        QJniObject formatList = parameters.callObjectMethod("getSupportedPreviewFormats",
                                                              "()Ljava/util/List;");
        int count = formatList.callMethod<jint>("size");
        for (int i = 0; i < count; ++i) {
            QJniObject format = formatList.callObjectMethod("get",
                                                            "(I)Ljava/lang/Object;",
                                                            i);
            list.append(AndroidCamera::ImageFormat(format.callMethod<jint>("intValue")));
        }
    }
 
    return list;
}
 
QSize AndroidCameraPrivate::getPreviewSize()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return QSize();
 
    QJniObject size = m_parameters.callObjectMethod("getPreviewSize",
                                                           "()Landroid/hardware/Camera$Size;");
 
    if (!size.isValid())
        return QSize();
 
    return QSize(size.getField<jint>("width"), size.getField<jint>("height"));
}
 
void AndroidCameraPrivate::updatePreviewSize()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (m_previewSize.isValid()) {
        m_parameters.callMethod<void>("setPreviewSize", "(II)V", m_previewSize.width(), m_previewSize.height());
        applyParameters();
    }
 
    emit previewSizeChanged();
}
 
bool AndroidCameraPrivate::setPreviewTexture(void *surfaceTexture)
{
    QJniEnvironment env;
    auto methodId = env->GetMethodID(m_camera.objectClass(), "setPreviewTexture",
                                     "(Landroid/graphics/SurfaceTexture;)V");
    env->CallVoidMethod(m_camera.object(), methodId, static_cast<jobject>(surfaceTexture));
 
    if (env.checkAndClearExceptions())
        return false;
    return true;
}
 
bool AndroidCameraPrivate::setPreviewDisplay(void *surfaceHolder)
{
    QJniEnvironment env;
    auto methodId = env->GetMethodID(m_camera.objectClass(), "setPreviewDisplay",
                                     "(Landroid/view/SurfaceHolder;)V");
    env->CallVoidMethod(m_camera.object(), methodId, static_cast<jobject>(surfaceHolder));
 
    if (env.checkAndClearExceptions())
        return false;
    return true;
}
 
void AndroidCameraPrivate::setDisplayOrientation(int degrees)
{
    m_camera.callMethod<void>("setDisplayOrientation", "(I)V", degrees);
    m_cameraListener.callMethod<void>("setPhotoRotation", "(I)V", degrees);
}
 
bool AndroidCameraPrivate::isZoomSupported()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return false;
 
    return m_parameters.callMethod<jboolean>("isZoomSupported");
}
 
int AndroidCameraPrivate::getMaxZoom()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return 0;
 
    return m_parameters.callMethod<jint>("getMaxZoom");
}
 
QList<int> AndroidCameraPrivate::getZoomRatios()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    QList<int> ratios;
 
    if (m_parameters.isValid()) {
        QJniObject ratioList = m_parameters.callObjectMethod("getZoomRatios",
                                                                    "()Ljava/util/List;");
        int count = ratioList.callMethod<jint>("size");
        for (int i = 0; i < count; ++i) {
            QJniObject zoomRatio = ratioList.callObjectMethod("get",
                                                                     "(I)Ljava/lang/Object;",
                                                                     i);
 
            ratios.append(zoomRatio.callMethod<jint>("intValue"));
        }
    }
 
    return ratios;
}
 
int AndroidCameraPrivate::getZoom()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return 0;
 
    return m_parameters.callMethod<jint>("getZoom");
}
 
void AndroidCameraPrivate::setZoom(int value)
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return;
 
    m_parameters.callMethod<void>("setZoom", "(I)V", value);
    applyParameters();
}
 
QString AndroidCameraPrivate::getFlashMode()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    QString value;
 
    if (m_parameters.isValid()) {
        QJniObject flashMode = m_parameters.callObjectMethod("getFlashMode",
                                                             "()Ljava/lang/String;");
        if (flashMode.isValid())
            value = flashMode.toString();
    }
 
    return value;
}
 
void AndroidCameraPrivate::setFlashMode(const QString &value)
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return;
 
    m_parameters.callMethod<void>("setFlashMode",
                                  "(Ljava/lang/String;)V",
                                  QJniObject::fromString(value).object());
    applyParameters();
}
 
QString AndroidCameraPrivate::getFocusMode()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    QString value;
 
    if (m_parameters.isValid()) {
        QJniObject focusMode = m_parameters.callObjectMethod("getFocusMode",
                                                             "()Ljava/lang/String;");
        if (focusMode.isValid())
            value = focusMode.toString();
    }
 
    return value;
}
 
void AndroidCameraPrivate::setFocusMode(const QString &value)
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return;
 
    m_parameters.callMethod<void>("setFocusMode",
                                  "(Ljava/lang/String;)V",
                                  QJniObject::fromString(value).object());
    applyParameters();
}
 
int AndroidCameraPrivate::getMaxNumFocusAreas()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return 0;
 
    return m_parameters.callMethod<jint>("getMaxNumFocusAreas");
}
 
QList<QRect> AndroidCameraPrivate::getFocusAreas()
{
    QList<QRect> areas;
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (m_parameters.isValid()) {
        QJniObject list = m_parameters.callObjectMethod("getFocusAreas",
                                                        "()Ljava/util/List;");
 
        if (list.isValid()) {
            int count = list.callMethod<jint>("size");
            for (int i = 0; i < count; ++i) {
                QJniObject area = list.callObjectMethod("get",
                                                        "(I)Ljava/lang/Object;",
                                                        i);
 
                areas.append(areaToRect(area.object()));
            }
        }
    }
 
    return areas;
}
 
void AndroidCameraPrivate::setFocusAreas(const QList<QRect> &areas)
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid() || areas.isEmpty())
        return;
 
    QJniObject list;
 
    if (!areas.isEmpty()) {
        QJniEnvironment env;
        QJniObject arrayList("java/util/ArrayList", "(I)V", areas.size());
        for (int i = 0; i < areas.size(); ++i) {
            arrayList.callMethod<jboolean>("add",
                                           "(Ljava/lang/Object;)Z",
                                           rectToArea(areas.at(i)).object());
        }
        list = arrayList;
    }
 
    m_parameters.callMethod<void>("setFocusAreas", "(Ljava/util/List;)V", list.object());
 
    applyParameters();
}
 
void AndroidCameraPrivate::autoFocus()
{
    QJniEnvironment env;
    auto methodId = env->GetMethodID(m_camera.objectClass(), "autoFocus",
                                     "(Landroid/hardware/Camera$AutoFocusCallback;)V");
    env->CallVoidMethod(m_camera.object(), methodId, m_cameraListener.object());
 
    if (!env.checkAndClearExceptions())
        emit autoFocusStarted();
}
 
void AndroidCameraPrivate::cancelAutoFocus()
{
    QJniEnvironment env;
    m_camera.callMethod<void>("cancelAutoFocus");
}
 
bool AndroidCameraPrivate::isAutoExposureLockSupported()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return false;
 
    return m_parameters.callMethod<jboolean>("isAutoExposureLockSupported");
}
 
bool AndroidCameraPrivate::getAutoExposureLock()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return false;
 
    return m_parameters.callMethod<jboolean>("getAutoExposureLock");
}
 
void AndroidCameraPrivate::setAutoExposureLock(bool toggle)
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return;
 
    m_parameters.callMethod<void>("setAutoExposureLock", "(Z)V", toggle);
    applyParameters();
}
 
bool AndroidCameraPrivate::isAutoWhiteBalanceLockSupported()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return false;
 
    return m_parameters.callMethod<jboolean>("isAutoWhiteBalanceLockSupported");
}
 
bool AndroidCameraPrivate::getAutoWhiteBalanceLock()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return false;
 
    return m_parameters.callMethod<jboolean>("getAutoWhiteBalanceLock");
}
 
void AndroidCameraPrivate::setAutoWhiteBalanceLock(bool toggle)
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return;
 
    m_parameters.callMethod<void>("setAutoWhiteBalanceLock", "(Z)V", toggle);
    applyParameters();
}
 
int AndroidCameraPrivate::getExposureCompensation()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return 0;
 
    return m_parameters.callMethod<jint>("getExposureCompensation");
}
 
void AndroidCameraPrivate::setExposureCompensation(int value)
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return;
 
    m_parameters.callMethod<void>("setExposureCompensation", "(I)V", value);
    applyParameters();
}
 
float AndroidCameraPrivate::getExposureCompensationStep()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return 0;
 
    return m_parameters.callMethod<jfloat>("getExposureCompensationStep");
}
 
int AndroidCameraPrivate::getMinExposureCompensation()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return 0;
 
    return m_parameters.callMethod<jint>("getMinExposureCompensation");
}
 
int AndroidCameraPrivate::getMaxExposureCompensation()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return 0;
 
    return m_parameters.callMethod<jint>("getMaxExposureCompensation");
}
 
QString AndroidCameraPrivate::getSceneMode()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    QString value;
 
    if (m_parameters.isValid()) {
        QJniObject sceneMode = m_parameters.callObjectMethod("getSceneMode",
                                                             "()Ljava/lang/String;");
        if (sceneMode.isValid())
            value = sceneMode.toString();
    }
 
    return value;
}
 
void AndroidCameraPrivate::setSceneMode(const QString &value)
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return;
 
    m_parameters.callMethod<void>("setSceneMode",
                                  "(Ljava/lang/String;)V",
                                  QJniObject::fromString(value).object());
    applyParameters();
}
 
QString AndroidCameraPrivate::getWhiteBalance()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    QString value;
 
    if (m_parameters.isValid()) {
        QJniObject wb = m_parameters.callObjectMethod("getWhiteBalance",
                                                      "()Ljava/lang/String;");
        if (wb.isValid())
            value = wb.toString();
    }
 
    return value;
}
 
void AndroidCameraPrivate::setWhiteBalance(const QString &value)
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return;
 
    m_parameters.callMethod<void>("setWhiteBalance",
                                  "(Ljava/lang/String;)V",
                                  QJniObject::fromString(value).object());
    applyParameters();
 
    emit whiteBalanceChanged();
}
 
void AndroidCameraPrivate::updateRotation()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    m_parameters.callMethod<void>("setRotation", "(I)V", m_rotation);
    applyParameters();
}
 
QList<QSize> AndroidCameraPrivate::getSupportedPictureSizes()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    QList<QSize> list;
 
    if (m_parameters.isValid()) {
        QJniObject sizeList = m_parameters.callObjectMethod("getSupportedPictureSizes",
                                                            "()Ljava/util/List;");
        int count = sizeList.callMethod<jint>("size");
        for (int i = 0; i < count; ++i) {
            QJniObject size = sizeList.callObjectMethod("get",
                                                        "(I)Ljava/lang/Object;",
                                                        i);
            list.append(QSize(size.getField<jint>("width"), size.getField<jint>("height")));
        }
 
        std::sort(list.begin(), list.end(), qt_sizeLessThan);
    }
 
    return list;
}
 
QList<QSize> AndroidCameraPrivate::getSupportedVideoSizes()
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
    QList<QSize> list;
 
    if (m_parameters.isValid()) {
        QJniObject sizeList = m_parameters.callObjectMethod("getSupportedVideoSizes",
                                                            "()Ljava/util/List;");
        if (!sizeList.isValid())
            return list;
 
        int count = sizeList.callMethod<jint>("size");
        for (int i = 0; i < count; ++i) {
            const QJniObject size = sizeList.callObjectMethod("get", "(I)Ljava/lang/Object;", i);
            if (size.isValid())
                list.append(QSize(size.getField<jint>("width"), size.getField<jint>("height")));
        }
        std::sort(list.begin(), list.end(), qt_sizeLessThan);
    }
 
    return list;
}
 
void AndroidCameraPrivate::setPictureSize(const QSize &size)
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return;
 
    m_parameters.callMethod<void>("setPictureSize", "(II)V", size.width(), size.height());
    applyParameters();
}
 
void AndroidCameraPrivate::setJpegQuality(int quality)
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    if (!m_parameters.isValid())
        return;
 
    m_parameters.callMethod<void>("setJpegQuality", "(I)V", quality);
    applyParameters();
}
 
void AndroidCameraPrivate::startPreview()
{
    setupPreviewFrameCallback();
 
    QJniEnvironment env;
    auto methodId = env->GetMethodID(m_camera.objectClass(), "startPreview", "()V");
    env->CallVoidMethod(m_camera.object(), methodId);
 
    if (env.checkAndClearExceptions())
        emit previewFailedToStart();
    else
        emit previewStarted();
}
 
void AndroidCameraPrivate::stopPreview()
{
    // cancel any pending new frame notification
    m_cameraListener.callMethod<void>("notifyWhenFrameAvailable", "(Z)V", false);
    m_camera.callMethod<void>("stopPreview");
    emit previewStopped();
}
 
void AndroidCameraPrivate::takePicture()
{
    // We must clear the preview callback before calling takePicture(), otherwise the call will
    // block and the camera server will be frozen until the next device restart...
    // That problem only happens on some devices and on the emulator
    m_cameraListener.callMethod<void>("clearPreviewCallback", "(Landroid/hardware/Camera;)V", m_camera.object());
 
    QJniEnvironment env;
    auto methodId = env->GetMethodID(m_camera.objectClass(), "takePicture",
                                     "(Landroid/hardware/Camera$ShutterCallback;"
                                     "Landroid/hardware/Camera$PictureCallback;"
                                     "Landroid/hardware/Camera$PictureCallback;)V");
    env->CallVoidMethod(m_camera.object(), methodId, m_cameraListener.object(),
                        jobject(0), m_cameraListener.object());
 
    if (env.checkAndClearExceptions())
        emit takePictureFailed();
}
 
void AndroidCameraPrivate::setupPreviewFrameCallback()
{
    m_cameraListener.callMethod<void>("setupPreviewCallback", "(Landroid/hardware/Camera;)V", m_camera.object());
}
 
void AndroidCameraPrivate::notifyNewFrames(bool notify)
{
    m_cameraListener.callMethod<void>("notifyNewFrames", "(Z)V", notify);
}
 
void AndroidCameraPrivate::fetchLastPreviewFrame()
{
    QJniEnvironment env;
    QJniObject data = m_cameraListener.callObjectMethod("lastPreviewBuffer", "()[B");
 
    if (!data.isValid()) {
        // If there's no buffer received yet, retry when the next one arrives
        m_cameraListener.callMethod<void>("notifyWhenFrameAvailable", "(Z)V", true);
        return;
    }
 
    const int arrayLength = env->GetArrayLength(static_cast<jbyteArray>(data.object()));
    if (arrayLength == 0)
        return;
 
    QByteArray bytes(arrayLength, Qt::Uninitialized);
    env->GetByteArrayRegion(static_cast<jbyteArray>(data.object()),
                            0,
                            arrayLength,
                            reinterpret_cast<jbyte *>(bytes.data()));
 
    const int width = m_cameraListener.callMethod<jint>("previewWidth");
    const int height = m_cameraListener.callMethod<jint>("previewHeight");
    const int format = m_cameraListener.callMethod<jint>("previewFormat");
    const int bpl = m_cameraListener.callMethod<jint>("previewBytesPerLine");
 
    QVideoFrameFormat frameFormat(
            QSize(width, height),
            qt_pixelFormatFromAndroidImageFormat(AndroidCamera::ImageFormat(format)));
 
    QVideoFrame frame = QVideoFramePrivate::createFrame(
            std::make_unique<QMemoryVideoBuffer>(std::move(bytes), bpl), std::move(frameFormat));
 
    emit lastPreviewFrameFetched(frame);
}
 
void AndroidCameraPrivate::applyParameters()
{
    QJniEnvironment env;
    m_camera.callMethod<void>("setParameters",
                              "(Landroid/hardware/Camera$Parameters;)V",
                              m_parameters.object());
}
 
QStringList AndroidCameraPrivate::callParametersStringListMethod(const QByteArray &methodName)
{
    const std::lock_guard<QRecursiveMutex> locker(m_parametersMutex);
 
    QStringList stringList;
 
    if (m_parameters.isValid()) {
        QJniObject list = m_parameters.callObjectMethod(methodName.constData(),
                                                        "()Ljava/util/List;");
 
        if (list.isValid()) {
            int count = list.callMethod<jint>("size");
            for (int i = 0; i < count; ++i) {
                QJniObject string = list.callObjectMethod("get",
                                                          "(I)Ljava/lang/Object;",
                                                          i);
                stringList.append(string.toString());
            }
        }
    }
 
    return stringList;
}
 
bool AndroidCamera::registerNativeMethods()
{
    static const JNINativeMethod methods[] = {
        {"notifyAutoFocusComplete", "(IZ)V", (void *)notifyAutoFocusComplete},
        {"notifyPictureExposed", "(I)V", (void *)notifyPictureExposed},
        {"notifyPictureCaptured", "(I[B)V", (void *)notifyPictureCaptured},
        {"notifyNewPreviewFrame", "(I[BIIII)V", (void *)notifyNewPreviewFrame},
        {"notifyFrameAvailable", "(I)V", (void *)notifyFrameAvailable}
    };
 
    const int size = std::size(methods);
    return QJniEnvironment().registerNativeMethods(QtCameraListenerClassName, methods, size);
}
 
QT_END_NAMESPACE
 
#include "androidcamera.moc"
#include "moc_androidcamera_p.cpp"