Revision control
Copy as Markdown
// Copyright (C) 2024 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include <QtFFmpegMediaPluginImpl/private/qandroidscreencapture_p.h>
#include <QtCore/private/qjnihelpers_p.h>
#include <QtCore/qreadwritelock.h>
#include <QtMultimedia/private/qsurfacecapturegrabber_p.h>
#include <QtFFmpegMediaPluginImpl/private/qandroidvideoframefactory_p.h>
#include <QtFFmpegMediaPluginImpl/private/qffmpegvideobuffer_p.h>
QT_BEGIN_NAMESPACE
Q_DECLARE_JNI_CLASS(QtScreenGrabber,
"org/qtproject/qt/android/multimedia/qffmpeg/QtScreenGrabber")
Q_DECLARE_JNI_CLASS(QtScreenCaptureService,
"org/qtproject/qt/android/multimedia/qffmpeg/QtScreenCaptureService")
Q_DECLARE_JNI_CLASS(Size, "android/util/Size")
namespace {
QAtomicInteger<int> idCounter = 0;
constexpr int REQUEST_CODE_MEDIA_PROJECTION = 24680; // Arbitrary
constexpr int RESULT_CANCEL = 0;
constexpr int RESULT_OK = -1;
}
class QAndroidScreenCapture::Grabber : public QtAndroidPrivate::ActivityResultListener,
public QSurfaceCaptureGrabber
{
public:
Grabber(QAndroidScreenCapture & screenCapture)
: m_activityRequestCode(REQUEST_CODE_MEDIA_PROJECTION + idCounter.fetchAndAddRelaxed(1))
, m_screenCapture(screenCapture)
{
injectContextToGrabbingThread(&m_resourceContext);
addFrameCallback(&screenCapture, &QAndroidScreenCapture::newVideoFrame);
using namespace QtJniTypes;
const auto sizeObj = QtScreenGrabber::callStaticMethod<Size>(
"getScreenCaptureSize", QtAndroidPrivate::activity());
const QSize size = QSize(sizeObj.callMethod<int>("getWidth"),
sizeObj.callMethod<int>("getHeight"));
m_format = QVideoFrameFormat(size, QVideoFrameFormat::Format_RGBA8888);
if (m_format.frameHeight() > 0 && m_format.frameWidth() > 0) {
QtAndroidPrivate::registerActivityResultListener(this);
m_jniGrabber = QtScreenGrabber(QtAndroidPrivate::activity(), m_activityRequestCode);
} else {
updateError(QStringLiteral("Invalid Screen size: %1x%2. Screen capture not started")
.arg(m_format.frameHeight())
.arg(m_format.frameWidth()));
}
setFrameRate(screenCapture.frameRate().value_or(DefaultScreenCaptureFrameRate));
m_format.setStreamFrameRate(frameRate());
}
QVideoFrame grabFrame() override
{
return m_resourceContext.latestFrame();
}
bool handleActivityResult(jint requestCode, jint resultCode, jobject data) override
{
if (requestCode != m_activityRequestCode || m_jniGrabber == nullptr)
return false;
if (resultCode == RESULT_OK) {
const QtJniTypes::Intent intent(data);
const bool screenCaptureServiceStarted = m_jniGrabber.callMethod<bool>(
"startScreenCaptureService",
resultCode,
reinterpret_cast<jlong>(&m_screenCapture),
m_format.frameWidth(),
m_format.frameHeight(),
intent);
if (!screenCaptureServiceStarted)
updateError(QStringLiteral("Cannot start screen capture service"));
} else if (resultCode == RESULT_CANCEL) {
updateError(QStringLiteral("Screen capture canceled"));
}
return true;
}
~Grabber() override
{
stop();
QtAndroidPrivate::unregisterActivityResultListener(this);
m_jniGrabber.callMethod<bool>("stopScreenCaptureService");
}
QVideoFrameFormat format() const { return m_format; }
void onNewFrameReceived(QtJniTypes::Image image)
{
QMetaObject::invokeMethod(&m_resourceContext, &ResourceContext::updateLatestImageRef,
image);
}
private:
void updateError(const QString &errorString)
{
QMetaObject::invokeMethod(&m_screenCapture,
&QPlatformSurfaceCapture::updateError,
Qt::QueuedConnection,
QPlatformSurfaceCapture::Error::InternalError,
errorString);
}
QtJniTypes::QtScreenGrabber m_jniGrabber;
const int m_activityRequestCode;
QAndroidScreenCapture & m_screenCapture;
QVideoFrameFormat m_format;
class ResourceContext : public QObject
{
public:
ResourceContext() : m_frameFactory(QAndroidVideoFrameFactory::create()) { }
~ResourceContext() override { updateLatestImageRef({ }); }
Q_DISABLE_COPY_MOVE(ResourceContext)
void updateLatestImageRef(QJniObject newImage)
{
auto oldImage = std::exchange(m_latestImage, newImage);
if (oldImage.isValid())
oldImage.callMethod<void>("close");
}
QVideoFrame latestFrame()
{
Q_ASSERT(m_frameFactory);
return m_latestImage.isValid()
? m_frameFactory->createVideoFrame(std::move(m_latestImage))
: QVideoFrame();
}
private:
QJniObject m_latestImage;
std::shared_ptr<QAndroidVideoFrameFactory> m_frameFactory;
} m_resourceContext;
};
QAndroidScreenCapture::QAndroidScreenCapture()
: QPlatformSurfaceCapture(ScreenSource{})
{
}
QAndroidScreenCapture::~QAndroidScreenCapture()
{
}
QVideoFrameFormat QAndroidScreenCapture::frameFormat() const
{
return m_grabber ? m_grabber->format() : QVideoFrameFormat();
}
bool QAndroidScreenCapture::setActiveInternal(bool active)
{
if (active == static_cast<bool>(m_grabber))
return true;
if (m_grabber) {
m_grabber.reset();
} else {
m_grabber = std::make_unique<Grabber>(*this);
m_grabber->start();
}
return bool(m_grabber) == active;
}
void QAndroidScreenCapture::onNewFrameReceived(QtJniTypes::Image image)
{
if (m_grabber)
m_grabber->onNewFrameReceived(image);
else if (image.isValid())
image.callMethod<void>("close");
}
static void onScreenFrameAvailable(JNIEnv *env, jobject obj, QtJniTypes::Image image, jlong id)
{
Q_UNUSED(env);
Q_UNUSED(obj);
auto *cppObj = reinterpret_cast<QAndroidScreenCapture*>(id);
cppObj->onNewFrameReceived(image);
}
Q_DECLARE_JNI_NATIVE_METHOD(onScreenFrameAvailable)
static void onErrorUpdate(JNIEnv *env, jobject obj, QString errorString, jlong id)
{
Q_UNUSED(env);
Q_UNUSED(obj);
auto cppObj = reinterpret_cast<QAndroidScreenCapture*>(id);
QMetaObject::invokeMethod(cppObj,
&QPlatformSurfaceCapture::updateError,
Qt::QueuedConnection,
QPlatformSurfaceCapture::Error::InternalError,
errorString);
}
Q_DECLARE_JNI_NATIVE_METHOD(onErrorUpdate)
bool QAndroidScreenCapture::registerNativeMethods()
{
using namespace QtJniTypes;
static const bool registered = []() {
return QtScreenCaptureService::registerNativeMethods(
{ Q_JNI_NATIVE_METHOD(onScreenFrameAvailable),
Q_JNI_NATIVE_METHOD(onErrorUpdate)});
}();
return registered;
}
QT_END_NAMESPACE