Revision control
Copy as Markdown
// 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 <QtMultimedia/private/qmultimedia_ranges_p.h>
#include <QtCore/qcoreapplication.h>
#include <mutex>
QT_BEGIN_NAMESPACE
namespace ranges = QtMultimediaPrivate::ranges;
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);
Q_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 ¶meters);
Q_INVOKABLE QList<AndroidCamera::FpsRange> getSupportedPreviewFpsRange();
Q_INVOKABLE AndroidCamera::FpsRange getPreviewFpsRange();
static AndroidCamera::FpsRange getPreviewFpsRange(QJniObject ¶meters);
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 ¶meters);
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 ¶meters)
{
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")));
}
ranges::sort(list, 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 ¶meters)
{
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 ¶meters)
{
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();
}
Q_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())
Q_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();
Q_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")));
}
ranges::sort(list, 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")));
}
ranges::sort(list, 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())
Q_EMIT previewFailedToStart();
else
Q_EMIT previewStarted();
}
void AndroidCameraPrivate::stopPreview()
{
// cancel any pending new frame notification
m_cameraListener.callMethod<void>("notifyWhenFrameAvailable", "(Z)V", false);
m_camera.callMethod<void>("stopPreview");
Q_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())
Q_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));
Q_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"