From: Wonsik Jung Date: Fri, 30 Jun 2023 07:53:19 +0000 (+0900) Subject: Supports Pre-Initialized for UI Threading X-Git-Tag: dali_2.2.34~3 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=fe182b48bca7f8b3ed73a804f1d162a10319ee4b;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git Supports Pre-Initialized for UI Threading This patch is to support pre-initialized using Tizen Preloader for UI Threading. Next step, the related feature will be refactoring using factory pattern. Change-Id: Ib143b02906970fb878ef21c423e5aaebad3d967b --- diff --git a/dali/internal/adaptor/android/framework-android.cpp b/dali/internal/adaptor/android/framework-android.cpp index c0ccb13..e08b03d 100644 --- a/dali/internal/adaptor/android/framework-android.cpp +++ b/dali/internal/adaptor/android/framework-android.cpp @@ -668,6 +668,49 @@ bool FrameworkAndroid::AppStatusHandler(int type, void* data) return true; } +/** + * Impl for Pre-Initailized using UI Thread. + */ +struct UIThreadLoader::Impl +{ + // Constructor + + Impl(void *data) + { + } + + ~Impl() + { + } + + void Run(Runner runner) + { + } + +private: + // Undefined + Impl(const Impl& impl); + Impl& operator=(const Impl& impl); +}; + +/** + * UI Thread loader to support Pre-Initailized using UI Thread. + */ +UIThreadLoader::UIThreadLoader(int* argc, char*** argv) +: mArgc(argc), + mArgv(argv), + mImpl(nullptr) +{ +} + +UIThreadLoader::~UIThreadLoader() +{ +} + +void UIThreadLoader::Run(Runner runner) +{ +} + } // namespace Adaptor } // namespace Internal diff --git a/dali/internal/adaptor/androidjni/framework-androidjni.cpp b/dali/internal/adaptor/androidjni/framework-androidjni.cpp index d699f76..4fd36c1 100644 --- a/dali/internal/adaptor/androidjni/framework-androidjni.cpp +++ b/dali/internal/adaptor/androidjni/framework-androidjni.cpp @@ -191,6 +191,49 @@ bool FrameworkAndroidJni::AppStatusHandler(int type, void* data) return true; } +/** + * Impl for Pre-Initailized using UI Thread. + */ +struct UIThreadLoader::Impl +{ + // Constructor + + Impl(void *data) + { + } + + ~Impl() + { + } + + void Run(Runner runner) + { + } + +private: + // Undefined + Impl(const Impl& impl); + Impl& operator=(const Impl& impl); +}; + +/** + * UI Thread loader to support Pre-Initailized using UI Thread. + */ +UIThreadLoader::UIThreadLoader(int* argc, char*** argv) +: mArgc(argc), + mArgv(argv), + mImpl(nullptr) +{ +} + +UIThreadLoader::~UIThreadLoader() +{ +} + +void UIThreadLoader::Run(Runner runner) +{ +} + } // namespace Adaptor } // namespace Internal diff --git a/dali/internal/adaptor/common/application-impl.cpp b/dali/internal/adaptor/common/application-impl.cpp index d81c67b..9bad3be 100644 --- a/dali/internal/adaptor/common/application-impl.cpp +++ b/dali/internal/adaptor/common/application-impl.cpp @@ -81,11 +81,35 @@ void Application::PreInitialize(int* argc, char** argv[]) { if(!gPreInitializedApplication) { + char* retEnv = std::getenv("TIZEN_UI_THREAD"); + bool isUseUIThread = false; + if(retEnv) + { + std::string uiThreadEnv = retEnv; + std::string enabledString = "true"; + if(uiThreadEnv == enabledString) + { + isUseUIThread = true; + } + } + Dali::TextAbstraction::FontClientPreInitialize(); WindowData windowData; - gPreInitializedApplication = new Application(argc, argv, "", Framework::NORMAL, false, windowData); + gPreInitializedApplication = new Application(argc, argv, "", Framework::NORMAL, isUseUIThread, windowData); gPreInitializedApplication->mLaunchpadState = Launchpad::PRE_INITIALIZED; - gPreInitializedApplication->CreateWindow(); // Only create window + if(isUseUIThread) + { + DALI_LOG_RELEASE_INFO("PRE_INITIALIZED with UI Threading"); + gPreInitializedApplication->mUIThreadLoader = new UIThreadLoader(argc, argv); + gPreInitializedApplication->mUIThreadLoader->Run([&](){gPreInitializedApplication->CreateWindow();}); + } + else + { + DALI_LOG_RELEASE_INFO("Only PRE_INITIALIZED"); + gPreInitializedApplication->CreateWindow(); // Only create window + } + + } } @@ -112,7 +136,8 @@ Application::Application(int* argc, char** argv[], const std::string& stylesheet mDefaultWindowType(windowData.GetWindowType()), mUseUiThread(useUiThread), mIsSystemInitialized(false), - mSlotDelegate(this) + mSlotDelegate(this), + mUIThreadLoader(nullptr) { // Set mName from command-line args if(argc && (*argc > 0)) @@ -157,6 +182,13 @@ Application::~Application() WindowSystem::Shutdown(); } } + else + { + if(mUIThreadLoader) + { + delete mUIThreadLoader; + } + } } void Application::StoreWindowPositionSize(PositionSize positionSize) @@ -216,6 +248,8 @@ void Application::CreateWindow() windowData.SetTransparency(mMainWindowMode); windowData.SetWindowType(mDefaultWindowType); + DALI_LOG_RELEASE_INFO("Create Default Window"); + WindowSystem::Initialize(); mIsSystemInitialized = true; @@ -318,6 +352,7 @@ void Application::OnInit() // If an application was pre-initialized, a window was made in advance if(mLaunchpadState == Launchpad::NONE) { + DALI_LOG_RELEASE_INFO("default Window is created in standalone"); CreateWindow(); } diff --git a/dali/internal/adaptor/common/application-impl.h b/dali/internal/adaptor/common/application-impl.h index 8127322..914664a 100644 --- a/dali/internal/adaptor/common/application-impl.h +++ b/dali/internal/adaptor/common/application-impl.h @@ -544,6 +544,7 @@ private: SlotDelegate mSlotDelegate; + UIThreadLoader* mUIThreadLoader; static ApplicationPtr gPreInitializedApplication; }; diff --git a/dali/internal/adaptor/common/framework.h b/dali/internal/adaptor/common/framework.h index 23244eb..894bb88 100644 --- a/dali/internal/adaptor/common/framework.h +++ b/dali/internal/adaptor/common/framework.h @@ -332,7 +332,7 @@ private: private: // Undefined - Framework(const Framework&) = delete; + Framework(const Framework&) = delete; Framework& operator=(Framework&) = delete; protected: @@ -345,6 +345,43 @@ protected: bool mRunning; }; +class UIThreadLoader +{ +public: + using Runner = std::function; + + /** + * Constructor + * @param[in] argc A pointer to the number of arguments. + * @param[in] argv A pointer the the argument list. + */ + UIThreadLoader(int* argc, char*** argv); + + /** + * Destructor + */ + ~UIThreadLoader(); + +public: + /** + * Runs the main loop of framework + */ + void Run(Runner runner); + +private: + // Undefined + UIThreadLoader(const UIThreadLoader&); + UIThreadLoader& operator=(UIThreadLoader&); + +private: + int* mArgc; + char*** mArgv; + +private: // impl members + struct Impl; + Impl* mImpl; +}; + } // namespace Adaptor } // namespace Internal diff --git a/dali/internal/adaptor/libuv/framework-libuv.cpp b/dali/internal/adaptor/libuv/framework-libuv.cpp index bce2382..cc32e05 100644 --- a/dali/internal/adaptor/libuv/framework-libuv.cpp +++ b/dali/internal/adaptor/libuv/framework-libuv.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015 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. @@ -109,6 +109,49 @@ void FrameworkLibuv::Quit() mImpl->Quit(); } +/** + * Impl for Pre-Initailized using UI Thread. + */ +struct UIThreadLoader::Impl +{ + // Constructor + + Impl(void *data) + { + } + + ~Impl() + { + } + + void Run(Runner runner) + { + } + +private: + // Undefined + Impl(const Impl& impl); + Impl& operator=(const Impl& impl); +}; + +/** + * UI Thread loader to support Pre-Initailized using UI Thread. + */ +UIThreadLoader::UIThreadLoader(int* argc, char*** argv) +: mArgc(argc), + mArgv(argv), + mImpl(nullptr) +{ +} + +UIThreadLoader::~UIThreadLoader() +{ +} + +void UIThreadLoader::Run(Runner runner) +{ +} + } // namespace Adaptor } // namespace Internal diff --git a/dali/internal/adaptor/macos/framework-mac.mm b/dali/internal/adaptor/macos/framework-mac.mm index cb7b71f..8f88f54 100644 --- a/dali/internal/adaptor/macos/framework-mac.mm +++ b/dali/internal/adaptor/macos/framework-mac.mm @@ -120,6 +120,49 @@ bool FrameworkMac::AppStatusHandler(int type, void *) return true; } +/** + * Impl for Pre-Initailized using UI Thread. + */ +struct UIThreadLoader::Impl +{ + // Constructor + + Impl(void *data) + { + } + + ~Impl() + { + } + + void Run(Runner runner) + { + } + +private: + // Undefined + Impl(const Impl& impl); + Impl& operator=(const Impl& impl); +}; + +/** + * UI Thread loader to support Pre-Initailized using UI Thread. + */ +UIThreadLoader::UIThreadLoader(int* argc, char*** argv) +: mArgc(argc), + mArgv(argv), + mImpl(nullptr) +{ +} + +UIThreadLoader::~UIThreadLoader() +{ +} + +void UIThreadLoader::Run(Runner runner) +{ +} + } // namespace Adaptor } // namespace Internal diff --git a/dali/internal/adaptor/tizen-wayland/framework-tizen.cpp b/dali/internal/adaptor/tizen-wayland/framework-tizen.cpp index 46fcc4b..ec679e3 100644 --- a/dali/internal/adaptor/tizen-wayland/framework-tizen.cpp +++ b/dali/internal/adaptor/tizen-wayland/framework-tizen.cpp @@ -29,6 +29,7 @@ #include #include #include +#include // CONDITIONAL INCLUDES #ifdef APPCORE_WATCH_AVAILABLE @@ -1396,6 +1397,81 @@ std::string FrameworkTizen::GetRegion() const return mImpl->GetRegion(); } +/** + * Impl for Pre-Initailized using UI Thread. + */ +struct UIThreadLoader::Impl +{ + // Constructor + Impl(void *data) + { + mUIThreadLoader = static_cast(data); + mAppCoreUiThreadBase = new AppCoreUiThreadBase(); + print_log(DLOG_INFO, "DALI", "%s: %s(%d) > Create mAppCoreUiThreadBase(%p)", __MODULE__, __func__, __LINE__, mAppCoreUiThreadBase); + } + + // Destructor + ~Impl() + { + if(mAppCoreUiThreadBase) + { + mAppCoreUiThreadBase->Exit(); + delete mAppCoreUiThreadBase; + } + } + + /** + * Runs to work create window in UI thread when application is pre-initialized. + */ + void Run(Runner runner) + { + mAppCoreUiThreadBase->Post(runner); + mAppCoreUiThreadBase->Run(*(mUIThreadLoader->mArgc), *(mUIThreadLoader->mArgv)); + } + +private: + // Undefined + Impl(const Impl& impl); + Impl& operator=(const Impl& impl); + + // Data + AppCoreUiThreadBase* mAppCoreUiThreadBase; + UIThreadLoader* mUIThreadLoader; +}; + +/** + * UI Thread loader to support Pre-Initailized using UI Thread. + */ +UIThreadLoader::UIThreadLoader(int* argc, char*** argv) +: mArgc(argc), + mArgv(argv), + mImpl(nullptr) +{ + if(mArgc == nullptr || mArgv == nullptr) + { + mArgc = const_cast(&gTizenDummyArgc); + mArgv = const_cast(reinterpret_cast(&gTizenDummyArgv)); + } + + mImpl = new Impl(this); +} + +UIThreadLoader::~UIThreadLoader() +{ + if(mImpl) + { + delete mImpl; + } +} + +/** + * Runs to work create window in UI thread when application is pre-initialized. + */ +void UIThreadLoader::Run(Runner runner) +{ + mImpl->Run(runner); +} + } // namespace Adaptor } // namespace Internal diff --git a/dali/internal/adaptor/ubuntu/framework-ubuntu.cpp b/dali/internal/adaptor/ubuntu/framework-ubuntu.cpp index ab4f353..7ad9005 100644 --- a/dali/internal/adaptor/ubuntu/framework-ubuntu.cpp +++ b/dali/internal/adaptor/ubuntu/framework-ubuntu.cpp @@ -71,6 +71,48 @@ void FrameworkUbuntu::InitThreads() XInitThreads(); } +/** + * Impl for Pre-Initailized using UI Thread. + */ +struct UIThreadLoader::Impl +{ + // Constructor + Impl(void *data) + { + } + + ~Impl() + { + } + + void Run(Runner runner) + { + } + +private: + // Undefined + Impl(const Impl& impl); + Impl& operator=(const Impl& impl); +}; + +/** + * UI Thread loader to support Pre-Initailized using UI Thread. + */ +UIThreadLoader::UIThreadLoader(int* argc, char*** argv) +: mArgc(argc), + mArgv(argv), + mImpl(nullptr) +{ +} + +UIThreadLoader::~UIThreadLoader() +{ +} + +void UIThreadLoader::Run(Runner runner) +{ +} + } // namespace Adaptor } // namespace Internal diff --git a/dali/internal/adaptor/windows/framework-win.cpp b/dali/internal/adaptor/windows/framework-win.cpp index 90e3fa9..bc2c31e 100644 --- a/dali/internal/adaptor/windows/framework-win.cpp +++ b/dali/internal/adaptor/windows/framework-win.cpp @@ -106,6 +106,51 @@ void FrameworkWin::Quit() mObserver.OnTerminate(); } +/** + * Impl for Pre-Initailized using UI Thread. + */ +struct UIThreadLoader::Impl +{ + // Constructor + Impl(void *data) + { + } + + ~Impl() + { + } + + /** + * Runs the main loop of framework + */ + void Run(Runner runner) + { + } + +private: + // Undefined + Impl(const Impl& impl); + Impl& operator=(const Impl& impl); +}; + +/** + * UI Thread loader to support Pre-Initailized using UI Thread. + */ +UIThreadLoader::UIThreadLoader(int* argc, char*** argv) +: mArgc(argc), + mArgv(argv), + mImpl(nullptr) +{ +} + +UIThreadLoader::~UIThreadLoader() +{ +} + +void UIThreadLoader::Run(Runner runner) +{ +} + } // namespace Adaptor } // namespace Internal