qohoswebviewcontroller.cpp

++ // 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 "qohoswebresourceerror.h"

++ #include "qohoswebviewcontroller.h"

++ #include <QtCore/private/qnapi_p.h>

++ #include <QtCore/private/qohoslogger_p.h>

++ #include <QtCore/QByteArray>

++ #include <QtCore/QMimeDatabase>

++ #include <QtCore/QResource>

++ #include <QtCore/QUrl>

++ #include <arkui/native_node_napi.h>

++ #include <arkui/native_type.h>

++ #include <web/arkweb_net_error_list.h>

++ #include <web/arkweb_scheme_handler.h>

++ #include <cstdlib>

++

++ QT_BEGIN_NAMESPACE

++

++ #define QT_OHOS_ARKWEB_CHECK(call) \

++     do { \

++         const int32_t arkwebRc_ = (call); \

++         if (arkwebRc_ != ARKWEB_NET_OK) \

++             qOhosPrintfError("%s: %s failed with error: %d", \

++                              Q_FUNC_INFO, #call, arkwebRc_); \

++     } while (false)

++

++ namespace {

++

++ class QOhosWebViewControllerImpl : public QOhosWebViewController

++ {

++ public:

++     QOhosWebViewControllerImpl();

++

++     ::ArkUI_NodeHandle createEmbeddedWebComponentNodeOrFail(

++         std::shared_ptr<QOhosWebComponentListener> webComponentListener,

++         QObject *webComponentListenerContext) override;

++

++     bool tryLoadUrl(const std::string &url) override;

++     std::string getUrl() override;

++

++     bool tryLoadHtml(const std::string &data, const std::string &mimeType,

++                      const std::string &encoding, const std::string &baseUrl,

++                      const std::string &historyUrl) override;

++

++     bool canGoBack() override;

++     bool canGoForward() override;

++

++     void goBack() override;

++     void goForward() override;

++

++     void refresh() override;

++     void stop() override;

++

++     std::optional<std::string> tryRunJavaScript(const std::string &script) override;

++

++     void setAttribute(QWebViewSettings::WebAttribute attribute, bool enabled) override;

++     bool testAttribute(QWebViewSettings::WebAttribute attribute) const override;

++

++     bool trySetCookie(const std::string &url, const std::string &cookie) override;

++     std::optional<std::string> tryFetchCookie(const std::string &url) override;

++     bool tryClearAllCookies() override;

++     std::vector<std::pair<std::string, std::string>> fetchAllCookies() override;

++

++     void bindQrcSchemeHandler() override;

++

++     bool trySetCustomUserAgent(const std::string &userAgent) override;

++

++ private:

++     using WebAttribute = QWebViewSettings::WebAttribute;

++

++     QNapi::Object makeWebComponentAttributes(

++         QOhosJsState &jsState,

++         const std::shared_ptr<QOhosWebComponentListener> &webComponentListener) const;

++     void applyUniversalAccessPath(QOhosJsState &jsState);

++     void setPathAllowingUniversalAccess(bool enabled);

++     void updateWebAttribute(WebAttribute attribute, bool enabled);

++

++     struct JsScopeData

++     {

++         QNapi::Reference<QNapi::Object> jsWebViewController;

++         QNapi::Reference<QNapi::Object> jsComponentContent;

++

++         QHash<WebAttribute, bool> attributes = {

++             {WebAttribute::LocalStorageEnabled, false},

++             {WebAttribute::JavaScriptEnabled, true},

++             {WebAttribute::AllowFileAccess, false},

++             {WebAttribute::LocalContentCanAccessFileUrls, false},

++         };

++         std::string universalAccessPath;

++     };

++

++     std::shared_ptr<JsScopeData> m_jsScopeData;

++     std::shared_ptr<QOhosWebComponentListener> m_webComponentListener;

++     std::shared_ptr<void> m_qrcSchemeHandlerBinding;

++     std::string m_webTag;

++ };

++

++ QNapi::Object createEmbeddedWebComponent(

++     QOhosJsState &jsState, QNapi::Object parentAbilityWindowStage,

++     QNapi::Object webComponentAttributes)

++ {

++     return jsState.eval<QNapi::Object>(

++         "QEmbeddedComponentCreator.makeNewQEmbeddedComponentCreator().createEmbeddedWebComponent(*)",

++         {

++             parentAbilityWindowStage.eval<QNapi::Object>("getMainWindowSync().getUIContext()"),

++             webComponentAttributes

++         });

++ }

++

++ std::string localDirectoryForTarget(const std::string &target)

++ {

++     if (target.empty())

++         return {};

++

++     std::string path = target;

++

++     const std::string filePrefix = "file://";

++     if (path.compare(0, filePrefix.size(), filePrefix) == 0)

++         path.erase(0, filePrefix.size());

++

++     if (path.empty() || path.front() != '/')

++         return {};

++

++     if (path.back() == '/')

++         path.pop_back();

++     else

++         path.erase(path.find_last_of('/'));

++

++     if (path.empty()) // the document sat at the filesystem root, e.g. "/index.html"

++         path = "/";

++

++     return path;

++ }

++

++ std::optional<std::string> tryGetResourceRequestUrl(const ArkWeb_ResourceRequest *resourceRequest)

++ {

++     char *rawUrl = nullptr;

++     ::OH_ArkWebResourceRequest_GetUrl(resourceRequest, &rawUrl);

++     if (!rawUrl) {

++         qOhosPrintfError("%s: OH_ArkWebResourceRequest_GetUrl returned no URL", Q_FUNC_INFO);

++         return std::nullopt;

++     }

++     std::string url = rawUrl;

++     ::OH_ArkWeb_ReleaseString(rawUrl);

++     return url;

++ }

++

++ std::shared_ptr<::ArkWeb_Response> createArkWebResponseOrNull()

++ {

++     ArkWeb_Response *response = nullptr;

++     ::OH_ArkWeb_CreateResponse(&response);

++     if (!response) {

++         qOhosPrintfError("%s: OH_ArkWeb_CreateResponse failed", Q_FUNC_INFO);

++         return nullptr;

++     }

++     return std::shared_ptr<::ArkWeb_Response>(response, ::OH_ArkWeb_DestroyResponse);

++ }

++

++ void onQrcRequestStart(const ArkWeb_SchemeHandler *,

++                        ArkWeb_ResourceRequest *resourceRequest,

++                        const ArkWeb_ResourceHandler *resourceHandler,

++                        bool *intercept)

++ {

++     *intercept = true;

++     QT_OHOS_ARKWEB_CHECK(::OH_ArkWebResourceRequest_SetUserData(

++         resourceRequest, const_cast<ArkWeb_ResourceHandler *>(resourceHandler)));

++

++     auto optRequestUrl = tryGetResourceRequestUrl(resourceRequest);

++     if (!optRequestUrl) {

++         QT_OHOS_ARKWEB_CHECK(::OH_ArkWebResourceHandler_DidFailWithErrorV2(

++             resourceHandler, ARKWEB_ERR_FAILED, true));

++         return;

++     }

++     const QUrl url(QString::fromUtf8(*optRequestUrl));

++

++     // qrc:/path/file  ->  ":/path/file"

++     QResource resource(QStringLiteral(":") + url.path());

++     if (!resource.isValid()) {

++         QT_OHOS_ARKWEB_CHECK(::OH_ArkWebResourceHandler_DidFailWithErrorV2(

++             resourceHandler, ARKWEB_ERR_FILE_NOT_FOUND, true));

++         return;

++     }

++

++     const QByteArray body = resource.uncompressedData();

++     const QByteArray mimeType =

++         QMimeDatabase().mimeTypeForFileNameAndData(url.fileName(), body).name().toUtf8();

++

++     const std::shared_ptr<::ArkWeb_Response> response = createArkWebResponseOrNull();

++     if (!response) {

++         QT_OHOS_ARKWEB_CHECK(::OH_ArkWebResourceHandler_DidFailWithErrorV2(

++             resourceHandler, ARKWEB_ERR_FAILED, true));

++         return;

++     }

++     QT_OHOS_ARKWEB_CHECK(::OH_ArkWebResponse_SetStatus(response.get(), 200));

++     QT_OHOS_ARKWEB_CHECK(::OH_ArkWebResponse_SetMimeType(response.get(), mimeType.constData()));

++     QT_OHOS_ARKWEB_CHECK(::OH_ArkWebResponse_SetCharset(response.get(), "UTF-8"));

++     QT_OHOS_ARKWEB_CHECK(::OH_ArkWebResponse_SetHeaderByName(

++         response.get(), "content-length", QByteArray::number(body.size()).constData(), false));

++

++     QT_OHOS_ARKWEB_CHECK(::OH_ArkWebResourceHandler_DidReceiveResponse(resourceHandler, response.get()));

++     QT_OHOS_ARKWEB_CHECK(::OH_ArkWebResourceHandler_DidReceiveData(

++         resourceHandler, reinterpret_cast<const uint8_t *>(body.constData()), body.size()));

++     QT_OHOS_ARKWEB_CHECK(::OH_ArkWebResourceHandler_DidFinish(resourceHandler));

++ }

++

++ void onQrcRequestStop(const ArkWeb_SchemeHandler *,

++                       const ArkWeb_ResourceRequest *resourceRequest)

++ {

++     auto *resourceHandler = static_cast<ArkWeb_ResourceHandler *>(

++         ::OH_ArkWebResourceRequest_GetUserData(resourceRequest));

++     if (resourceHandler)

++         QT_OHOS_ARKWEB_CHECK(::OH_ArkWebResourceHandler_Destroy(resourceHandler));

++     QT_OHOS_ARKWEB_CHECK(::OH_ArkWebResourceRequest_Destroy(resourceRequest));

++ }

++

++ std::shared_ptr<::ArkWeb_SchemeHandler> createQrcSchemeHandlerOrNull()

++ {

++     ArkWeb_SchemeHandler *schemeHandler = nullptr;

++     ::OH_ArkWeb_CreateSchemeHandler(&schemeHandler);

++     if (!schemeHandler) {

++         qOhosPrintfError("%s: OH_ArkWeb_CreateSchemeHandler failed", Q_FUNC_INFO);

++         return nullptr;

++     }

++     QT_OHOS_ARKWEB_CHECK(::OH_ArkWebSchemeHandler_SetOnRequestStart(schemeHandler, onQrcRequestStart));

++     QT_OHOS_ARKWEB_CHECK(::OH_ArkWebSchemeHandler_SetOnRequestStop(schemeHandler, onQrcRequestStop));

++     return std::shared_ptr<::ArkWeb_SchemeHandler>(schemeHandler, ::OH_ArkWeb_DestroySchemeHandler);

++ }

++

++ std::shared_ptr<::ArkWeb_SchemeHandler> sharedQrcSchemeHandlerOrNull()

++ {

++     static std::weak_ptr<::ArkWeb_SchemeHandler> weakHandler;

++     auto handler = weakHandler.lock();

++     if (!handler) {

++         handler = createQrcSchemeHandlerOrNull();

++         weakHandler = handler;

++     }

++     return handler;

++ }

++

++ std::string makeUniqueWebViewTag()

++ {

++     static unsigned s_webTagCounter = 0;

++     return "qtwebview_" + std::to_string(s_webTagCounter++);

++ }

++

++ QOhosWebViewControllerImpl::QOhosWebViewControllerImpl()

++     : QOhosWebViewController()

++     , m_webTag(makeUniqueWebViewTag())

++ {

++     m_jsScopeData = QOhosJsThreadGateway::eval(

++         [&](QOhosJsState &jsState) {

++             return QtOhos::makeProxyWithJsThreadDeleter(

++                 QtOhos::moveToSharedPtr(

++                     JsScopeData{

++                         .jsWebViewController = QNapi::Reference<>::makePersistentFrom(

++                             jsState.eval<QNapi::Object>("@ohos.web.webview.WebviewController<new>(*)", {m_webTag})),

++                         .jsComponentContent = {},

++                         .attributes = {},

++                         .universalAccessPath = {},

++                     }));

++         });

++ }

++

++ ::ArkUI_NodeHandle QOhosWebViewControllerImpl::createEmbeddedWebComponentNodeOrFail(

++     std::shared_ptr<QOhosWebComponentListener> webComponentListener,

++     QObject *webComponentListenerContext)

++ {

++     m_webComponentListener =

++         makeOhosWebComponentListenerExecutingInContextThread(

++             webComponentListener, webComponentListenerContext);

++

++     return QOhosJsThreadGateway::eval([&](QOhosJsState &jsState) {

++         auto optWindowStage = jsState.defaultWindowStageOrEmpty();

++         if (optWindowStage.IsEmpty()) {

++             qFatal("Attempting to create Web component without WindowStage object available, which is not supported. Aborting...");

++             std::abort();

++         }

++

++         auto embeddedWebComponent = createEmbeddedWebComponent(

++             jsState, optWindowStage,

++             makeWebComponentAttributes(jsState, m_webComponentListener));

++

++         m_jsScopeData->jsComponentContent =

++             QNapi::Reference<>::makePersistentFrom(embeddedWebComponent);

++

++         ::ArkUI_NodeHandle handle = nullptr;

++         auto getNodeFromNapiValueResult

++             = ::OH_ArkUI_GetNodeHandleFromNapiValue(jsState.env(), embeddedWebComponent, &handle);

++         if (getNodeFromNapiValueResult != ::ARKUI_ERROR_CODE_NO_ERROR || handle == nullptr) {

++             qFatal(

++                 "Failed to get node handle from webview component, reason: %i, Aborting...",

++                 getNodeFromNapiValueResult);

++             std::abort();

++         }

++

++         return handle;

++     });

++ }

++

++ bool QOhosWebViewControllerImpl::tryLoadUrl(const std::string &url)

++ {

++     return QOhosJsThreadGateway::eval([&](QOhosJsState &jsState) {

++         m_jsScopeData->universalAccessPath = localDirectoryForTarget(url);

++         applyUniversalAccessPath(jsState);

++         try {

++             m_jsScopeData->jsWebViewController.eval("loadUrl(*)", {url});

++             return true;

++         } catch (const Napi::Error &error) {

++             qOhosPrintfError(

++                 "%s received error from WebController.loadUrl('%s'): %s",

++                 Q_FUNC_INFO, url.c_str(), error.what());

++             return false;

++         }

++     });

++ }

++

++ std::string QOhosWebViewControllerImpl::getUrl()

++ {

++     return QOhosJsThreadGateway::eval([&](QOhosJsState &) {

++         return m_jsScopeData->jsWebViewController.eval<QNapi::String>("getUrl()").Utf8Value();

++     });

++ }

++

++ bool QOhosWebViewControllerImpl::tryLoadHtml(const std::string &data, const std::string &mimeType,

++                                              const std::string &encoding, const std::string &baseUrl,

++                                              const std::string &historyUrl)

++ {

++     return QOhosJsThreadGateway::eval([&](QOhosJsState &jsState) {

++         m_jsScopeData->universalAccessPath = localDirectoryForTarget(baseUrl);

++         applyUniversalAccessPath(jsState);

++         try {

++             if (baseUrl.empty())

++                 m_jsScopeData->jsWebViewController.eval("loadData(*)", {data, mimeType, encoding});

++             else

++                 m_jsScopeData->jsWebViewController.eval("loadData(*)", {data, mimeType, encoding, baseUrl, historyUrl});

++             return true;

++         } catch (const Napi::Error &error) {

++             qOhosPrintfError(

++                 "%s received error from WebController.loadData: %s", Q_FUNC_INFO, error.what());

++             return false;

++         }

++     });

++ }

++

++ bool QOhosWebViewControllerImpl::canGoBack()

++ {

++     return QOhosJsThreadGateway::eval([&](QOhosJsState &) {

++         return m_jsScopeData->jsWebViewController.eval<QNapi::Boolean>("accessBackward()").Value();

++     });

++ }

++

++ bool QOhosWebViewControllerImpl::canGoForward()

++ {

++     return QOhosJsThreadGateway::eval([&](QOhosJsState &) {

++         return m_jsScopeData->jsWebViewController.eval<QNapi::Boolean>("accessForward()").Value();

++     });

++ }

++

++ void QOhosWebViewControllerImpl::goBack()

++ {

++     QOhosJsThreadGateway::runAndWait([&](QOhosJsState &) {

++         m_jsScopeData->jsWebViewController.eval("backward()");

++     });

++ }

++

++ void QOhosWebViewControllerImpl::goForward()

++ {

++     QOhosJsThreadGateway::runAndWait([&](QOhosJsState &) {

++         m_jsScopeData->jsWebViewController.eval("forward()");

++     });

++ }

++

++ void QOhosWebViewControllerImpl::refresh()

++ {

++     QOhosJsThreadGateway::runAndWait([&](QOhosJsState &) {

++         m_jsScopeData->jsWebViewController.eval("refresh()");

++     });

++ }

++

++ void QOhosWebViewControllerImpl::stop()

++ {

++     QOhosJsThreadGateway::runAndWait([&](QOhosJsState &) {

++         m_jsScopeData->jsWebViewController.eval("stop()");

++     });

++ }

++

++ std::optional<std::string> QOhosWebViewControllerImpl::tryRunJavaScript(const std::string &script)

++ {

++     return QOhosJsThreadGateway::evalWithPromise<std::optional<std::string>>(

++         [&](QOhosJsState &, auto javaScriptResultPromise) {

++             auto thenCatchPromises = std::move(javaScriptResultPromise).makeThenCatchBranches(Q_FUNC_INFO);

++             m_jsScopeData->jsWebViewController.evalToPromiseOrRejectOnThrow("runJavaScript(*)", {script})

++             .onThen(

++                 [thenPromise = std::move(thenCatchPromises.first)](const QOhosCallbackInfo &cbInfo) {

++                     std::string javaScriptResult = cbInfo.getFirstArg<QNapi::String>(Q_FUNC_INFO);

++                     thenPromise(javaScriptResult);

++                 })

++             .onCatch(

++                 [catchPromise = std::move(thenCatchPromises.second)](const QOhosCallbackInfo &cbInfo) {

++                     QtOhos::logJsCallbackError(cbInfo, "@ohos.web.webview.WebviewController.runJavaScript() failed");

++                     catchPromise({});

++                 });

++         },

++         Q_FUNC_INFO);

++ }

++

++ void QOhosWebViewControllerImpl::setAttribute(WebAttribute attribute, bool enabled)

++ {

++     if (attribute == WebAttribute::LocalContentCanAccessFileUrls) {

++         setPathAllowingUniversalAccess(enabled);

++         return;

++     }

++     updateWebAttribute(attribute, enabled);

++ }

++

++ bool QOhosWebViewControllerImpl::testAttribute(WebAttribute attribute) const

++ {

++     return QOhosJsThreadGateway::eval(

++         [&](QOhosJsState &) {

++             return m_jsScopeData->attributes.value(attribute, false);

++         });

++ }

++

++ bool QOhosWebViewControllerImpl::trySetCookie(const std::string &url, const std::string &cookie)

++ {

++     return QOhosJsThreadGateway::eval([&](QOhosJsState &jsState) {

++         try {

++             jsState.eval("@ohos.web.webview.WebCookieManager.configCookieSync(*)", {url, cookie});

++             return true;

++         } catch (const Napi::Error &error) {

++             qOhosPrintfError(

++                 "%s: WebCookieManager.configCookieSync() failed for '%s': %s",

++                 Q_FUNC_INFO, url.c_str(), error.what());

++             return false;

++         }

++     });

++ }

++

++ std::optional<std::string> QOhosWebViewControllerImpl::tryFetchCookie(const std::string &url)

++ {

++     return QOhosJsThreadGateway::eval([&](QOhosJsState &jsState) -> std::optional<std::string> {

++         try {

++             const std::string cookie = jsState.eval<QNapi::String>(

++                 "@ohos.web.webview.WebCookieManager.fetchCookieSync(*)", {url});

++             return cookie;

++         } catch (const Napi::Error &error) {

++             qOhosPrintfError(

++                 "%s: WebCookieManager.fetchCookieSync('%s') failed: %s",

++                 Q_FUNC_INFO, url.c_str(), error.what());

++             return {};

++         }

++     });

++ }

++

++ bool QOhosWebViewControllerImpl::tryClearAllCookies()

++ {

++     return QOhosJsThreadGateway::eval([&](QOhosJsState &jsState) {

++         try {

++             jsState.eval("@ohos.web.webview.WebCookieManager.clearAllCookiesSync()");

++             return true;

++         } catch (const Napi::Error &error) {

++             qOhosPrintfError(

++                 "%s: WebCookieManager.clearAllCookiesSync() failed: %s", Q_FUNC_INFO, error.what());

++             return false;

++         }

++     });

++ }

++

++ std::vector<std::pair<std::string, std::string>> QOhosWebViewControllerImpl::fetchAllCookies()

++ {

++     using CookieList = std::vector<std::pair<std::string, std::string>>;

++     return QOhosJsThreadGateway::evalWithPromise<CookieList>(

++         [&](QOhosJsState &jsState, auto cookieListPromise) {

++             constexpr bool incognitoMode = false;

++             auto thenCatchPromises = std::move(cookieListPromise).makeThenCatchBranches(Q_FUNC_INFO);

++             jsState.evalToPromiseOrRejectOnThrow(

++                 "@ohos.web.webview.WebCookieManager.fetchAllCookies(*)", {incognitoMode})

++                 .onThen(

++                     [thenPromise = std::move(thenCatchPromises.first)](const QOhosCallbackInfo &cbInfo) {

++                         auto cookies = cbInfo.getFirstArg<QNapi::Array>(Q_FUNC_INFO);

++                         thenPromise(

++                             QNapi::getArrayElements<CookieList, QNapi::Object>(

++                                 cookies,

++                                 [](const QNapi::Object &cookie) -> std::pair<std::string, std::string> {

++                                     return {

++                                         cookie.get<QNapi::String>("domain"),

++                                         cookie.get<QNapi::String>("name")

++                                     };

++                                 }));

++                     })

++                 .onCatch(

++                     [catchPromise = std::move(thenCatchPromises.second)](const QOhosCallbackInfo &cbInfo) {

++                         QtOhos::logJsCallbackError(

++                             cbInfo, "@ohos.web.webview.WebCookieManager.fetchAllCookies() failed");

++                         catchPromise({});

++                     });

++         },

++         Q_FUNC_INFO);

++ }

++

++ void QOhosWebViewControllerImpl::bindQrcSchemeHandler()

++ {

++     m_qrcSchemeHandlerBinding = QOhosJsThreadGateway::eval(

++         [&](QOhosJsState &) -> std::shared_ptr<void> {

++             auto schemeHandler = sharedQrcSchemeHandlerOrNull();

++             if (!schemeHandler)

++                 return nullptr;

++

++             if (!::OH_ArkWeb_SetSchemeHandler("qrc", m_webTag.c_str(), schemeHandler.get())) {

++                 qOhosPrintfError(

++                     "%s: OH_ArkWeb_SetSchemeHandler(\"qrc\", \"%s\") failed.",

++                     Q_FUNC_INFO, m_webTag.c_str());

++                 return nullptr;

++             }

++

++             return QtOhos::makeProxyWithJsThreadDeleter(

++                 QtOhos::makeDestroyNotifier(

++                     [webTag = m_webTag, schemeHandler] {

++                         if (::OH_ArkWeb_ClearSchemeHandlers(webTag.c_str()) != 0)

++                             qOhosPrintfError(

++                                 "%s: OH_ArkWeb_ClearSchemeHandlers(\"%s\") failed.",

++                                 Q_FUNC_INFO, webTag.c_str());

++                     }));

++         });

++ }

++

++ bool QOhosWebViewControllerImpl::trySetCustomUserAgent(const std::string &userAgent)

++ {

++     return QOhosJsThreadGateway::eval([&](QOhosJsState &) {

++         try {

++             m_jsScopeData->jsWebViewController.eval("setCustomUserAgent(*)", {userAgent});

++             return true;

++         } catch (const Napi::Error &error) {

++             qOhosPrintfError("%s: setCustomUserAgent() failed: %s", Q_FUNC_INFO, error.what());

++             return false;

++         }

++     });

++ }

++

++ QNapi::Object QOhosWebViewControllerImpl::makeWebComponentAttributes(

++     QOhosJsState &jsState,

++     const std::shared_ptr<QOhosWebComponentListener> &webComponentListener) const

++ {

++     return QNapi::makeObject(

++         jsState.env(),

++         {

++             {"webviewController", m_jsScopeData->jsWebViewController.Value()},

++             {"domStorageAccess", m_jsScopeData->attributes.value(WebAttribute::LocalStorageEnabled, false)},

++             {"javaScriptAccess", m_jsScopeData->attributes.value(WebAttribute::JavaScriptEnabled, false)},

++             {"fileAccess", m_jsScopeData->attributes.value(WebAttribute::AllowFileAccess, false)},

++             {

++                 "onErrorReceive",

++                 [webComponentListener](const QOhosCallbackInfo &callbackInfo) {

++                     auto onErrorReceiveEvent = callbackInfo.getFirstArg<QNapi::Object>("onErrorReceive");

++                     std::string url = onErrorReceiveEvent.eval<QNapi::String>("request.getRequestUrl()");

++                     auto error = onErrorReceiveEvent.get<QNapi::Object>("error");

++                     webComponentListener->onErrorReceived(

++                         url, WebResourceError::makeFromJsObject(error));

++                 }

++             },

++             {

++                 "onPageBegin",

++                 [webComponentListener](const QNapi::CallbackInfo &callbackInfo) {

++                     auto onPageBeginEvent = callbackInfo.getFirstArg<QNapi::Object>("onPageBegin");

++                     webComponentListener->onPageBegan(

++                         onPageBeginEvent.get<QNapi::String>("url"));

++                 }

++             },

++             {

++                 "onPageEnd",

++                 [webComponentListener](const QNapi::CallbackInfo &callbackInfo) {

++                     auto onPageEndEvent = callbackInfo.getFirstArg<QNapi::Object>("onPageEnd");

++                     webComponentListener->onPageEnded(

++                         onPageEndEvent.get<QNapi::String>("url"));

++                 }

++             },

++             {

++                 "onProgressChange",

++                 [webComponentListener](const QNapi::CallbackInfo &callbackInfo) {

++                     auto onProgressChangeEvent = callbackInfo.getFirstArg<QNapi::Object>("onProgressChange");

++                     webComponentListener->onProgressChanged(

++                         onProgressChangeEvent.get<QNapi::Number>("newProgress"));

++                 }

++             },

++             {

++                 "onTitleReceive",

++                 [webComponentListener](const QNapi::CallbackInfo &callbackInfo) {

++                     auto onTitleReceivedEvent = callbackInfo.getFirstArg<QNapi::Object>("onTitleReceive");

++                     auto isRealTitleValue =

++                         QNapi::getOptionalPropOrEmpty<QNapi::Boolean>(onTitleReceivedEvent, "isRealTitle");

++                     webComponentListener->onTitleReceived(

++                         onTitleReceivedEvent.get<QNapi::String>("title"),

++                         !isRealTitleValue.IsEmpty() && isRealTitleValue.Value());

++                 }

++             },

++         });

++ }

++

++ void QOhosWebViewControllerImpl::applyUniversalAccessPath(QOhosJsState &jsState)

++ {

++     if (!m_jsScopeData->jsComponentContent)

++         return;

++

++     std::vector<std::string> paths;

++     if (m_jsScopeData->attributes[WebAttribute::LocalContentCanAccessFileUrls] && !m_jsScopeData->universalAccessPath.empty())

++         paths.push_back(m_jsScopeData->universalAccessPath);

++

++     try {

++         m_jsScopeData->jsWebViewController.eval(

++             "setPathAllowingUniversalAccess(*)",

++             {QNapi::makeArray(jsState.env(), paths)});

++     } catch (const Napi::Error &error) {

++         qOhosPrintfError(

++             "%s: setPathAllowingUniversalAccess failed (paths must live under "

++             "filesDir or resourceDir, otherwise error 401): %s",

++             Q_FUNC_INFO, error.what());

++     }

++ }

++

++ void QOhosWebViewControllerImpl::setPathAllowingUniversalAccess(bool enabled)

++ {

++     QOhosJsThreadGateway::runAndWait([&](QOhosJsState &jsState) {

++         m_jsScopeData->attributes[WebAttribute::LocalContentCanAccessFileUrls] = enabled;

++         applyUniversalAccessPath(jsState);

++     });

++ }

++

++ void QOhosWebViewControllerImpl::updateWebAttribute(WebAttribute attribute, bool enabled)

++ {

++     QOhosJsThreadGateway::runAndWait([&](QOhosJsState &jsState) {

++         m_jsScopeData->attributes[attribute] = enabled;

++

++         if (!m_jsScopeData->jsComponentContent)

++             return;

++

++         m_jsScopeData->jsComponentContent.eval(

++             "update(*)", {makeWebComponentAttributes(jsState, m_webComponentListener)});

++     });

++ }

++

++ }

++

++ QOhosWebViewController::QOhosWebViewController() = default;

++

++ QOhosWebViewController::~QOhosWebViewController() = default;

++

++ std::shared_ptr<QOhosWebViewController> makeOhosWebViewController()

++ {

++     return std::make_shared<QOhosWebViewControllerImpl>();

++ }

++

++ void initializeOhosWebEngine()

++ {

++     QOhosJsThreadGateway::runAndWait([](QOhosJsState &jsState) {

++         const int32_t opt = ARKWEB_SCHEME_OPTION_STANDARD | ARKWEB_SCHEME_OPTION_SECURE

++                             | ARKWEB_SCHEME_OPTION_CORS_ENABLED | ARKWEB_SCHEME_OPTION_FETCH_ENABLED;

++         if (::OH_ArkWeb_RegisterCustomSchemes("qrc", opt) != 0) {

++             qOhosPrintfError("%s: RegisterCustomSchemes(\"qrc\") failed", Q_FUNC_INFO);

++             return;

++         }

++         jsState.eval("@ohos.web.webview.WebviewController.initializeWebEngine()");

++     });

++ }

++

++ QT_END_NAMESPACE

Revision control