"//components/samsung/bpbookmark_model",
"//components/samsung/bpbookmark_image_model",
"//components/samsung/browser_config",
+ "//components/samsung/window_event_provider",
]
configs += [
"samsung/multi_language_controller.h",
"samsung/thread_booster_controller.cc",
"samsung/thread_booster_controller.h",
+ "samsung/multiscreen_controller.cc",
+ "samsung/multiscreen_controller.h",
+ "samsung/window_event_manager.cc",
+ "samsung/window_event_manager.h",
]
deps += [
"//chrome/app:samsung_strings",
--- /dev/null
+#include "chrome/browser/ui/samsung/multiscreen_controller.h"
+
+#include "base/logging.h"
+#include "chrome/browser/ui/samsung/samsung_browser_core.h"
+
+namespace samsung_browser_controller {
+
+MultiScreenController::MultiScreenController()
+{
+ LOG(INFO) << "Constructor start";
+}
+
+MultiScreenController::~MultiScreenController() {
+ LOG(INFO) << "Destructor start";
+ DeInit();
+}
+
+bool MultiScreenController::Init() {
+ LOG(INFO) <<"MultiScreenController::Init()";
+ auto bc = samsung_browser_main::SamsungBrowserCore::instance();
+ auto window_event_manager = bc->WindowEventManager();
+ window_event_manager->AddObserver(this);
+
+ auto system_configuration = bc->SystemConfiguration();
+ system_configuration->AddMlsModeChangedObserver(this);
+ return true;
+}
+
+void MultiScreenController::DeInit() {
+ LOG(INFO) << "MultiScreenController::DeInit()";
+ auto bc = samsung_browser_main::SamsungBrowserCore::instance();
+ auto window_event_manager = bc->WindowEventManager();
+ window_event_manager->RemoveObserver(this);
+
+ auto system_configuration = bc->SystemConfiguration();
+ system_configuration->RemoveMlsModeChangedObserver(this);
+}
+
+void MultiScreenController::EnterMultiScreen(){
+ LOG(INFO)<<"Entering multiscreen";
+ auto bc = samsung_browser_main::SamsungBrowserCore::instance();
+ auto window_event_manager = bc->WindowEventManager();
+ window_event_manager->EnterMultiScreen();
+}
+
+void MultiScreenController::ExitMultiScreen(){
+ LOG(INFO)<<"Exiting Multiscreen";
+ auto bc = samsung_browser_main::SamsungBrowserCore::instance();
+ auto window_event_manager = bc->WindowEventManager();
+ window_event_manager->ExitMultiScreen();
+}
+
+void MultiScreenController::CheckMlsState(){
+ auto bc = samsung_browser_main::SamsungBrowserCore::instance();
+ auto system_configuration = bc->SystemConfiguration();
+ int mls_state = system_configuration->GetInt(samsung_browser_fw_core::SamsungConfigKey::MLSState);
+ is_multi_screen_on_ = (mls_state == 1);
+}
+
+void MultiScreenController::RelayoutBrowserOnMultiScreenExit(){
+ auto bc = samsung_browser_main::SamsungBrowserCore::instance();
+ auto system_configuration = bc->SystemConfiguration();
+ int orientation_state = system_configuration->GetInt(samsung_browser_fw_core::SamsungConfigKey::Orientation);
+
+ if(orientation_state == 1){ //Landscape mode
+ auto browser = samsung_browser_main::SamsungBrowserCore::instance()->GetBrowserInstance();
+ browser->window()->SetBounds(gfx::Rect(0,0,1920,1080));
+ }
+ else{
+ //Portrait mode
+ //Need to implement
+ }
+}
+
+void MultiScreenController::onVirtualScreenGeometryChanged(int w, int h){
+ CheckMlsState();
+ LOG(INFO)<<"w: "<<w<<" h: "<<h<<" multiscreenState: "<<is_multi_screen_on_;
+ if(is_multi_screen_on_){
+ EnterMultiScreen();
+ auto browser = samsung_browser_main::SamsungBrowserCore::instance()->GetBrowserInstance();
+ browser->window()->SetBounds(gfx::Rect(0,0,w,h));
+ }
+}
+
+void MultiScreenController::MlsModeChanged(int mls_state){
+ is_multi_screen_on_ = (mls_state == 1);
+ if(!is_multi_screen_on_){
+ ExitMultiScreen();
+ RelayoutBrowserOnMultiScreenExit();
+ }
+}
+
+} // namespace samsung_browser_controller
--- /dev/null
+#ifndef CHROME_BROWSER_UI_SAMSUNG_MULTISCREEN_CONTROLLER_H_
+#define CHROME_BROWSER_UI_SAMSUNG_MULTISCREEN_CONTROLLER_H_
+
+#include "chrome/browser/ui/samsung/window_event_manager.h"
+#include "components/samsung/public/system_configuration/samsung_system_configuration.h"
+#include "components/samsung/public/system_configuration/samsung_system_configuration_observer.h"
+
+namespace samsung_browser_controller {
+
+class MultiScreenController:
+ public samsung_window_event_manager::WindowEventManager::Observer,
+ public samsung_browser_configuration::MlsModeChangedObserver {
+ public:
+ explicit MultiScreenController();
+ ~MultiScreenController();
+
+ MultiScreenController(const MultiScreenController&) = delete;
+ MultiScreenController& operator=(const MultiScreenController&) = delete;
+
+ bool Init();
+ void DeInit();
+ void EnterMultiScreen();
+ void ExitMultiScreen();
+ void onVirtualScreenGeometryChanged(int w, int h) override;
+ void MlsModeChanged(int value) override;
+ private:
+ void CheckMlsState();
+ void RelayoutBrowserOnMultiScreenExit();
+ bool is_multi_screen_on_;
+};
+} // namespace samsung_browser_controller
+
+#endif // CHROME_BROWSER_UI_SAMSUNG_MULTISCREEN_CONTROLLER_H_
#include "chrome/browser/ui/samsung/data_sync_manager.h"
#include "chrome/browser/ui/samsung/samsung_account_manager.h"
#include "chrome/browser/ui/samsung/thread_booster_controller.h"
+#include "chrome/browser/ui/samsung/multiscreen_controller.h"
+#include "chrome/browser/ui/samsung/window_event_manager.h"
#include "chrome/browser/ui/views/frame/browser_view.h"
#include "chrome/browser/ui/views/frame/toolbar_button_provider.h"
#include "chrome/browser/ui/views/profiles/avatar_toolbar_button.h"
SetWindowInstance();
m_thread_booster_controller =
std::make_unique<samsung_browser_controller::ThreadBoosterController>();
+ m_window_event_manager = std::make_unique<samsung_window_event_manager::WindowEventManager>();
+ m_window_event_manager->Init();
m_thread_booster_controller->Init();
m_input_manager = std::make_unique<samsung_input_manager::InputManager>();
m_input_manager->Init();
std::make_unique<samsung_browser_controller::MultiLanguageController>(
browser_);
m_multi_language_controller->Init();
-
+ m_multiscreen_controller = std::make_unique<samsung_browser_controller::MultiScreenController>();
+ m_multiscreen_controller->Init();
BrowserList::AddObserver(this);
m_initialized = true;
return true;
class SamsungWebContentsController;
class MCFController;
class ThreadBoosterController;
+class MultiScreenController;
}
namespace samsung_data_sync_manager {
class WebContents;
}
+namespace samsung_window_event_manager {
+class WindowEventManager;
+}
+
namespace samsung_browser_main {
class SamsungBrowserCore : public BrowserListObserver {
samsung_input_manager::InputManager* InputManager() {
return m_input_manager.get();
};
-
+ samsung_window_event_manager::WindowEventManager* WindowEventManager() {
+ return m_window_event_manager.get();
+ }
samsung_browser_controller::CursorController* CursorController() {
return m_cursor_controller.get();
};
std::unique_ptr<SamsungPass> m_samsung_pass;
std::unique_ptr<samsung_browser_controller::ThreadBoosterController>
m_thread_booster_controller;
+ std::unique_ptr<samsung_window_event_manager::WindowEventManager> m_window_event_manager;
+ std::unique_ptr<samsung_browser_controller::MultiScreenController> m_multiscreen_controller;
raw_ptr<Browser> browser_;
aura::WindowTreeHost* window_host;
bool m_initialized;
--- /dev/null
+// Use of this source code is governed by a BSD-style license that can be
+// Copyright 2023 Samsung Electronics. All rights reserved.
+// found in the LICENSE file.
+#include "chrome/browser/ui/samsung/window_event_manager.h"
+
+#include "base/logging.h"
+#include "chrome/browser/ui/samsung/samsung_browser_core.h"
+
+namespace samsung_window_event_manager {
+
+WindowEventManager::WindowEventManager()
+{
+ LOG(INFO) << "Constructor start";
+}
+
+WindowEventManager::~WindowEventManager() {
+ LOG(INFO) << "Destructor start";
+ DeInit();
+}
+
+bool WindowEventManager::Init() {
+ window_event_provider_ = std::make_unique<samsung_browser_main::WindowEventProvider>();
+ auto window_host = samsung_browser_main::SamsungBrowserCore::instance()->GetWindowInstance();
+ window_event_provider_->SetWindow(window_host);
+ window_event_provider_->Init();
+ window_event_provider_->AddObserver(this);
+ LOG(INFO) <<"WindowEventManager::Init()";
+ return true;
+}
+
+void WindowEventManager::DeInit() {
+ LOG(INFO) << "WindowEventManager::DeInit()";
+ window_event_provider_->RemoveObserver(this);
+}
+
+void WindowEventManager::AddObserver(Observer* observer) {
+ LOG(INFO) << "Adding observer";
+ m_observer_list.AddObserver(observer);
+}
+
+void WindowEventManager::RemoveObserver(Observer* observer) {
+ m_observer_list.RemoveObserver(observer);
+}
+
+void WindowEventManager::EnterMultiScreen(){
+ window_event_provider_->EnterMultiScreen();
+}
+
+void WindowEventManager::ExitMultiScreen(){
+ window_event_provider_->ExitMultiScreen();
+}
+
+void WindowEventManager::onVirtualScreenGeometryChanged(int w, int h){
+ LOG(INFO)<<"virtual screen geometry change : "<<w<<" "<<h;
+ for (auto& observer : m_observer_list) {
+ observer.onVirtualScreenGeometryChanged(w, h);
+ }
+}
+
+} // namespace samsung_browser_controller
--- /dev/null
+#ifndef CHROME_BROWSER_UI_SAMSUNG_WINDOW_EVENT_MANAGER_H_
+#define CHROME_BROWSER_UI_SAMSUNG_WINDOW_EVENT_MANAGER_H_
+
+#include "components/samsung/public/window_event_provider/window_event_provider.h"
+#include <memory>
+
+namespace samsung_window_event_manager {
+
+class WindowEventManager : public samsung_browser_main::WindowEventProvider::Observer {
+ public:
+ explicit WindowEventManager();
+ ~WindowEventManager();
+ WindowEventManager(const WindowEventManager&) = delete;
+ WindowEventManager& operator=(const WindowEventManager&) = delete;
+
+ class Observer {
+ public:
+ virtual ~Observer() = default;
+ virtual void onVirtualScreenGeometryChanged(int w, int h) {}
+ };
+
+ bool Init();
+ void DeInit();
+ void AddObserver(Observer* observer);
+ void RemoveObserver(Observer* observer);
+ void ExitMultiScreen();
+ void EnterMultiScreen();
+ void onVirtualScreenGeometryChanged(int w, int h) override;
+ private:
+ std::unique_ptr<samsung_browser_main::WindowEventProvider> window_event_provider_;
+ base::ObserverList<Observer>::Unchecked m_observer_list;
+};
+} // namespace samsung_browser_controller
+
+#endif // CHROME_BROWSER_UI_SAMSUNG_MULTISCREEN_CONTROLLER_H_
--- /dev/null
+#include "components/samsung/public/window_event_provider/window_event_provider.h"
+
+#include "base/logging.h"
+#include "components/samsung/window_event_provider/window_event_provider_impl.h"
+
+namespace samsung_browser_main {
+
+WindowEventProvider::WindowEventProvider() {}
+
+WindowEventProvider::~WindowEventProvider() {
+ Deinit();
+}
+
+void WindowEventProvider::Init() {
+ LOG(INFO) << "init called!!";
+ window_event_provider_impl_ = std::make_unique<WindowEventProviderImpl>(this);
+ window_event_provider_impl_->SetWindow(window_host_);
+ window_event_provider_impl_->Init();
+}
+
+void WindowEventProvider::Deinit() {}
+
+bool WindowEventProvider::ReInit() {
+ LOG(INFO) << "";
+ window_event_provider_impl_->DeInit();
+ window_event_provider_impl_->Init();
+ return true;
+}
+
+void WindowEventProvider::SetWindow(aura::WindowTreeHost* window_host) {
+ LOG(INFO) << "";
+ window_host_ = window_host;
+}
+
+void WindowEventProvider::AddObserver(Observer* observer) {
+ LOG(INFO) << "Adding observer";
+ m_observer_list.AddObserver(observer);
+}
+
+void WindowEventProvider::RemoveObserver(Observer* observer) {
+ m_observer_list.RemoveObserver(observer);
+}
+
+void WindowEventProvider::EnterMultiScreen(){
+ window_event_provider_impl_->EnterMultiScreen();
+}
+
+void WindowEventProvider::ExitMultiScreen(){
+ window_event_provider_impl_->ExitMultiScreen();
+}
+
+void WindowEventProvider::onVirtualScreenGeometryChanged(int w, int h){
+ for (auto& observer : m_observer_list) {
+ observer.onVirtualScreenGeometryChanged(w, h);
+ }
+}
+
+} // namespace samsung_browser_main
--- /dev/null
+#ifndef COMPONENTS_SAMSUNG_PUBLIC_WINDOW_EVENT_PROVIDER_WINDOW_EVENT_PROVIDER_H_
+#define COMPONENTS_SAMSUNG_PUBLIC_WINDOW_EVENT_PROVIDER_WINDOW_EVENT_PROVIDER_H_
+
+#include <memory>
+#include "ui/aura/window_tree_host_platform.h"
+
+namespace samsung_browser_main {
+
+class WindowEventProviderImpl;
+
+class WindowEventProvider {
+ public:
+ explicit WindowEventProvider();
+ ~WindowEventProvider();
+
+ WindowEventProvider(const WindowEventProvider&) = delete;
+ WindowEventProvider& operator=(const WindowEventProvider&) = delete;
+ void Init();
+ void Deinit();
+ bool ReInit();
+
+ class Observer {
+ public:
+ virtual ~Observer() = default;
+ virtual void onVirtualScreenGeometryChanged(int w, int h) {}
+ };
+
+ void AddObserver(Observer* observer);
+ void RemoveObserver(Observer* observer);
+ void SetWindow(aura::WindowTreeHost* window_host);
+ void onVirtualScreenGeometryChanged(int w, int h);
+ void EnterMultiScreen();
+ void ExitMultiScreen();
+private:
+ aura::WindowTreeHost* window_host_;
+ base::ObserverList<Observer>::Unchecked m_observer_list;
+ std::unique_ptr<WindowEventProviderImpl> window_event_provider_impl_;
+};
+} // namespace samsung_browser_main
+#endif // COMPONENTS_SAMSUNG_WINDOW_EVENT_PROVIDER_H
--- /dev/null
+
+source_set("window_event_provider") {
+ sources = [
+ "../public/window_event_provider/window_event_provider.cc",
+ "../public/window_event_provider/window_event_provider.h",
+ "window_event_provider_impl.cc",
+ "window_event_provider_impl.h",
+ ]
+
+ public_deps = [ "//base" ]
+
+ deps = [
+ "//skia",
+ "//ui/aura",
+ ]
+
+ configs += [
+ "//tizen_src/build:ecore",
+ "//tizen_src/build:libecore",
+ "//tizen_src/build:ecore-evas",
+ "//tizen_src/build:libecore-evas",
+ "//tizen_src/build:elementary",
+ "//tizen_src/build:libelementary",
+ "//tizen_src/build:capi-window-tv",
+ "//tizen_src/build:libcapi-window-tv",
+ ]
+
+}
--- /dev/null
+#include "components/samsung/window_event_provider/window_event_provider_impl.h"
+
+#include "base/logging.h"
+#include "components/samsung/public/window_event_provider/window_event_provider.h"
+#include "tizen_src/chromium_impl/ui/ozone/platform/efl/efl_window.h"
+
+constexpr int invalidMultiViewSize = 32;
+
+namespace samsung_browser_main {
+
+WindowEventProviderImpl::WindowEventProviderImpl(WindowEventProvider* window_event_provider)
+ : window_event_provider_(window_event_provider) {}
+
+
+WindowEventProviderImpl::~WindowEventProviderImpl() {
+ DeInit();
+}
+
+void WindowEventProviderImpl::Init() {
+ LOG(INFO) << "init called!!";
+}
+
+void WindowEventProviderImpl::DeInit() {
+ LOG(INFO) << "destructor is called";
+}
+
+void WindowEventProviderImpl::SetWindow(aura::WindowTreeHost* window_host) {
+ LOG(INFO) << "";
+ window_host_ = window_host;
+ ui::EflWindow* window = static_cast<ui::EflWindow*>(
+ static_cast<aura::WindowTreeHostPlatform*>(window_host)
+ ->platform_window());
+ LOG(INFO) << "Got EFL Window";
+ if(window){
+ window->RegisterVirtualScreenGeometryChangeCallback((void *)onVirtualScreenGeometryChanged, (void *)this);
+ window->SetAuxHint("wm.policy.win.user.geometry", "1");
+ }
+}
+
+void WindowEventProviderImpl::ExitMultiScreen(){
+ LOG(INFO)<<"Exiting multiscreen";
+ ui::EflWindow* window = static_cast<ui::EflWindow*>(static_cast<aura::WindowTreeHostPlatform*>(window_host_)->platform_window());
+ if(window){
+ window->SetAuxHint("wm.policy.win.transform.mode", "manual");
+ }
+}
+
+void WindowEventProviderImpl::EnterMultiScreen(){
+ LOG(INFO)<<"Entering multiscreen";
+ ui::EflWindow* window = static_cast<ui::EflWindow*>(static_cast<aura::WindowTreeHostPlatform*>(window_host_)->platform_window());
+ if(window){
+ window->SetAuxHint("wm.policy.win.transform.mode", "ratiofit");
+ }
+}
+
+void WindowEventProviderImpl::onVirtualScreenGeometryChanged(int vs_id, int x, int y, int width, int height, int angle, void* data){
+ LOG(INFO)<<" x: "<<x<<" y: "<<y<<" width: "<<width<<" height: "<<height<<" angle: "<<angle;
+ LOG(INFO)<<"vs_id: "<<vs_id;
+ if (vs_id == 0 || vs_id == -1)
+ {
+ LOG(INFO)<<"Invalid VirtualID";
+ return;
+ }
+
+ if(width<= invalidMultiViewSize || height<= invalidMultiViewSize)
+ {
+ LOG(INFO)<<"Do not Resize : width or height is less than 33";
+ return;
+ }
+ WindowEventProviderImpl* self = static_cast<WindowEventProviderImpl*>(data);
+ if(!self){
+ LOG(INFO)<<"cast to seld failed";
+ return;
+ }
+ int aspectRatio=((float)width/(float)height)*10;
+ int w = 0, h = 0;
+ if(aspectRatio==17)
+ {
+ LOG(INFO)<<"Resizing to 1920*1080 and not setting webview's rotation";
+ w = 1920;
+ h = 1080;
+ }
+ else if(aspectRatio==5)
+ {
+ LOG(INFO)<<"Resizing to 1080*1920 and not setting webview's rotation";
+ w = 1080;
+ h = 1920;
+ }
+ else
+ {
+ w = 1920;
+ h = 1080;
+ if(width<=height)
+ {
+ w=1080;
+ }
+ h=((((float)height/(float)width)*1000)*w)/1000;
+ LOG(INFO)<<"[Not in Fixed Aspect ";
+ }
+ LOG(INFO)<<"w: "<<w<<" h: "<<h;
+ self->window_event_provider_->onVirtualScreenGeometryChanged(w,h);
+}
+
+} // namespace samsung_browser_main
--- /dev/null
+#ifndef COMPONENTS_SAMSUNG_WINDOW_EVENT_PROVIDER_WINDOW_EVENT_PROVIDER_IMPL_H_
+#define COMPONENTS_SAMSUNG_WINDOW_EVENT_PROVIDER_WINDOW_EVENT_PROVIDER_IMPL_H_
+
+//#include <memory>
+#include "ui/aura/window_tree_host_platform.h"
+
+namespace samsung_browser_main {
+
+class WindowEventProvider;
+
+class WindowEventProviderImpl {
+ public:
+ explicit WindowEventProviderImpl(WindowEventProvider*);
+ ~WindowEventProviderImpl();
+
+ WindowEventProviderImpl(const WindowEventProvider&) = delete;
+ WindowEventProviderImpl& operator=(const WindowEventProvider&) = delete;
+ void Init();
+ void DeInit();
+ void SetWindow(aura::WindowTreeHost* window_host);
+ void EnterMultiScreen();
+ void ExitMultiScreen();
+ static void onVirtualScreenGeometryChanged(int vs_id,int x, int y, int width, int height, int angle, void* data);
+ private:
+ std::unique_ptr<WindowEventProvider> window_event_provider_;
+ aura::WindowTreeHost* window_host_;
+};
+} // namespace samsung_browser_main
+#endif // COMPONENTS_SAMSUNG_WINDOW_EVENT_PROVIDER_WINDOW_EVENT_PROVIDER_IMPL_H_
#include "tizen_src/chromium_impl/ui/ozone/platform/efl/video_controller.h"
#endif
+#if defined(SAMSUNG_NEXT_BROWSER)
+#include <capi_window_tv_window_manager.h>
+#endif
+
namespace ui {
namespace {
delegate_->OnLostCapture();
}
+#if defined(SAMSUNG_NEXT_BROWSER)
+void EflWindow::RegisterVirtualScreenGeometryChangeCallback(void* callback, void* data){
+ capi_window_tv_set_virtualscreen_geometry_changed_callback(elm_win_, (capi_window_tv_virtualscreen_geometry_change_callback)callback, data);
+}
+
+void EflWindow::SetAuxHint(std::string hint, std::string value){
+ elm_win_aux_hint_add(elm_win_, hint.c_str(), value.c_str());
+}
+#endif
+
uint32_t EflWindow::DispatchEventToDelegate(const PlatformEvent& event) {
bool handled = DispatchEventFromNativeUiEvent(
event, base::BindOnce(&PlatformWindowDelegate::DispatchEvent,
void SetFocus(bool focused) { has_focus_ = focused; }
void OnWindowLostCapture();
-
+#if defined(SAMSUNG_NEXT_BROWSER)
+ void RegisterVirtualScreenGeometryChangeCallback(void* callback, void* data);
+ void SetAuxHint(std::string hint, std::string value);
+#endif
static void OnEcoreEvasResize(Ecore_Evas* ee);
Evas* evas() const { return evas_; }
projects / platform / framework / web / chromium-efl.git / commitdiff