/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include "toolkit-timer.h"
-#include <dali/devel-api/adaptor-framework/web-engine.h>
-#include <dali/devel-api/adaptor-framework/web-engine-back-forward-list.h>
-#include <dali/devel-api/adaptor-framework/web-engine-back-forward-list-item.h>
-#include <dali/devel-api/adaptor-framework/web-engine-certificate.h>
-#include <dali/devel-api/adaptor-framework/web-engine-console-message.h>
-#include <dali/devel-api/adaptor-framework/web-engine-context.h>
-#include <dali/devel-api/adaptor-framework/web-engine-context-menu.h>
-#include <dali/devel-api/adaptor-framework/web-engine-context-menu-item.h>
-#include <dali/devel-api/adaptor-framework/web-engine-cookie-manager.h>
-#include <dali/devel-api/adaptor-framework/web-engine-form-repost-decision.h>
-#include <dali/devel-api/adaptor-framework/web-engine-frame.h>
-#include <dali/devel-api/adaptor-framework/web-engine-hit-test.h>
-#include <dali/devel-api/adaptor-framework/web-engine-http-auth-handler.h>
-#include <dali/devel-api/adaptor-framework/web-engine-load-error.h>
-#include <dali/devel-api/adaptor-framework/web-engine-policy-decision.h>
-#include <dali/devel-api/adaptor-framework/web-engine-request-interceptor.h>
-#include <dali/devel-api/adaptor-framework/web-engine-security-origin.h>
-#include <dali/devel-api/adaptor-framework/web-engine-settings.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-back-forward-list.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-back-forward-list-item.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-certificate.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-console-message.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-context.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-context-menu.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-context-menu-item.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-cookie-manager.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-form-repost-decision.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-frame.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-hit-test.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-http-auth-handler.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-load-error.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-policy-decision.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-request-interceptor.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-security-origin.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-settings.h>
#include <dali/public-api/adaptor-framework/native-image-source.h>
#include <dali/public-api/images/pixel-data.h>
#include <dali/public-api/object/any.h>
class WebEngine;
class MockWebEngineContext;
+class MockWebEngineCookieManager;
namespace
{
-
// Generally only one WebEngine instance exists.
// If > 1, a new web engine has been created by CreateWindowSignal.
-static WebEngine* gInstance = nullptr;
-static int gInstanceCount = 0;
-static MockWebEngineContext* gWebEngineContextInstance = nullptr;
+WebEngine* gInstance = nullptr;
+int gInstanceCount = 0;
+MockWebEngineContext* gWebEngineContextInstance = nullptr;
+MockWebEngineCookieManager* gMockWebEngineCookieManager = nullptr;
bool OnGoBack();
bool OnGoForward();
float mockZoomFactor;
};
+Dali::WebEngineContext* GetContext()
+{
+ if (!gWebEngineContextInstance)
+ {
+ gWebEngineContextInstance = new MockWebEngineContext();
+ }
+ return gWebEngineContextInstance;
+}
+
class MockWebEngineCookieManager : public Dali::WebEngineCookieManager
{
public:
Dali::WebEngineCookieManager::CookieAcceptPolicy mockCookieAcceptPolicy;
};
+Dali::WebEngineCookieManager* GetCookieManager()
+{
+ if (!gMockWebEngineCookieManager)
+ {
+ gMockWebEngineCookieManager = new MockWebEngineCookieManager();
+ }
+ return gMockWebEngineCookieManager;
+}
+
class MockWebEngineBackForwardListItem : public Dali::WebEngineBackForwardListItem
{
public:
}
};
-
class MockWebEngineCertificate : public Dali::WebEngineCertificate
{
public:
MockWebEngineFrame mockWebFrame;
};
-class MockWebEngineRequestInterceptor : public WebEngineRequestInterceptor
-{
-public:
- MockWebEngineRequestInterceptor()
- {
- }
-
- std::string GetUrl() const override
- {
- return "http://test.html";
- }
-
- Dali::Property::Map GetHeaders() const override
- {
- return mockHeadersMap;
- }
-
- std::string GetMethod() const override
- {
- return "GET";
- }
-
- bool Ignore() override
- {
- return true;
- }
-
- bool SetResponseStatus(int statusCode, const std::string& customedStatusText) override
- {
- return true;
- }
-
- bool AddResponseHeader(const std::string& fieldName, const std::string& fieldValue) override
- {
- mockHeadersMap.Add(fieldName, fieldValue);
- return true;
- }
-
- bool AddResponseHeaders(const Dali::Property::Map& headers) override
- {
- mockHeadersMap.Merge(headers);
- return true;
- }
-
- bool AddResponseBody(const int8_t* body, uint32_t length) override
- {
- return true;
- }
-
- bool AddResponse(const std::string& headers, const int8_t* body, uint32_t length) override
- {
- return true;
- }
-
- bool WriteResponseChunk(const int8_t* chunk, uint32_t length) override
- {
- return true;
- }
-
-private:
- Dali::Property::Map mockHeadersMap;
-};
-
class MockWebEngineConsoleMessage : public Dali::WebEngineConsoleMessage
{
public:
std::string mockDefaultTextEncodingName;
};
+class MockWebEnginePlugin : public Dali::WebEnginePlugin
+{
+public:
+ MockWebEnginePlugin(){}
+ void Create(uint32_t width, uint32_t height, const std::string& locale, const std::string& timezoneId) override {}
+ void Create(uint32_t width, uint32_t height, uint32_t argc, char** argv) override {}
+ void Destroy() override {}
+ WebEngineSettings& GetSettings() const override { return *((WebEngineSettings*)&settings); }
+ WebEngineBackForwardList& GetBackForwardList() const override { return *((WebEngineBackForwardList*)&backForwardList); }
+ void LoadUrl(const std::string& url) override {}
+ std::string GetTitle() const override { return std::string(); }
+ Dali::PixelData GetFavicon() const override { return Dali::PixelData(); }
+ NativeImageSourcePtr GetNativeImageSource() override { return nullptr; }
+ std::string GetUrl() const override { return std::string(); }
+ void LoadHtmlString(const std::string& htmlString) override {}
+ bool LoadHtmlStringOverrideCurrentEntry(const std::string& html, const std::string& basicUri, const std::string& unreachableUrl) override { return false; }
+ bool LoadContents(const int8_t* contents, uint32_t contentSize, const std::string& mimeType, const std::string& encoding, const std::string& baseUri) override { return false; }
+ void Reload() override {}
+ bool ReloadWithoutCache() override { return false; }
+ void StopLoading() override {}
+ void Suspend() override {}
+ void Resume() override {}
+ void SuspendNetworkLoading() override {}
+ void ResumeNetworkLoading() override {}
+ bool AddCustomHeader(const std::string& name, const std::string& value) override { return false; }
+ bool RemoveCustomHeader(const std::string& name) override { return false; }
+ uint32_t StartInspectorServer(uint32_t port) override { return 0; }
+ bool StopInspectorServer() override { return false; }
+ void ScrollBy(int32_t deltaX, int32_t deltaY) override {}
+ bool ScrollEdgeBy(int32_t deltaX, int32_t deltaY) override { return false; }
+ void SetScrollPosition(int32_t x, int32_t y) override {}
+ Dali::Vector2 GetScrollPosition() const override { return Dali::Vector2(); }
+ Dali::Vector2 GetScrollSize() const override { return Dali::Vector2(); }
+ Dali::Vector2 GetContentSize() const override { return Dali::Vector2(); }
+ bool CanGoForward() override { return false; }
+ void GoForward() override {}
+ bool CanGoBack() override { return false; }
+ void GoBack() override {}
+ void EvaluateJavaScript(const std::string& script, JavaScriptMessageHandlerCallback resultHandler) override {}
+ void AddJavaScriptMessageHandler(const std::string& exposedObjectName, JavaScriptMessageHandlerCallback handler) override {}
+ void RegisterJavaScriptAlertCallback(JavaScriptAlertCallback callback) override {}
+ void JavaScriptAlertReply() override {}
+ void RegisterJavaScriptConfirmCallback(JavaScriptConfirmCallback callback) override {}
+ void JavaScriptConfirmReply(bool confirmed) override {}
+ void RegisterJavaScriptPromptCallback(JavaScriptPromptCallback callback) override {}
+ void JavaScriptPromptReply(const std::string& result) override {}
+ std::unique_ptr<Dali::WebEngineHitTest> CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode) override { return nullptr; }
+ bool CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, WebEngineHitTestCreatedCallback callback) override { return false; }
+ void ClearHistory() override {}
+ void ClearAllTilesResources() override {}
+ std::string GetUserAgent() const override { return std::string(); }
+ void SetUserAgent(const std::string& userAgent) override {}
+ void SetSize(uint32_t width, uint32_t height) override {}
+ void SetDocumentBackgroundColor(Dali::Vector4 color) override {}
+ void ClearTilesWhenHidden(bool cleared) override {}
+ void SetTileCoverAreaMultiplier(float multiplier) override {}
+ void EnableCursorByClient(bool enabled) override {}
+ std::string GetSelectedText() const override { return std::string(); }
+ bool SendTouchEvent(const TouchEvent& touch) override { return false; }
+ bool SendKeyEvent(const KeyEvent& event) override { return false; }
+ void EnableMouseEvents(bool enabled) override {}
+ void EnableKeyEvents(bool enabled) override {}
+ void SetFocus(bool focused) override {}
+ void SetPageZoomFactor(float zoomFactor) override {}
+ float GetPageZoomFactor() const override { return 0.0f; }
+ void SetTextZoomFactor(float zoomFactor) override {}
+ float GetTextZoomFactor() const override { return 0.0f; }
+ float GetLoadProgressPercentage() const override { return 0.0f; }
+ void SetScaleFactor(float scaleFactor, Dali::Vector2 point) override {}
+ float GetScaleFactor() const override { return 0.0f; }
+ void ActivateAccessibility(bool activated) override {}
+ Accessibility::Address GetAccessibilityAddress() override { return Accessibility::Address(); }
+ bool SetVisibility(bool visible) override { return false; }
+ bool HighlightText(const std::string& text, FindOption options, uint32_t maxMatchCount) override { return false; }
+ void AddDynamicCertificatePath(const std::string& host, const std::string& certPath) override {}
+ Dali::PixelData GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor) override { return Dali::PixelData(); }
+ bool GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, ScreenshotCapturedCallback callback) override { return false; }
+ bool CheckVideoPlayingAsynchronously(VideoPlayingCallback callback) override { return false; }
+ void RegisterGeolocationPermissionCallback(GeolocationPermissionCallback callback) override {}
+ void UpdateDisplayArea(Dali::Rect<int32_t> displayArea) override {}
+ void EnableVideoHole(bool enabled) override {}
+ bool SendHoverEvent(const HoverEvent& event) override { return false; }
+ bool SendWheelEvent(const WheelEvent& event) override { return false; }
+ void RegisterFrameRenderedCallback(WebEngineFrameRenderedCallback callback) override {}
+ void RegisterPageLoadStartedCallback(WebEnginePageLoadCallback callback) override {}
+ void RegisterPageLoadInProgressCallback(WebEnginePageLoadCallback callback) override {}
+ void RegisterPageLoadFinishedCallback(WebEnginePageLoadCallback callback) override {}
+ void RegisterPageLoadErrorCallback(WebEnginePageLoadErrorCallback callback) override {}
+ void RegisterScrollEdgeReachedCallback(WebEngineScrollEdgeReachedCallback callback) override {}
+ void RegisterUrlChangedCallback(WebEngineUrlChangedCallback callback) override {}
+ void RegisterFormRepostDecidedCallback(WebEngineFormRepostDecidedCallback callback) override {}
+ void RegisterConsoleMessageReceivedCallback(WebEngineConsoleMessageReceivedCallback callback) override {}
+ void RegisterResponsePolicyDecidedCallback(WebEngineResponsePolicyDecidedCallback callback) override {}
+ void RegisterNavigationPolicyDecidedCallback(WebEngineNavigationPolicyDecidedCallback callback) override {}
+ void RegisterNewWindowCreatedCallback(WebEngineNewWindowCreatedCallback callback) override {}
+ void RegisterCertificateConfirmedCallback(WebEngineCertificateCallback callback) override {}
+ void RegisterSslCertificateChangedCallback(WebEngineCertificateCallback callback) override {}
+ void RegisterHttpAuthHandlerCallback(WebEngineHttpAuthHandlerCallback callback) override {}
+ void RegisterContextMenuShownCallback(WebEngineContextMenuShownCallback callback) override {}
+ void RegisterContextMenuHiddenCallback(WebEngineContextMenuHiddenCallback callback) override {}
+ void GetPlainTextAsynchronously(PlainTextReceivedCallback callback) override {}
+private:
+ MockWebEngineSettings settings;
+ MockWebEngineBackForwardList backForwardList;
+};
+
+Dali::WebEnginePlugin* GetWebEnginePlugin()
+{
+ static MockWebEnginePlugin plugin;
+ return &plugin;
+}
+
+class MockWebEngineRequestInterceptor : public WebEngineRequestInterceptor
+{
+public:
+ MockWebEngineRequestInterceptor()
+ {
+ }
+
+ Dali::WebEnginePlugin* GetWebEngine() const
+ {
+ return GetWebEnginePlugin();
+ }
+
+ std::string GetUrl() const override
+ {
+ return "http://test.html";
+ }
+
+ Dali::Property::Map GetHeaders() const override
+ {
+ return mockHeadersMap;
+ }
+
+ std::string GetMethod() const override
+ {
+ return "GET";
+ }
+
+ bool Ignore() override
+ {
+ return true;
+ }
+
+ bool SetResponseStatus(int statusCode, const std::string& customedStatusText) override
+ {
+ return true;
+ }
+
+ bool AddResponseHeader(const std::string& fieldName, const std::string& fieldValue) override
+ {
+ mockHeadersMap.Add(fieldName, fieldValue);
+ return true;
+ }
+
+ bool AddResponseHeaders(const Dali::Property::Map& headers) override
+ {
+ mockHeadersMap.Merge(headers);
+ return true;
+ }
+
+ bool AddResponseBody(const int8_t* body, uint32_t length) override
+ {
+ return true;
+ }
+
+ bool AddResponse(const std::string& headers, const int8_t* body, uint32_t length) override
+ {
+ return true;
+ }
+
+ bool WriteResponseChunk(const int8_t* chunk, uint32_t length) override
+ {
+ return true;
+ }
+
+private:
+ Dali::Property::Map mockHeadersMap;
+};
+
class WebEngine: public Dali::BaseObject
{
public:
}
mockWebEngineSettings = new MockWebEngineSettings();
- MockWebEngineContext* engineContext = new MockWebEngineContext();
- mockWebEngineContext = engineContext;
- if ( gInstanceCount == 1 )
- {
- gWebEngineContextInstance = engineContext;
- }
- mockWebEngineCookieManager = new MockWebEngineCookieManager();
mockWebEngineBackForwardList = new MockWebEngineBackForwardList();
}
gInstanceCount--;
if( !gInstanceCount )
{
- gInstance = 0;
- gWebEngineContextInstance = 0;
+ gInstance = nullptr;
}
delete mockWebEngineSettings;
- delete mockWebEngineContext;
- delete mockWebEngineCookieManager;
delete mockWebEngineBackForwardList;
}
return *mockWebEngineSettings;
}
- Dali::WebEngineContext& GetContext() const
- {
- return *mockWebEngineContext;
- }
-
- Dali::WebEngineCookieManager& GetCookieManager() const
- {
- return *mockWebEngineCookieManager;
- }
-
Dali::WebEngineBackForwardList& GetBackForwardList() const
{
return *mockWebEngineBackForwardList;
}
}
- Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType& FrameRenderedSignal()
+ void RegisterFrameRenderedCallback(Dali::WebEnginePlugin::WebEngineFrameRenderedCallback callback)
{
- return mFrameRenderedSignal;
+ mFrameRenderedCallback = callback;
}
void RegisterPageLoadStartedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
mNavigationPolicyDecisionCallback = callback;
}
+ void RegisterNewWindowCreatedCallback(Dali::WebEnginePlugin::WebEngineNewWindowCreatedCallback callback)
+ {
+ mNewWindowCreatedCallback = callback;
+ }
+
void RegisterCertificateConfirmedCallback(Dali::WebEnginePlugin::WebEngineCertificateCallback callback)
{
mCertificateConfirmCallback = callback;
size_t mCurrentPlusOnePos;
std::string mUserAgent;
- Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType mFrameRenderedSignal;
-
bool mEvaluating;
float mPageZoomFactor;
float mTextZoomFactor;
Dali::Vector2 mScrollSize;
Dali::Vector2 mContentSize;
WebEngineBackForwardList* mockWebEngineBackForwardList;
- WebEngineContext* mockWebEngineContext;
- WebEngineCookieManager* mockWebEngineCookieManager;
WebEngineSettings* mockWebEngineSettings;
std::vector<Dali::WebEnginePlugin::JavaScriptMessageHandlerCallback> mResultCallbacks;
Dali::WebEnginePlugin::WebEngineConsoleMessageReceivedCallback mConsoleMessageCallback;
Dali::WebEnginePlugin::WebEngineResponsePolicyDecidedCallback mResponsePolicyDecisionCallback;
Dali::WebEnginePlugin::WebEngineNavigationPolicyDecidedCallback mNavigationPolicyDecisionCallback;
+ Dali::WebEnginePlugin::WebEngineNewWindowCreatedCallback mNewWindowCreatedCallback;
Dali::WebEnginePlugin::WebEngineCertificateCallback mCertificateConfirmCallback;
Dali::WebEnginePlugin::WebEngineCertificateCallback mSslCertificateChangedCallback;
Dali::WebEnginePlugin::WebEngineHttpAuthHandlerCallback mHttpAuthHandlerCallback;
std::unique_ptr<Dali::WebEngineFormRepostDecision> repostDecision(new MockWebEngineFormRepostDecision());
gInstance->mFormRepostDecidedCallback(std::move(repostDecision));
}
- gInstance->mFrameRenderedSignal.Emit();
if (gInstance->mFrameRenderedCallback)
{
gInstance->mFrameRenderedCallback();
std::unique_ptr<Dali::WebEnginePolicyDecision> policyDecision(new MockWebEnginePolicyDecision());
gInstance->mNavigationPolicyDecisionCallback(std::move(policyDecision));
}
+ if (gInstance->mNewWindowCreatedCallback)
+ {
+ Dali::WebEnginePlugin* plugin = 0;
+ gInstance->mNewWindowCreatedCallback(plugin);
+ }
if (gInstance->mCertificateConfirmCallback)
{
std::unique_ptr<Dali::WebEngineCertificate> certificate(new MockWebEngineCertificate());
bool OnChangesWatch()
{
- DisconnectFromGlobalSignal( &OnChangesWatch );
-
- if ( gInstance )
+ DisconnectFromGlobalSignal(&OnChangesWatch);
+ if (gMockWebEngineCookieManager)
{
- MockWebEngineCookieManager* temp = (MockWebEngineCookieManager *)(&(gInstance->GetCookieManager()));
- if ( temp )
- {
- temp->mChangesWatchCallback();
- }
+ gMockWebEngineCookieManager->mChangesWatchCallback();
}
-
return false;
}
return WebEngine( baseObject );
}
+Dali::WebEngineContext* WebEngine::GetContext()
+{
+ return Internal::Adaptor::GetContext();
+}
+
+Dali::WebEngineCookieManager* WebEngine::GetCookieManager()
+{
+ return Internal::Adaptor::GetCookieManager();
+}
+
WebEngine::WebEngine( const WebEngine& WebEngine )
: BaseHandle( WebEngine )
{
return Internal::Adaptor::GetImplementation( *this ).GetSettings();
}
-WebEngineContext& WebEngine::GetContext() const
-{
- return Internal::Adaptor::GetImplementation( *this ).GetContext();
-}
-
-WebEngineCookieManager& WebEngine::GetCookieManager() const
-{
- return Internal::Adaptor::GetImplementation( *this ).GetCookieManager();
-}
-
WebEngineBackForwardList& WebEngine::GetBackForwardList() const
{
return Internal::Adaptor::GetImplementation( *this ).GetBackForwardList();
return Internal::Adaptor::GetImplementation( *this ).GetUrl();
}
+Dali::WebEnginePlugin* WebEngine::GetPlugin() const
+{
+ return Internal::Adaptor::GetWebEnginePlugin();
+}
+
NativeImageSourcePtr WebEngine::GetNativeImageSource()
{
Any source;
return true;
}
-bool WebEngine::LoadContents(const std::string& contents, uint32_t contentSize, const std::string& mimeType, const std::string& encoding, const std::string& baseUri)
+bool WebEngine::LoadContents(const int8_t* contents, uint32_t contentSize, const std::string& mimeType, const std::string& encoding, const std::string& baseUri)
{
return true;
}
{
}
-Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType& WebEngine::FrameRenderedSignal()
+void WebEngine::RegisterFrameRenderedCallback(Dali::WebEnginePlugin::WebEngineFrameRenderedCallback callback)
{
- return Internal::Adaptor::GetImplementation(*this).FrameRenderedSignal();
+ Internal::Adaptor::GetImplementation(*this).RegisterFrameRenderedCallback(callback);
}
void WebEngine::RegisterPageLoadStartedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
Internal::Adaptor::GetImplementation(*this).RegisterNavigationPolicyDecidedCallback(callback);
}
+void WebEngine::RegisterNewWindowCreatedCallback(Dali::WebEnginePlugin::WebEngineNewWindowCreatedCallback callback)
+{
+ Internal::Adaptor::GetImplementation(*this).RegisterNewWindowCreatedCallback(callback);
+}
+
void WebEngine::RegisterCertificateConfirmedCallback(Dali::WebEnginePlugin::WebEngineCertificateCallback callback)
{
Internal::Adaptor::GetImplementation( *this ).RegisterCertificateConfirmedCallback(callback);
projects / platform / core / uifw / dali-toolkit.git / blobdiff