Revision control
++ // 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