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 "qohoswebcomponentlistener.h"
#include "qohoswebresourceerror.h"
#include "qohoswebview_p.h"
#include "qohoswebviewcontroller.h"
#include <QtWebView/private/qwebviewfactory_p.h>
#include <QtCore/private/qohoslogger_p.h>
#include <QtCore/qfileinfo.h>
#include <QtCore/qjsonobject.h>
#include <QtGui/qpa/qplatformwindow_p.h>
QT_BEGIN_NAMESPACE
namespace {
class QOhosWebViewSettingPrivate : public QWebViewSettingsPrivate
{
public:
explicit QOhosWebViewSettingPrivate(std::shared_ptr<QOhosWebViewController> controller);
private:
bool doTestAttribute(WebAttribute attribute) const final;
void doSetAttribute(WebAttribute attribute, bool value) final;
std::shared_ptr<QOhosWebViewController> m_webViewController;
};
class QOhosWebViewPrivate : public QWebViewPrivate
{
Q_OBJECT
public:
explicit QOhosWebViewPrivate(QWebView *view);
~QOhosWebViewPrivate() override;
QString httpUserAgent() const override;
void setHttpUserAgent(const QString &httpUserAgent) override;
QUrl url() const override;
void setUrl(const QUrl &url) override;
bool canGoBack() const override;
bool canGoForward() const override;
QString title() const override;
int loadProgress() const override;
bool isLoading() const override;
void initialize(QObject *context) override;
void setCookie(const QString &domain, const QString &name, const QString &value) override;
void deleteCookie(const QString &domain, const QString &name) override;
void deleteAllCookies() override;
QWindow *nativeWindow() const override;
void onErrorReceived(const QString &url, const WebResourceError &error);
void onPageBegan(const QString &url);
void onPageEnded(const QString &url);
void onProgressChanged(int progress);
void onTitleUpdated(const QString &title, bool isRealTitle);
public Q_SLOTS:
void goBack() override;
void goForward() override;
void reload() override;
void stop() override;
void loadHtml(const QString &html, const QUrl &baseUrl) override;
protected:
void runJavaScript(const QString &script,
const std::function<void(const QVariant &)> &resultCallback) override;
QWebViewSettingsPrivate *settings() const override;
private:
void emitLoadingChangeSignalAndUpdateLoadStatus(const QWebViewLoadingInfo &loadingInfo);
void emitSyntheticLoadFailure(const QUrl &url, const QString &errorMessage);
QPointer<QWindow> m_webViewWindow;
std::shared_ptr<QOhosWebViewController> m_webViewController;
std::shared_ptr<QOhosWebComponentListener> m_webComponentListener;
int m_loadProgress = 0;
QWebViewLoadingInfo::LoadStatus m_loadStatus = QWebViewLoadingInfo::LoadStatus::Stopped;
QString m_url;
QString m_title;
bool m_loadFailed = false;
};
class QOhosWebComponentListenerImpl : public QOhosWebComponentListener
{
public:
QOhosWebComponentListenerImpl(QPointer<QOhosWebViewPrivate> webViewPrivate);
~QOhosWebComponentListenerImpl();
void onErrorReceived(const std::string &url, const WebResourceError &error) override;
void onPageBegan(const std::string &url) override;
void onPageEnded(const std::string &url) override;
void onProgressChanged(int progress) override;
void onTitleReceived(const std::string &title, bool isRealTitle) override;
private:
QPointer<QOhosWebViewPrivate> m_webViewPrivate;
};
QOhosWebViewSettingPrivate::QOhosWebViewSettingPrivate(std::shared_ptr<QOhosWebViewController> controller)
: m_webViewController(controller)
{
}
bool QOhosWebViewSettingPrivate::doTestAttribute(WebAttribute attribute) const
{
return m_webViewController->testAttribute(attribute);
}
void QOhosWebViewSettingPrivate::doSetAttribute(WebAttribute attribute, bool value)
{
m_webViewController->setAttribute(attribute, value);
}
QWindow *createEmbeddedWebViewWindow(
std::shared_ptr<QOhosWebViewController> webViewController,
std::shared_ptr<QOhosWebComponentListener> webComponentListener,
QObject *webComponentListenerContext)
{
auto webViewNode = webViewController->createEmbeddedWebComponentNodeOrFail(
webComponentListener, webComponentListenerContext);
return QNativeInterface::Private::QOhosWindow::fromNative(webViewNode);
}
QVariant convertJavaScriptResultToQVariantOrNull(std::optional<std::string> javaScriptResult)
{
if (!javaScriptResult.has_value())
return QVariant();
const QByteArray jsonData = "{ \"data\": " + QByteArray(javaScriptResult.value().c_str()) + " }";
QJsonParseError parseError;
const auto jsonDoc = QJsonDocument::fromJson(jsonData, &parseError);
if (parseError.error != QJsonParseError::NoError) {
qOhosCritical(QtForOhos)
<< Q_FUNC_INFO
<< "Failed to parse javaScript result, reason:"
<< parseError.errorString();
return QVariant();
}
return jsonDoc.isObject()
? jsonDoc.object()[QStringLiteral("data")].toVariant()
: QVariant();
}
std::string cookieUrlFromDomain(const QString &domain)
{
QString host = domain;
if (host.startsWith(u'.'))
host.remove(0, 1);
if (!host.contains(QLatin1String("://")))
host.prepend(QLatin1String("https://"));
return host.toStdString();
}
bool cookieHeaderHasName(const QString &cookieHeader, const QString &name)
{
const QStringList parts = cookieHeader.split(u';', Qt::SkipEmptyParts);
for (const QString &part : parts) {
const QString token = part.trimmed();
const qsizetype eq = token.indexOf(u'=');
const QString key = (eq < 0 ? token : token.left(eq)).trimmed();
if (key == name)
return true;
}
return false;
}
QOhosWebViewPrivate::QOhosWebViewPrivate(QWebView *view)
: QWebViewPrivate(view)
, m_webViewController(makeOhosWebViewController())
{
m_webComponentListener = std::make_shared<QOhosWebComponentListenerImpl>(this);
m_webViewWindow = createEmbeddedWebViewWindow(m_webViewController, m_webComponentListener, this);
if (m_webViewWindow) {
m_webViewController->bindQrcSchemeHandler();
m_webViewWindow->setParent(view);
connect(view, &QWindow::widthChanged, m_webViewWindow.data(), &QWindow::setWidth);
connect(view, &QWindow::heightChanged, m_webViewWindow.data(), &QWindow::setHeight);
connect(view, &QWindow::visibleChanged, m_webViewWindow.data(), &QWindow::setVisible);
}
}
QOhosWebViewPrivate::~QOhosWebViewPrivate() = default;
QString QOhosWebViewPrivate::httpUserAgent() const
{
return convertJavaScriptResultToQVariantOrNull(
m_webViewController->tryRunJavaScript("navigator.userAgent")).toString();
}
void QOhosWebViewPrivate::setHttpUserAgent(const QString &httpUserAgent)
{
if (m_webViewController->trySetCustomUserAgent(httpUserAgent.toStdString()))
Q_EMIT q_ptr->httpUserAgentStringChanged(httpUserAgent);
}
QUrl QOhosWebViewPrivate::url() const
{
auto controllerUrl = QString::fromStdString(m_webViewController->getUrl());
return QFileInfo::exists(controllerUrl)
? QUrl::fromLocalFile(controllerUrl)
: QUrl::fromEncoded(controllerUrl.toUtf8());
}
void QOhosWebViewPrivate::setUrl(const QUrl &url)
{
auto controllerUrl = url.isLocalFile()
? QFileInfo(url.toLocalFile()).absoluteFilePath().toStdString()
: url.toString().toStdString();
if (!m_webViewController->tryLoadUrl(controllerUrl)) {
qOhosWarning(QtForOhos) << Q_FUNC_INFO << "Failed to set url:" << controllerUrl.c_str();
emitSyntheticLoadFailure(
url, QStringLiteral("Failed to load: %1").arg(url.toString()));
}
}
void QOhosWebViewPrivate::loadHtml(const QString &html, const QUrl &baseUrl)
{
const std::string mimeType = "text/html;charset=UTF-8";
const std::string encoding = "UTF-8";
bool ok;
if (baseUrl.isEmpty() || baseUrl.scheme() == QLatin1String("data")) {
const std::string data = QUrl::toPercentEncoding(html).toStdString();
ok = m_webViewController->tryLoadHtml(data, mimeType, encoding, {}, {});
} else {
const std::string base = baseUrl.toString().toStdString();
ok = m_webViewController->tryLoadHtml(html.toStdString(), mimeType, encoding, base, base);
}
if (!ok)
qOhosWarning(QtForOhos) << Q_FUNC_INFO << "Failed to load html:" << html;
}
bool QOhosWebViewPrivate::canGoBack() const
{
return m_webViewController->canGoBack();
}
void QOhosWebViewPrivate::goBack()
{
m_webViewController->goBack();
}
bool QOhosWebViewPrivate::canGoForward() const
{
return m_webViewController->canGoForward();
}
void QOhosWebViewPrivate::goForward()
{
m_webViewController->goForward();
}
void QOhosWebViewPrivate::reload()
{
m_webViewController->refresh();
}
QString QOhosWebViewPrivate::title() const
{
return m_title;
}
void QOhosWebViewPrivate::runJavaScript(const QString &script,
const std::function<void(const QVariant &)> &resultCallback)
{
auto result = convertJavaScriptResultToQVariantOrNull(m_webViewController->tryRunJavaScript(script.toStdString()));
if (resultCallback)
resultCallback(result);
}
QWebViewSettingsPrivate *QOhosWebViewPrivate::settings() const
{
return new QOhosWebViewSettingPrivate(m_webViewController);
}
int QOhosWebViewPrivate::loadProgress() const
{
return m_loadProgress;
}
bool QOhosWebViewPrivate::isLoading() const
{
return m_loadStatus == QWebViewLoadingInfo::LoadStatus::Started;
}
void QOhosWebViewPrivate::initialize(QObject *context)
{
Q_UNUSED(context);
}
void QOhosWebViewPrivate::setCookie(const QString &domain, const QString &name, const QString &value)
{
const std::string url = cookieUrlFromDomain(domain);
const std::string cookie = QStringLiteral("%1=%2").arg(name, value).toStdString();
if (m_webViewController->trySetCookie(url, cookie))
Q_EMIT q_ptr->cookieAdded(domain, name);
}
void QOhosWebViewPrivate::deleteCookie(const QString &domain, const QString &name)
{
const std::string url = cookieUrlFromDomain(domain);
const std::optional<std::string> existing = m_webViewController->tryFetchCookie(url);
if (!existing || !cookieHeaderHasName(QString::fromStdString(*existing), name))
return;
const std::string expired = QStringLiteral("%1=; Max-Age=0; Path=/").arg(name).toStdString();
if (m_webViewController->trySetCookie(url, expired))
Q_EMIT q_ptr->cookieRemoved(domain, name);
}
void QOhosWebViewPrivate::deleteAllCookies()
{
const auto cookies = m_webViewController->fetchAllCookies();
if (!m_webViewController->tryClearAllCookies())
return;
for (const auto &[domain, name] : cookies)
Q_EMIT q_ptr->cookieRemoved(QString::fromStdString(domain), QString::fromStdString(name));
}
QWindow *QOhosWebViewPrivate::nativeWindow() const
{
return m_webViewWindow.data();
}
void QOhosWebViewPrivate::stop()
{
m_webViewController->stop();
QMetaObject::invokeMethod(
this,
[this]() {
emitLoadingChangeSignalAndUpdateLoadStatus(
QWebViewFactory::LoadingInfo::create(QUrl(m_url), QWebViewLoadingInfo::LoadStatus::Stopped, QString()));
},
Qt::QueuedConnection);
}
void QOhosWebViewPrivate::onErrorReceived(const QString &url, const WebResourceError &error)
{
auto errorMessage =
QString(QLatin1String("Error %1: '%3'")).arg(error.errorCode()).arg(error.errorInfo().c_str());
if (m_url != url) {
qOhosWarning(QtForOhos)
<< Q_FUNC_INFO << "Received onErrorReceive event on other url:" << url << errorMessage;
return;
}
qOhosCritical(QtForOhos) << Q_FUNC_INFO << "Received onErrorReceive for main page:" << errorMessage;
m_loadFailed = true;
emitLoadingChangeSignalAndUpdateLoadStatus(
QWebViewFactory::LoadingInfo::create(QUrl(m_url), QWebViewLoadingInfo::LoadStatus::Failed, errorMessage));
}
void QOhosWebViewPrivate::onPageBegan(const QString &url)
{
m_url = url;
m_loadFailed = false;
Q_EMIT q_ptr->urlChanged(QUrl(url));
emitLoadingChangeSignalAndUpdateLoadStatus(
QWebViewFactory::LoadingInfo::create(QUrl(url), QWebViewLoadingInfo::LoadStatus::Started, QString()));
onProgressChanged(0);
}
void QOhosWebViewPrivate::onPageEnded(const QString &url)
{
if (m_loadFailed) {
qOhosWarning(QtForOhos)
<< Q_FUNC_INFO
<< "Skipping LoadSucceededStatus; load already failed, url:" << url;
return;
}
if (m_url != url) {
qOhosWarning(QtForOhos) << Q_FUNC_INFO << "Received onPageEnd event from other url:" << url;
return;
}
emitLoadingChangeSignalAndUpdateLoadStatus(
QWebViewFactory::LoadingInfo::create(QUrl(url), QWebViewLoadingInfo::LoadStatus::Succeeded, QString()));
}
void QOhosWebViewPrivate::onProgressChanged(int progress)
{
if (m_loadProgress == progress) {
return;
}
m_loadProgress = progress;
Q_EMIT q_ptr->loadProgressChanged(progress);
}
void QOhosWebViewPrivate::onTitleUpdated(const QString &title, bool isRealTitle)
{
if (!isRealTitle) {
qOhosDebug(QtForOhos) << Q_FUNC_INFO << "Ignoring URL-generated title:" << title;
return;
}
if (m_title == title)
return;
m_title = title;
Q_EMIT q_ptr->titleChanged(title);
}
void QOhosWebViewPrivate::emitLoadingChangeSignalAndUpdateLoadStatus(
const QWebViewLoadingInfo &loadingInfo)
{
m_loadStatus = loadingInfo.status();
Q_EMIT q_ptr->loadingChanged(loadingInfo);
}
void QOhosWebViewPrivate::emitSyntheticLoadFailure(const QUrl &url, const QString &errorMessage)
{
QMetaObject::invokeMethod(
this,
[this, url, errorMessage]() {
m_url = url.toString();
Q_EMIT q_ptr->urlChanged(url);
emitLoadingChangeSignalAndUpdateLoadStatus(
QWebViewFactory::LoadingInfo::create(
url, QWebViewLoadingInfo::LoadStatus::Started, QString()));
emitLoadingChangeSignalAndUpdateLoadStatus(
QWebViewFactory::LoadingInfo::create(
url, QWebViewLoadingInfo::LoadStatus::Failed, errorMessage));
},
Qt::QueuedConnection);
}
QOhosWebComponentListenerImpl::QOhosWebComponentListenerImpl(QPointer<QOhosWebViewPrivate> webViewPrivate)
: QOhosWebComponentListener()
, m_webViewPrivate(webViewPrivate)
{
}
QOhosWebComponentListenerImpl::~QOhosWebComponentListenerImpl() = default;
void QOhosWebComponentListenerImpl::onErrorReceived(const std::string &url, const WebResourceError &error)
{
if (m_webViewPrivate)
m_webViewPrivate->onErrorReceived(QString::fromStdString(url), error);
}
void QOhosWebComponentListenerImpl::onPageBegan(const std::string &url)
{
if (m_webViewPrivate)
m_webViewPrivate->onPageBegan(QString::fromStdString(url));
}
void QOhosWebComponentListenerImpl::onPageEnded(const std::string &url)
{
if (m_webViewPrivate)
m_webViewPrivate->onPageEnded(QString::fromStdString(url));
}
void QOhosWebComponentListenerImpl::onProgressChanged(int progress)
{
if (m_webViewPrivate)
m_webViewPrivate->onProgressChanged(progress);
}
void QOhosWebComponentListenerImpl::onTitleReceived(const std::string &title, bool isRealTitle)
{
if (m_webViewPrivate)
m_webViewPrivate->onTitleUpdated(QString::fromStdString(title), isRealTitle);
}
}
QWebViewPrivate *makeOhosWebView(QWebView *view)
{
return new QOhosWebViewPrivate(view);
}
void prepareOhosWebView()
{
initializeOhosWebEngine();
}
QT_END_NAMESPACE
#include "qohoswebview.moc"