X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fadaptor%2Fcommon%2Fapplication-impl.cpp;h=0f18afa847c6db95294526fdaf2576203a87cded;hb=738fd571c706537f8897163684fcb9d3fd9d535e;hp=97a23e0e5e85726c15d42948841327eb4e79913f;hpb=da971ffe08bf5d340f0635105e00a1154c8adfcf;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git diff --git a/dali/internal/adaptor/common/application-impl.cpp b/dali/internal/adaptor/common/application-impl.cpp index 97a23e0..0f18afa 100644 --- a/dali/internal/adaptor/common/application-impl.cpp +++ b/dali/internal/adaptor/common/application-impl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 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. @@ -26,13 +26,17 @@ // INTERNAL INCLUDES #include +#include #include #include #include #include +#include #include #include #include +#include +#include #include #include #include @@ -62,15 +66,14 @@ DALI_INIT_TRACE_FILTER(gTraceFilter, DALI_TRACE_APPLICATION, true); ApplicationPtr Application::gPreInitializedApplication(NULL); ApplicationPtr Application::New( - int* argc, - char** argv[], - const std::string& stylesheet, - Dali::Application::WINDOW_MODE windowMode, - const PositionSize& positionSize, - Framework::Type applicationType, - WindowType type) -{ - ApplicationPtr application(new Application(argc, argv, stylesheet, windowMode, positionSize, applicationType, type)); + int* argc, + char** argv[], + const std::string& stylesheet, + Framework::Type applicationType, + bool useUiThread, + const WindowData& windowData) +{ + ApplicationPtr application(new Application(argc, argv, stylesheet, applicationType, useUiThread, windowData)); return application; } @@ -78,15 +81,43 @@ void Application::PreInitialize(int* argc, char** argv[]) { if(!gPreInitializedApplication) { - Dali::TextAbstraction::FontClientPreInitialize(); + bool isUseUIThread = false; + +#ifdef UI_THREAD_AVAILABLE + char* retEnv = std::getenv("TIZEN_UI_THREAD"); + if(retEnv) + { + std::string uiThreadEnv = retEnv; + std::string enabledString = "true"; + if(uiThreadEnv == enabledString) + { + isUseUIThread = true; + } + } +#endif - gPreInitializedApplication = new Application(argc, argv, "", Dali::Application::OPAQUE, PositionSize(), Framework::NORMAL, WindowType::NORMAL); - gPreInitializedApplication->CreateWindow(); // Only create window + Dali::TextAbstraction::FontClientPreInitialize(); + WindowData windowData; + gPreInitializedApplication = new Application(argc, argv, "", Framework::NORMAL, isUseUIThread, windowData); gPreInitializedApplication->mLaunchpadState = Launchpad::PRE_INITIALIZED; + +#ifdef UI_THREAD_AVAILABLE + if(isUseUIThread) + { + DALI_LOG_RELEASE_INFO("PRE_INITIALIZED with UI Threading"); + gPreInitializedApplication->mUIThreadLoader = new UIThreadLoader(argc, argv); + gPreInitializedApplication->mUIThreadLoader->Run([&]() { gPreInitializedApplication->CreateWindow(); }); + } + else +#endif + { + DALI_LOG_RELEASE_INFO("Only PRE_INITIALIZED"); + gPreInitializedApplication->CreateWindow(); // Only create window + } } } -Application::Application(int* argc, char** argv[], const std::string& stylesheet, Dali::Application::WINDOW_MODE windowMode, const PositionSize& positionSize, Framework::Type applicationType, WindowType type) +Application::Application(int* argc, char** argv[], const std::string& stylesheet, Framework::Type applicationType, bool useUiThread, const WindowData& windowData) : mInitSignal(), mTerminateSignal(), mPauseSignal(), @@ -95,32 +126,43 @@ Application::Application(int* argc, char** argv[], const std::string& stylesheet mAppControlSignal(), mLanguageChangedSignal(), mRegionChangedSignal(), - mEventLoop(nullptr), mFramework(nullptr), + mFrameworkFactory(nullptr), mCommandLineOptions(nullptr), mAdaptorBuilder(nullptr), mAdaptor(nullptr), + mEnvironmentOptions(nullptr), mMainWindow(), - mMainWindowMode(windowMode), + mMainWindowMode(windowData.GetTransparency() ? WINDOW_MODE::TRANSPARENT : WINDOW_MODE::OPAQUE), mMainWindowName(), + mIsMainWindowFrontBufferRendering(windowData.GetFrontBufferRendering()), mStylesheet(stylesheet), - mEnvironmentOptions(), - mWindowPositionSize(positionSize), + mWindowPositionSize(windowData.GetPositionSize()), mLaunchpadState(Launchpad::NONE), - mDefaultWindowType(type), - mSlotDelegate(this) -{ - // Get mName from environment options - mMainWindowName = mEnvironmentOptions.GetWindowName(); - if(mMainWindowName.empty() && argc && (*argc > 0)) + mDefaultWindowType(windowData.GetWindowType()), + mUseUiThread(useUiThread), + mIsSystemInitialized(false), + mSlotDelegate(this), + mUIThreadLoader(nullptr) +{ + // Set mName from command-line args + if(argc && (*argc > 0)) { - // Set mName from command-line args if environment option not set mMainWindowName = (*argv)[0]; } + const char* uiThreadEnabled = Dali::EnvironmentVariable::GetEnvironmentVariable(DALI_ENV_ENABLE_UI_THREAD); + if(uiThreadEnabled && std::atoi(uiThreadEnabled) != 0) + { + mUseUiThread = true; + } + mCommandLineOptions = new CommandLineOptions(argc, argv); - mFramework = new Framework(*this, argc, argv, applicationType); - mUseRemoteSurface = (applicationType == Framework::WATCH); + + mFrameworkFactory = std::unique_ptr(Dali::Internal::Adaptor::CreateFrameworkFactory()); + mFramework = mFrameworkFactory->CreateFramework(FrameworkBackend::DEFAULT, *this, *this, argc, argv, applicationType, mUseUiThread); + + mUseRemoteSurface = (applicationType == Framework::WATCH); } Application::~Application() @@ -133,10 +175,28 @@ Application::~Application() } mMainWindow.Reset(); - delete mAdaptor; - delete mAdaptorBuilder; + delete mCommandLineOptions; - delete mFramework; + + // Application is created in Main thread whether UI Threading is enabled or not. + // But some resources are created in Main thread or UI thread. + // The below code is for the resource are created in Main thread. + if(!mUseUiThread) + { + delete mAdaptor; + delete mAdaptorBuilder; + if(mIsSystemInitialized) + { + WindowSystem::Shutdown(); + } + } + else + { + if(mUIThreadLoader) + { + delete mUIThreadLoader; + } + } } void Application::StoreWindowPositionSize(PositionSize positionSize) @@ -144,11 +204,29 @@ void Application::StoreWindowPositionSize(PositionSize positionSize) mWindowPositionSize = positionSize; } -void Application::ChangePreInitializedWindowSize() +void Application::StoreFrontBufferRendering(bool enable) +{ + mIsMainWindowFrontBufferRendering = enable; +} + +void Application::ChangePreInitializedWindowInfo() { + // Set window name + auto windowClassName = mEnvironmentOptions->GetWindowClassName(); + auto windowName = mEnvironmentOptions->GetWindowName(); + if(!windowName.empty()) + { + mMainWindowName = windowName; + } + mMainWindow.SetClass(mMainWindowName, windowClassName); + + // The real screen size may be different from the value of the preinitialized state. Update it. + Dali::Internal::Adaptor::WindowSystem::UpdateScreenSize(); + int screenWidth, screenHeight; Dali::Internal::Adaptor::WindowSystem::GetScreenSize(screenWidth, screenHeight); + // Set window position / size if(mWindowPositionSize != PositionSize(0, 0, 0, 0)) { Dali::DevelWindow::SetPositionSize(mMainWindow, mWindowPositionSize); @@ -160,44 +238,75 @@ void Application::ChangePreInitializedWindowSize() mWindowPositionSize.height = mCommandLineOptions->stageHeight; mMainWindow.SetSize(Dali::Window::WindowSize(mWindowPositionSize.width, mWindowPositionSize.height)); } - else if(mEnvironmentOptions.GetWindowWidth() && mEnvironmentOptions.GetWindowHeight()) + else if(mEnvironmentOptions->GetWindowWidth() && mEnvironmentOptions->GetWindowHeight()) { // Environment options override full screen functionality if command line arguments not provided - mWindowPositionSize.width = mEnvironmentOptions.GetWindowWidth(); - mWindowPositionSize.height = mEnvironmentOptions.GetWindowHeight(); + mWindowPositionSize.width = mEnvironmentOptions->GetWindowWidth(); + mWindowPositionSize.height = mEnvironmentOptions->GetWindowHeight(); mMainWindow.SetSize(Dali::Window::WindowSize(mWindowPositionSize.width, mWindowPositionSize.height)); } else if(screenWidth != mWindowPositionSize.width || screenHeight != mWindowPositionSize.height) { - //Some apps can receive screen size differently after launching by specifying size in manifest. + // Some apps can receive screen size differently after launching by specifying size in manifest. mWindowPositionSize.width = screenWidth; mWindowPositionSize.height = screenHeight; mMainWindow.SetSize(Dali::Window::WindowSize(mWindowPositionSize.width, mWindowPositionSize.height)); } + + // Set front buffer rendering + Dali::DevelWindow::SetFrontBufferRendering(mMainWindow, mIsMainWindowFrontBufferRendering); } void Application::CreateWindow() { - if(mWindowPositionSize.width == 0 && mWindowPositionSize.height == 0) + Internal::Adaptor::Window* window; + WindowData windowData; + windowData.SetTransparency(mMainWindowMode); + windowData.SetWindowType(mDefaultWindowType); + windowData.SetFrontBufferRendering(mIsMainWindowFrontBufferRendering); + + DALI_LOG_RELEASE_INFO("Create Default Window"); + + WindowSystem::Initialize(); + mIsSystemInitialized = true; + + if(mLaunchpadState != Launchpad::PRE_INITIALIZED) { - if(mCommandLineOptions->stageWidth > 0 && mCommandLineOptions->stageHeight > 0) + if(mWindowPositionSize.width == 0 && mWindowPositionSize.height == 0) { - // Command line options override environment options and full screen - mWindowPositionSize.width = mCommandLineOptions->stageWidth; - mWindowPositionSize.height = mCommandLineOptions->stageHeight; + if(mCommandLineOptions->stageWidth > 0 && mCommandLineOptions->stageHeight > 0) + { + // Command line options override environment options and full screen + mWindowPositionSize.width = mCommandLineOptions->stageWidth; + mWindowPositionSize.height = mCommandLineOptions->stageHeight; + } + else if(mEnvironmentOptions->GetWindowWidth() && mEnvironmentOptions->GetWindowHeight()) + { + // Environment options override full screen functionality if command line arguments not provided + mWindowPositionSize.width = mEnvironmentOptions->GetWindowWidth(); + mWindowPositionSize.height = mEnvironmentOptions->GetWindowHeight(); + } } - else if(mEnvironmentOptions.GetWindowWidth() && mEnvironmentOptions.GetWindowHeight()) + + auto windowClassName = mEnvironmentOptions->GetWindowClassName(); + auto windowName = mEnvironmentOptions->GetWindowName(); + if(!windowName.empty()) { - // Environment options override full screen functionality if command line arguments not provided - mWindowPositionSize.width = mEnvironmentOptions.GetWindowWidth(); - mWindowPositionSize.height = mEnvironmentOptions.GetWindowHeight(); + mMainWindowName = windowName; } - } - const std::string& windowClassName = mEnvironmentOptions.GetWindowClassName(); + windowData.SetPositionSize(mWindowPositionSize); + window = Internal::Adaptor::Window::New(mMainWindowName, windowClassName, windowData); + } + else + { + // The position, size, window name, and frontbuffering of the pre-initialized application + // will be updated in ChangePreInitializedWindowInfo() when the real application is launched. + windowData.SetPositionSize(mWindowPositionSize); + window = Internal::Adaptor::Window::New("", "", windowData); + } - Internal::Adaptor::Window* window = Internal::Adaptor::Window::New(mWindowPositionSize, mMainWindowName, windowClassName, mDefaultWindowType, mMainWindowMode == Dali::Application::TRANSPARENT); - mMainWindow = Dali::Window(window); + mMainWindow = Dali::Window(window); // Quit the application when the window is closed GetImplementation(mMainWindow).DeleteRequestSignal().Connect(mSlotDelegate, &Application::Quit); @@ -211,14 +320,14 @@ void Application::CreateAdaptor() Integration::SceneHolder sceneHolder = Integration::SceneHolder(&Dali::GetImplementation(mMainWindow)); - mAdaptor = Adaptor::New(graphicsFactory, sceneHolder, &mEnvironmentOptions); + mAdaptor = Adaptor::New(graphicsFactory, sceneHolder, mEnvironmentOptions.get()); Adaptor::GetImplementation(*mAdaptor).SetUseRemoteSurface(mUseRemoteSurface); } void Application::CreateAdaptorBuilder() { - mAdaptorBuilder = new AdaptorBuilder(mEnvironmentOptions); + mAdaptorBuilder = new AdaptorBuilder(*mEnvironmentOptions); } void Application::MainLoop() @@ -252,12 +361,15 @@ void Application::QuitFromMainLoop() void Application::OnInit() { + mEnvironmentOptions = std::unique_ptr(new EnvironmentOptions()); + mFramework->AddAbortCallback(MakeCallback(this, &Application::QuitFromMainLoop)); CreateAdaptorBuilder(); // 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(); } @@ -265,7 +377,7 @@ void Application::OnInit() if(mLaunchpadState == Launchpad::PRE_INITIALIZED) { - ChangePreInitializedWindowSize(); + ChangePreInitializedWindowInfo(); } // Run the adaptor @@ -296,6 +408,9 @@ void Application::OnInit() DALI_TRACE_END(gTraceFilter, "DALI_APP_EMIT_INIT_SIGNAL"); mAdaptor->NotifySceneCreated(); + + // Ensure the join of Font thread at this point + Dali::TextAbstraction::FontClientJoinFontThreads(); } void Application::OnTerminate() @@ -313,6 +428,15 @@ void Application::OnTerminate() } mMainWindow.Reset(); // This only resets (clears) the default Window + + // If DALi's UI Thread works, some resources are created in UI Thread, not Main thread. + // For that case, these resource should be deleted in UI Thread. + if(mUseUiThread) + { + delete mAdaptor; + delete mAdaptorBuilder; + WindowSystem::Shutdown(); + } } void Application::OnPause() @@ -380,6 +504,12 @@ void Application::OnMemoryLow(Dali::DeviceStatus::Memory::Status status) mLowMemorySignal.Emit(status); } +void Application::OnDeviceOrientationChanged(Dali::DeviceStatus::Orientation::Status status) +{ + Dali::Application application(this); + mDeviceOrientationChangedSignal.Emit(status); +} + void Application::OnSurfaceCreated(Any newSurface) { void* newWindow = AnyCast(newSurface); @@ -397,6 +527,54 @@ void Application::OnSurfaceDestroyed(Any surface) { } +void Application::OnTaskInit() +{ + Dali::Application application(this); + mTaskInitSignal.Emit(application); +} + +void Application::OnTaskTerminate() +{ + Dali::Application application(this); + mTaskTerminateSignal.Emit(application); +} + +void Application::OnTaskAppControl(void* data) +{ + Dali::Application application(this); + mTaskAppControlSignal.Emit(application, data); +} + +void Application::OnTaskLanguageChanged() +{ + Dali::Application application(this); + mTaskLanguageChangedSignal.Emit(application); +} + +void Application::OnTaskRegionChanged() +{ + Dali::Application application(this); + mTaskRegionChangedSignal.Emit(application); +} + +void Application::OnTaskBatteryLow(Dali::DeviceStatus::Battery::Status status) +{ + Dali::Application application(this); + mTaskLowBatterySignal.Emit(status); +} + +void Application::OnTaskMemoryLow(Dali::DeviceStatus::Memory::Status status) +{ + Dali::Application application(this); + mTaskLowMemorySignal.Emit(status); +} + +void Application::OnTaskDeviceOrientationChanged(Dali::DeviceStatus::Orientation::Status status) +{ + Dali::Application application(this); + mTaskDeviceOrientationChangedSignal.Emit(status); +} + bool Application::AddIdle(CallbackBase* callback, bool hasReturnValue) { return mAdaptor->AddIdle(callback, hasReturnValue); @@ -434,12 +612,17 @@ Dali::Window Application::GetWindow() std::string Application::GetResourcePath() { - return Internal::Adaptor::Framework::GetResourcePath(); + return SystemSettings::GetResourcePath(); } std::string Application::GetDataPath() { - return Internal::Adaptor::Framework::GetDataPath(); + return SystemSettings::GetDataPath(); +} + +void Application::FlushUpdateMessages() +{ + Internal::Adaptor::Adaptor::GetImplementation(*mAdaptor).FlushUpdateMessages(); } void Application::SetStyleSheet(const std::string& stylesheet) @@ -454,6 +637,12 @@ void Application::SetCommandLineOptions(int* argc, char** argv[]) mCommandLineOptions = new CommandLineOptions(argc, argv); mFramework->SetCommandLineOptions(argc, argv); + + if(argc && (*argc > 0)) + { + // Set mName from command-line args + mMainWindowName = (*argv)[0]; + } } void Application::SetDefaultWindowType(WindowType type) @@ -462,6 +651,15 @@ void Application::SetDefaultWindowType(WindowType type) mMainWindow.SetType(type); } +int32_t Application::GetRenderThreadId() const +{ + if(mAdaptor) + { + return Internal::Adaptor::Adaptor::GetImplementation(*mAdaptor).GetRenderThreadId(); + } + return 0; +} + ApplicationPtr Application::GetPreInitializedApplication() { // Reset the handle to decrease the reference count