qt/qtbase/src/plugins/platforms/ohos/render/qnativenode.cpp

Source code

Revision control

Copy as Markdown

// Copyright (C) 2025 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 <render/qnativenode.h>
#include <EGL/eglplatform.h>
#include <QtCore/private/qcore_ohos_p.h>
#include <QtCore/qpointer.h>
#include <qohosutils.h>
#include <QtGui/private/qguiapplication_p.h>
#include <QtGui/private/qohosimageconversions_p.h>
#include <QtGui/qguiapplication.h>
#include <ace/xcomponent/native_interface_xcomponent.h>
#include <arkui/native_node.h>
#include <arkui/native_type.h>
#include <arkui/ui_input_event.h>
#include <native_window/external_window.h>
#include <qarkui/qembeddedwindownode.h>
#include <qohosinputmethodeventhandler.h>
#include <qohosjsmain.h>
#include <qohosplatformintegration.h>
#include <qohosplatformwindow.h>
#include <qohosudmf.h>
#include <qohosudmfconversions.h>
#include <qpa/qwindowsysteminterface.h>
#include <render/qohosarkuinativegestureshandler.h>
#include <render/qohosdrageventutils.h>
#include <render/qohosnativeaxiseventhandler.h>
#include <render/qohosnativedrageventshandler.h>
#include <render/qohosnativekeyeventshandler.h>
#include <render/qohosnativemouseeventshandler.h>
#include <render/qohosnativexcomponentinputhandler.h>
#include <render/qohosview.h>
#include <render/qxcomponent.h>
#include <algorithm>
#include <cstdint>
#include <functional>
#include <iterator>
QT_BEGIN_NAMESPACE
namespace {
using InputEventType = QArkUi::QXComponentCallbackReceiver::InputEventType;
using SurfaceEventType = QArkUi::QXComponentCallbackReceiver::SurfaceEventType;
class CallbackReceiver final : public QArkUi::QXComponentCallbackReceiver
{
public:
explicit CallbackReceiver(
QXComponentRender xComponent,
QtOhos::QThreadSafeRef<QWindow> windowRef,
QtOhos::QThreadSafeRef<QOhosInputMethodEventHandler> imEventHandlerRef,
std::function<void(SurfaceEventType, ::OHNativeWindow *, std::optional<QSize>)> surfaceEventHandler);
void onSurfaceEvent(SurfaceEventType surfaceEventType, ::OHNativeWindow *nativeWindow) override;
void onInputEvent(InputEventType inputEventType, ::OHNativeWindow *window) override;
void onHoverEvent(bool isHover) override;
~CallbackReceiver() override = default;
private:
std::optional<void *> m_lastWindowArgReceivedViaAnyCallback;
std::function<void(SurfaceEventType, ::OHNativeWindow *, std::optional<QSize>)> m_surfaceEventHandler;
QSharedPointer<QOhosNativeXComponentInputHandler> m_xComponentInputHandler;
};
CallbackReceiver::CallbackReceiver(
QXComponentRender xComponent,
QtOhos::QThreadSafeRef<QWindow> windowRef,
QtOhos::QThreadSafeRef<QOhosInputMethodEventHandler> imEventHandlerRef,
std::function<void(SurfaceEventType, ::OHNativeWindow *, std::optional<QSize>)> surfaceEventHandler)
: m_lastWindowArgReceivedViaAnyCallback()
, m_surfaceEventHandler(std::move(surfaceEventHandler))
, m_xComponentInputHandler(
QSharedPointer<QOhosNativeXComponentInputHandler>::create(
xComponent, windowRef, imEventHandlerRef))
{
}
void CallbackReceiver::onSurfaceEvent(SurfaceEventType surfaceEventType, ::OHNativeWindow *nativeWindow)
{
m_lastWindowArgReceivedViaAnyCallback = nativeWindow;
m_surfaceEventHandler(surfaceEventType, nativeWindow, QOhosSurface::tryGetBufferGeometryForWindow(nativeWindow));
}
void CallbackReceiver::onInputEvent(InputEventType inputEventType, ::OHNativeWindow *window)
{
m_lastWindowArgReceivedViaAnyCallback = window;
switch (inputEventType) {
case QArkUi::QXComponentCallbackReceiver::InputEventType::Mouse:
m_xComponentInputHandler->handleMouseEvent(window);
break;
case QArkUi::QXComponentCallbackReceiver::InputEventType::Touch:
m_xComponentInputHandler->handleTouchEvent(window);
break;
case QArkUi::QXComponentCallbackReceiver::InputEventType::Keyboard:
m_xComponentInputHandler->handleKeyEvent();
break;
}
}
void CallbackReceiver::onHoverEvent(bool isHover)
{
if (!m_lastWindowArgReceivedViaAnyCallback.has_value()) {
qOhosPrintfWarning("Received hover event before without existing surface");
return;
}
m_xComponentInputHandler->handleHoverEvent(m_lastWindowArgReceivedViaAnyCallback.value(), isHover);
}
}
QNativeNode::QNativeNode(const CreateInfo &nativeNodeCreateInfo)
: QObject()
{
auto qWindow = QPointer<QWindow>(nativeNodeCreateInfo.window);
auto selfRef = QtOhos::makeQThreadSafeRef(this);
auto windowId = QOhosPlatformWindow::fromQWindow(qWindow)->internalWindowId();
auto platformWindowFlags = QOhosPlatformWindow::platformWindowFlagsForQWindow(qWindow);
bool focusable = !platformWindowFlags.testFlag(Qt::WindowDoesNotAcceptFocus);
auto renderFit = nativeNodeCreateInfo.renderFitPolicyHint.value_or(::ARKUI_RENDER_FIT_TOP_LEFT);
connect(
qGuiApp, &QGuiApplication::focusWindowChanged,
this, [this, qWindow](QWindow *focusedWindow) {
if (focusedWindow == qWindow)
setFocused(true);
});
auto qWindowRef = QtOhos::makeQThreadSafeRef(qWindow.data());
auto *ohosPlatformIntegration = QOhosPlatformIntegration::instance();
auto *inputMethodEventHandler = ohosPlatformIntegration->inputMethodEventHandler();
if (inputMethodEventHandler == nullptr)
qOhosReportFatalErrorAndAbort("QOhosInputMethodEventHandler is null!");
auto imEventHandlerRef = QtOhos::makeQThreadSafeRef(inputMethodEventHandler);
QOhosJsThreadGateway::runAndWait([&](QOhosJsState &) {
using ParentDescriptor = QArkUi::QEmbeddedWindowNode::ParentDescriptor;
std::optional<ParentDescriptor> optParentDescriptor;
if (nativeNodeCreateInfo.optParent.has_value()) {
auto *parentNode = nativeNodeCreateInfo.optParent.value()->m_jsStateData->embeddedWindow.get();
optParentDescriptor = ParentDescriptor(*parentNode);
}
QArkUi::QQtEmbeddedWindowNode::CreateInfo createInfo = {
.offset = nativeNodeCreateInfo.geometry.topLeft(),
.size = nativeNodeCreateInfo.geometry.size(),
.xComponentId = QXComponentId::createForRenderXComponent(windowId),
.xComponentType = ::ArkUI_XComponentType::ARKUI_XCOMPONENT_TYPE_SURFACE,
.focusOnTouch = false,
.focusable = focusable,
.optParent = optParentDescriptor,
.sizePolicy = QArkUi::QEmbeddedWindowNode::SizePolicy::Points,
.renderFit = renderFit,
.backgroundColor = nativeNodeCreateInfo.backgroundColor,
};
m_jsStateData->embeddedWindow = QArkUi::QQtEmbeddedWindowNode::createOrFail(createInfo);
m_jsStateData->embeddedWindow->setCallbackReceiver(
std::make_unique<CallbackReceiver>(
m_jsStateData->embeddedWindow->renderXComponent(),
qWindowRef, imEventHandlerRef,
[selfRef](SurfaceEventType type, ::OHNativeWindow *window, std::optional<QSize> optSurfaceSize) {
selfRef.visitInQtThreadIfAlive(
[type, window, optSurfaceSize](auto &self) {
self.handleSurfaceEvent(type, window, optSurfaceSize);
});
}));
m_jsStateData->embeddedWindow->setTouchInterceptReceiver(
[selfRef, embeddedWindow = m_jsStateData->embeddedWindow.get()](const ::ArkUI_UIInputEvent *event) {
auto eventAction = ::OH_ArkUI_UIInputEvent_GetAction(event);
if (eventAction != ::UI_MOUSE_EVENT_ACTION_PRESS && eventAction != ::UI_TOUCH_EVENT_ACTION_DOWN)
return;
if (!embeddedWindow->hasNonQtManagedChildren())
return;
selfRef.visitInQtThreadIfAlive(
[](QNativeNode &node) {
Q_EMIT node.externalContentClickDetected();
});
});
auto sharedAxisEventHandler = QtOhos::moveToSharedPtr(
makeQOhosNativeAxisEventHandler(qWindowRef, imEventHandlerRef));
m_jsStateData->embeddedWindow->setAxisEventsHandler(
[sharedAxisEventHandler](auto *event) {
(*sharedAxisEventHandler)(QOhosAxisEventType::AxisEvent, event);
}
);
m_jsStateData->embeddedWindow->setCoastingAxisEventsHandler(
[sharedAxisEventHandler](auto *event) {
(*sharedAxisEventHandler)(QOhosAxisEventType::CoastingAxisEvent, event);
});
m_jsStateData->embeddedWindow->setGesturesHandler(
makeQOhosArkUiNativeGesturesHandler(qWindowRef));
m_jsStateData->embeddedWindow->setDragEventsHandler(makeQOhosNativeDragEventsHandler(qWindowRef));
if (QtOhos::isNativeNodeApiKeyEventsEnabled())
m_jsStateData->embeddedWindow->setKeyEventsHandler(makeQOhosNativeKeyEventsHandler(qWindowRef, imEventHandlerRef));
if (QtOhos::isNativeNodeApiMouseEventsEnabled()) {
m_jsStateData->embeddedWindow->setMouseEventsHandler(
makeQOhosNativeMouseEventsHandler(qWindowRef, imEventHandlerRef));
m_jsStateData->embeddedWindow->setHoverEventsHandler(
[qWindowRef, imEventHandlerRef](QArkUi::NativeNodeHoverEvent hoverEvent) {
if (hoverEvent.isHovered)
return;
imEventHandlerRef.visitInQtThreadIfAlive(
[qWindowRef](QOhosInputMethodEventHandler &imEventHandler) {
QWindow *qWindow = qWindowRef.data();
if (qWindow)
imEventHandler.onHoverEvent(QOhosHoverEvent { .targetWindow = qWindow });
});
});
}
},
Q_FUNC_INFO);
}
QRectF QNativeNode::geometry() const
{
return m_nodeGeometry;
}
void QNativeNode::setSizeParentFillPercentNormalized(const QSizeF &size)
{
QOhosJsThreadGateway::runAndWait(
[&](QOhosJsState &) {
m_jsStateData->embeddedWindow->setSizeParentFillPercentageNormalized(size);
},
Q_FUNC_INFO);
}
void QNativeNode::setSize(const QSizeF &size)
{
m_nodeGeometry.setSize(size.toSize());
QOhosJsThreadGateway::runAndWait(
[&](QOhosJsState &) {
m_jsStateData->embeddedWindow->setSize(size);
},
Q_FUNC_INFO);
}
void QNativeNode::setPosition(QPoint position)
{
m_nodeGeometry.setTopLeft(position);
QOhosJsThreadGateway::runAndWait(
[&](QOhosJsState &) {
m_jsStateData->embeddedWindow->setPosition(position);
},
Q_FUNC_INFO);
}
void QNativeNode::setVisibility(bool visible)
{
QOhosJsThreadGateway::runAndWait(
[&](QOhosJsState &) {
m_jsStateData->embeddedWindow->setNodeVisibility(visible);
},
Q_FUNC_INFO);
}
QOhosSurface *QNativeNode::surfaceOrNull() const
{
return m_optSurface.get();
}
void QNativeNode::fillToParent()
{
QOhosJsThreadGateway::runAndWait(
[&](QOhosJsState &) {
m_jsStateData->embeddedWindow->setPosition(QPointF(0, 0));
m_jsStateData->embeddedWindow->setSizeParentFillPercentageNormalized(QSizeF(1.0, 1.0));
},
Q_FUNC_INFO);
}
void QNativeNode::handleSurfaceEvent(
SurfaceEventType surfaceEventType,
::OHNativeWindow *nativeWindow,
const std::optional<QSize> &optSurfaceSize)
{
qCDebug(QtForOhos, "Surface event: %d window: %p", surfaceEventType, nativeWindow);
switch (surfaceEventType) {
case SurfaceEventType::SurfaceChanged:
{
// NOTE - Its possible to receive surface changed event with null nativeWindow
if (nativeWindow == nullptr) {
m_optSurface.reset();
} else if (m_optSurface) {
m_optSurface->setNativeWindowSurface(nativeWindow, optSurfaceSize);
} else {
m_optSurface = std::make_unique<QOhosSurface>(nativeWindow);
}
break;
}
case SurfaceEventType::SurfaceCreated:
m_optSurface = std::make_unique<QOhosSurface>(nativeWindow);
break;
case SurfaceEventType::SurfaceDestroyed:
m_optSurface.reset();
break;
}
Q_EMIT surfaceStatusChanged(optSurfaceSize);
}
WId QNativeNode::windowId() const
{
return QOhosJsThreadGateway::eval([&](QOhosJsState &) {
return reinterpret_cast<WId>(m_jsStateData->embeddedWindow->qtWindowId());
},
Q_FUNC_INFO);
}
void QNativeNode::setParent(std::shared_ptr<QXComponentNode> xComponent)
{
QOhosJsThreadGateway::runAndWait([&](QOhosJsState &){
m_jsStateData->embeddedWindow->setParentOrReparent(
QArkUi::QEmbeddedWindowNode::ParentDescriptor(xComponent));
},
Q_FUNC_INFO);
}
void QNativeNode::setParent(QNativeNode &other)
{
QOhosJsThreadGateway::runAndWait([&](QOhosJsState &){
m_jsStateData->embeddedWindow->setParentOrReparent(
QArkUi::QEmbeddedWindowNode::ParentDescriptor(*other.m_jsStateData->embeddedWindow));
},
Q_FUNC_INFO);
}
void QNativeNode::raise()
{
QOhosJsThreadGateway::runAndWait([&](QOhosJsState &){
auto &window = *m_jsStateData->embeddedWindow;
window.raise();
},
Q_FUNC_INFO);
}
void QNativeNode::lower()
{
QOhosJsThreadGateway::runAndWait([&](QOhosJsState &){
auto &window = *m_jsStateData->embeddedWindow;
window.lower();
},
Q_FUNC_INFO);
}
void QNativeNode::detachFromParentIfPresent()
{
QOhosJsThreadGateway::runAndWait([&](QOhosJsState &) {
auto &window = *m_jsStateData->embeddedWindow;
window.detachFromParentIfPresent();
},
Q_FUNC_INFO);
}
void QNativeNode::setFocused(bool focused)
{
QOhosJsThreadGateway::runAndWait([&](QOhosJsState &) {
m_jsStateData->embeddedWindow->setFocused(focused);
},
Q_FUNC_INFO);
}
void QNativeNode::setFocusable(bool focusable)
{
QOhosJsThreadGateway::runAndWait([&](QOhosJsState &) {
m_jsStateData->embeddedWindow->setFocusable(focusable);
},
Q_FUNC_INFO);
}
void QNativeNode::setBackgroundColor(const QColor &color)
{
QOhosJsThreadGateway::runAndWait([&](QOhosJsState &) {
m_jsStateData->embeddedWindow->setBackgroundColor(color);
},
Q_FUNC_INFO);
}
void QNativeNode::setBrightness(int brightness)
{
QOhosJsThreadGateway::runAndWait(
[&](QOhosJsState &) {
m_jsStateData->embeddedWindow->setBrightness(brightness);
},
Q_FUNC_INFO);
}
void QNativeNode::setContrast(int contrast)
{
QOhosJsThreadGateway::runAndWait(
[&](QOhosJsState &) {
m_jsStateData->embeddedWindow->setContrast(contrast);
},
Q_FUNC_INFO);
}
void QNativeNode::setSaturation(int saturation)
{
QOhosJsThreadGateway::runAndWait(
[&](QOhosJsState &) {
m_jsStateData->embeddedWindow->setSaturation(saturation);
},
Q_FUNC_INFO);
}
void QNativeNode::startDrag(
const std::vector<QImage> &images, const QPointF &hotspot,
const QMimeData &mimeData, QOhosConsumer<Qt::DropAction> dropActionConsumer)
{
auto udmfDataFactory = makeUdmfDataFactoryFromQMimeData(mimeData, {});
QOhosJsThreadGateway::runAndWait(
[&](QOhosJsState &) {
qOhosPrintfDebug("%s: starting drag", Q_FUNC_INFO);
std::vector<std::shared_ptr<::OH_PixelmapNative>> pixelMaps;
std::transform(
images.begin(), images.end(), std::back_inserter(pixelMaps),
&makeOhosNativePixelMapFromQImage);
struct DragContext
{
QOhosConsumer<Qt::DropAction> dropActionConsumer;
std::shared_ptr<void> startedDragHandle;
};
auto context = std::make_shared<DragContext>();
context->dropActionConsumer = std::move(dropActionConsumer);
auto startedDragHandle = m_jsStateData->embeddedWindow->startDrag(
std::move(pixelMaps), hotspot,
udmfDataFactory(),
[context](::ArkUI_DragAndDropInfo *dragAndDropInfo) mutable {
auto dragStatus = QArkUi::callArkUi(
Q_OHOS_NAMED_FUNC(::OH_ArkUI_DragAndDropInfo_GetDragStatus),
dragAndDropInfo);
qOhosPrintfDebug("%s: drag status: %d", Q_FUNC_INFO, static_cast<int>(dragStatus));
if (dragStatus == ::ARKUI_DRAG_STATUS_ENDED && context) {
auto *dragEvent = QArkUi::callArkUiOrFailOnNullResult(
Q_OHOS_NAMED_FUNC(::OH_ArkUI_DragAndDropInfo_GetDragEvent),
dragAndDropInfo);
::ArkUI_DragResult dragResult = ::ARKUI_DRAG_RESULT_FAILED;
QArkUi::callArkUiOrFailOnErrorResult(
Q_OHOS_NAMED_FUNC(::OH_ArkUI_DragEvent_GetDragResult),
dragEvent, &dragResult);
auto qtDropAction =
dragResult == ::ARKUI_DRAG_RESULT_SUCCESSFUL
? mapQOhosArkUiDropOperationToQt(
getQOhosDragEventDropOperation(dragEvent))
: Qt::IgnoreAction;
qOhosPrintfDebug(
"%s: sending drag-end notification: %d / %d",
Q_FUNC_INFO, static_cast<int>(dragResult), static_cast<int>(qtDropAction));
QtOhos::invokeInQtThread(
[dropActionConsumer = std::move(context->dropActionConsumer), qtDropAction]() {
dropActionConsumer(qtDropAction);
});
context.reset();
}
});
context->startedDragHandle = startedDragHandle;
},
Q_FUNC_INFO);
}
void QNativeNode::enableDropDisallowedBadge()
{
QOhosJsThreadGateway::runAndWait([&](QOhosJsState &) {
m_jsStateData->embeddedWindow->enableDropDisallowedBadge();
},
Q_FUNC_INFO);
}
void QNativeNode::addForeignWindowChild(QOhosForeignWindow *foreignWindow)
{
QOhosJsThreadGateway::runAndWait([&](QOhosJsState &) {
auto &child = foreignWindow->embeddedWindowNodeInJsThread();
auto parentDescriptor = QArkUi::QEmbeddedWindowNode::ParentDescriptor(*m_jsStateData->embeddedWindow);
child.setParentOrReparent(parentDescriptor);
},
Q_FUNC_INFO);
}
void QNativeNode::setTransparentForInput(bool transparentForInput)
{
QOhosJsThreadGateway::runAndWait([&](QOhosJsState &) {
m_jsStateData->embeddedWindow->setHitTestMode(
transparentForInput
? ::ARKUI_HIT_TEST_MODE_NONE
: ::ARKUI_HIT_TEST_MODE_DEFAULT);
},
Q_FUNC_INFO);
}
void QNativeNode::setNodeAreaChangeHandler(QOhosConsumer<QArkUi::QQtEmbeddedWindowNode::NodeAreaInfo> areaChangeEventConsumer)
{
auto selfRef = QtOhos::makeQThreadSafeRef(this);
QOhosJsThreadGateway::runAndWait([&](QOhosJsState &) {
m_jsStateData->embeddedWindow->setAreaChangeReceiver(
QtOhos::makeCompressingAsyncConsumer(
std::move(areaChangeEventConsumer),
[selfRef](auto task) {
selfRef.visitInQtThreadIfAlive([task = std::move(task)](QNativeNode &) {
task();
});
}));
},
Q_FUNC_INFO);
}
void QNativeNode::setNodeFocusChangeHandler(QOhosConsumer<bool> focusedChangedConsumer)
{
auto selfRef = QtOhos::makeQThreadSafeRef(this);
auto sharedConsumer = QtOhos::moveToSharedPtr(std::move(focusedChangedConsumer));
QOhosJsThreadGateway::runAndWait([&](QOhosJsState &) {
m_jsStateData->embeddedWindow->setFocusedChangeReceiver(
[selfRef, sharedConsumer = std::move(sharedConsumer)](bool focused) {
selfRef.visitInQtThreadIfAlive([focused, sharedConsumer](QNativeNode &) {
(*sharedConsumer)(focused);
});
});
},
Q_FUNC_INFO);
}
void QNativeNode::setNodeVisibilityChangeHandler(QOhosConsumer<bool> visibilityChangedConsumer)
{
auto selfRef = QtOhos::makeQThreadSafeRef(this);
auto sharedConsumer = QtOhos::moveToSharedPtr(std::move(visibilityChangedConsumer));
QOhosJsThreadGateway::runAndWait([&](QOhosJsState &) {
m_jsStateData->embeddedWindow->setVisibilityChangeReceiver(
[selfRef, sharedConsumer = std::move(sharedConsumer)](bool visibile) {
selfRef.visitInQtThreadIfAlive([visibile, sharedConsumer](QNativeNode &) {
(*sharedConsumer)(visibile);
});
});
},
Q_FUNC_INFO);
}
QRect QNativeNode::nodeScreenGeometryPixels() const
{
return QOhosJsThreadGateway::eval(
[&](QOhosJsState &) {
return m_jsStateData->embeddedWindow->nodeScreenGeometryPixels();
},
Q_FUNC_INFO);
}
QRect QNativeNode::nodeParentRelativeGeometryPixels() const
{
return QOhosJsThreadGateway::eval(
[&](QOhosJsState &) {
return QRect(
m_jsStateData->embeddedWindow->parentRelativeOffsetPixels(),
m_jsStateData->embeddedWindow->nodeScreenGeometryPixels().size());
},
Q_FUNC_INFO);
}
QArkUi::QQtEmbeddedWindowNode::NodeAreaInfo QNativeNode::nodeAreaInfo() const
{
return QOhosJsThreadGateway::eval(
[&](QOhosJsState &) {
return m_jsStateData->embeddedWindow->nodeAreaInfo();
},
Q_FUNC_INFO);
}
QT_END_NAMESPACE