/*
- * 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 <dali/integration-api/input-options.h>
#include <dali/integration-api/processor-interface.h>
#include <dali/integration-api/profiling.h>
+#include <dali/integration-api/trace.h>
#include <dali/public-api/actors/layer.h>
#include <dali/public-api/events/wheel-event.h>
#include <dali/public-api/object/any.h>
#include <dali/devel-api/text-abstraction/font-client.h>
#include <dali/internal/accessibility/common/tts-player-impl.h>
-#include <dali/internal/clipboard/common/clipboard-impl.h>
#include <dali/internal/graphics/common/egl-image-extensions.h>
#include <dali/internal/graphics/gles/egl-sync-implementation.h>
#include <dali/internal/graphics/gles/gl-implementation.h>
#include <dali/internal/graphics/gles/gl-proxy-implementation.h>
#include <dali/internal/system/common/callback-manager.h>
#include <dali/internal/system/common/object-profiler.h>
+#include <dali/internal/system/common/system-factory.h>
#include <dali/internal/window-system/common/display-connection.h>
#include <dali/internal/window-system/common/display-utils.h> // For Utils::MakeUnique
#include <dali/internal/window-system/common/event-handler.h>
#include <dali/internal/window-system/common/window-impl.h>
#include <dali/internal/window-system/common/window-render-surface.h>
+#include <dali/internal/window-system/common/window-system.h>
-#include <dali/devel-api/adaptor-framework/accessibility-impl.h>
+#include <dali/devel-api/adaptor-framework/accessibility-bridge.h>
#include <dali/internal/system/common/logging.h>
#include <dali/internal/imaging/common/image-loader-plugin-proxy.h>
#include <dali/internal/imaging/common/image-loader.h>
#include <dali/internal/system/common/locale-utils.h>
+#include <dali/devel-api/adaptor-framework/environment-variable.h>
#include <dali/internal/system/common/configuration-manager.h>
#include <dali/internal/system/common/environment-variables.h>
{
thread_local Adaptor* gThreadLocalAdaptor = NULL; // raw thread specific pointer to allow Adaptor::Get
+DALI_INIT_TRACE_FILTER(gTraceFilter, DALI_TRACE_PERFORMANCE_MARKER, false);
+
+const char* ENABLE_IMAGE_LOADER_PLUGIN_ENV = "DALI_ENABLE_IMAGE_LOADER_PLUGIN";
} // unnamed namespace
Dali::Adaptor* Adaptor::New(Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface* surface, EnvironmentOptions* environmentOptions, ThreadMode threadMode)
mEnvironmentOptions->CreateTraceManager(mPerformanceInterface);
mEnvironmentOptions->InstallTraceFunction(); // install tracing for main thread
- mCallbackManager = CallbackManager::New();
+ mCallbackManager = Dali::Internal::Adaptor::GetSystemFactory()->CreateCallbackManager();
Dali::Internal::Adaptor::SceneHolder* defaultWindow = mWindows.front();
mGraphics->GetStencilBufferRequired(),
mGraphics->GetPartialUpdateRequired());
+ // Create TextureUploadManager after mCore created
+ mTextureUploadManager = Dali::Devel::TextureUploadManager::Get();
+
defaultWindow->SetAdaptor(Get());
Dali::Integration::SceneHolder defaultSceneHolder(defaultWindow);
mObjectProfiler = new ObjectProfiler(mCore->GetObjectRegistry(), timeInterval);
}
+ const uint32_t poolTimeInterval = mEnvironmentOptions->GetMemoryPoolInterval();
+ if(0u < poolTimeInterval)
+ {
+ mMemoryPoolTimer = Dali::Timer::New(poolTimeInterval * 1000);
+ mMemoryPoolTimer.TickSignal().Connect(mMemoryPoolTimerSlotDelegate, &Adaptor::MemoryPoolTimeout);
+ mMemoryPoolTimer.Start();
+ }
+
mNotificationTrigger = TriggerEventFactory::CreateTriggerEvent(MakeCallback(this, &Adaptor::ProcessCoreEvents), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER);
mDisplayConnection = Dali::DisplayConnection::New(*mGraphics, defaultWindow->GetSurface()->GetSurfaceType());
Integration::SetTapMaximumAllowedTime(mEnvironmentOptions->GetTapMaximumAllowedTime());
}
-
std::string systemCachePath = GetSystemCachePath();
if(!systemCachePath.empty())
{
if(0 != dir_err && errno != EEXIST)
{
DALI_LOG_ERROR("Error creating system cache directory: %s!\n", systemCachePath.c_str());
- exit(1);
}
}
mConfigurationManager = Utils::MakeUnique<ConfigurationManager>(systemCachePath, mGraphics.get(), mThreadController);
-
- auto appName = GetApplicationPackageName();
- auto bridge = Accessibility::Bridge::GetCurrentBridge();
- bridge->SetApplicationName(appName);
- bridge->Initialize();
- Dali::Stage::GetCurrent().KeyEventSignal().Connect(&mAccessibilityObserver, &AccessibilityObserver::OnAccessibleKeyEvent);
}
void Adaptor::AccessibilityObserver::OnAccessibleKeyEvent(const Dali::KeyEvent& event)
delete mDisplayConnection;
delete mPlatformAbstraction;
- delete mCallbackManager;
+
+ mCallbackManager.reset();
+
delete mPerformanceInterface;
mGraphics->Destroy();
// Start the callback manager
mCallbackManager->Start();
+ // Initialize accessibility bridge after callback manager is started to use Idler callback
+ auto appName = GetApplicationPackageName();
+ auto bridge = Accessibility::Bridge::GetCurrentBridge();
+ bridge->SetApplicationName(appName);
+ bridge->Initialize();
+ Dali::Stage::GetCurrent().KeyEventSignal().Connect(&mAccessibilityObserver, &AccessibilityObserver::OnAccessibleKeyEvent);
+
Dali::Internal::Adaptor::SceneHolder* defaultWindow = mWindows.front();
unsigned int dpiHor, dpiVer;
dpiHor = dpiVer = 0;
defaultWindow->GetSurface()->GetDpi(dpiHor, dpiVer);
-
- // set the DPI value for font rendering
- FontClient fontClient = FontClient::Get();
- fontClient.SetDpi(dpiHor, dpiVer);
+ Dali::Internal::Adaptor::WindowSystem::SetDpi(dpiHor, dpiVer);
// Initialize the thread controller
mThreadController->Initialize();
ProcessCoreEvents(); // Ensure any startup messages are processed.
// Initialize the image loader plugin
- Internal::Adaptor::ImageLoaderPluginProxy::Initialize();
+ auto enablePluginString = Dali::EnvironmentVariable::GetEnvironmentVariable(ENABLE_IMAGE_LOADER_PLUGIN_ENV);
+ bool enablePlugin = enablePluginString ? std::atoi(enablePluginString) : false;
+ if(enablePlugin)
+ {
+ Internal::Adaptor::ImageLoaderPluginProxy::Initialize();
+ }
for(ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter)
{
}
// Destroy the image loader plugin
- Internal::Adaptor::ImageLoaderPluginProxy::Destroy();
+ auto enablePluginString = Dali::EnvironmentVariable::GetEnvironmentVariable(ENABLE_IMAGE_LOADER_PLUGIN_ENV);
+ bool enablePlugin = enablePluginString ? std::atoi(enablePluginString) : false;
+ if(enablePlugin)
+ {
+ Internal::Adaptor::ImageLoaderPluginProxy::Destroy();
+ }
delete mNotificationTrigger;
mNotificationTrigger = NULL;
mState = STOPPED;
+ RemoveSystemInformation();
+
DALI_LOG_RELEASE_INFO("Adaptor::Stop\n");
}
}
idleAdded = mCallbackManager->AddIdleCallback(callback, hasReturnValue);
}
+ if(!idleAdded)
+ {
+ // Delete callback
+ delete callback;
+ }
+
return idleAdded;
}
windowImpl.GetRootLayer().SetProperty(Dali::Actor::Property::LAYOUT_DIRECTION, mRootLayoutDirection);
// Add the new Window to the container - the order is not important
- mWindows.push_back(&windowImpl);
+ {
+ Dali::Mutex::ScopedLock lock(mMutex);
+ mWindows.push_back(&windowImpl);
+ }
Dali::RenderSurfaceInterface* surface = windowImpl.GetSurface();
{
if(*iter == &windowImpl)
{
+ Dali::Mutex::ScopedLock lock(mMutex);
mWindows.erase(iter);
return true;
}
{
if((*iter)->GetName() == childWindowName)
{
+ Dali::Mutex::ScopedLock lock(mMutex);
mWindows.erase(iter);
return true;
}
{
if((*iter)->GetId() == childWindow->GetId())
{
+ Dali::Mutex::ScopedLock lock(mMutex);
mWindows.erase(iter);
return true;
}
void Adaptor::GetWindowContainerInterface(WindowContainer& windows)
{
+ Dali::Mutex::ScopedLock lock(mMutex);
windows = mWindows;
}
+Devel::TextureUploadManager& Adaptor::GetTextureUploadManager()
+{
+ return mTextureUploadManager;
+}
+
void Adaptor::DestroyTtsPlayer(Dali::TtsPlayer::Mode mode)
{
if(mTtsPlayers[mode])
}
}
+void Adaptor::FlushUpdateMessages()
+{
+ if(mCore)
+ {
+ DALI_TRACE_SCOPE(gTraceFilter, "DALI_FLUSH_UPDATE_MESSAGES");
+
+ mCore->ForceRelayout();
+ }
+}
+
void Adaptor::ProcessCoreEvents()
{
if(mCore)
{
+ DALI_TRACE_SCOPE(gTraceFilter, "DALI_PROCESS_CORE_EVENTS");
+
if(mPerformanceInterface)
{
mPerformanceInterface->AddMarker(PerformanceInterface::PROCESS_EVENTS_START);
}
}
-void Adaptor::RequestUpdate(bool forceUpdate)
+void Adaptor::RequestUpdate()
{
switch(mState)
{
case PAUSED:
case PAUSED_WHILE_HIDDEN:
{
- if(forceUpdate)
- {
- // Update (and resource upload) without rendering
- mThreadController->RequestUpdateOnce(UpdateMode::SKIP_RENDER);
- }
+ // Update (and resource upload) without rendering
+ mThreadController->RequestUpdateOnce(UpdateMode::SKIP_RENDER);
break;
}
default:
}
}
-void Adaptor::RequestProcessEventsOnIdle(bool forceProcess)
+void Adaptor::RequestProcessEventsOnIdle()
{
- // Only request a notification if the Adaptor is actually running
- // and we haven't installed the idle notification
- if((!mNotificationOnIdleInstalled) && (RUNNING == mState || READY == mState || forceProcess))
+ // We want to run the processes even when paused
+ if(STOPPED != mState)
{
- mNotificationOnIdleInstalled = AddIdleEnterer(MakeCallback(this, &Adaptor::ProcessCoreEventsFromIdle), forceProcess);
+ if(!mNotificationOnIdleInstalled)
+ {
+ // If we haven't installed the idle notification, install it idle enterer.
+ mNotificationOnIdleInstalled = AddIdleEnterer(MakeCallback(this, &Adaptor::ProcessCoreEventsFromIdle), true);
+ }
+ else
+ {
+ // Request comes during ProcessCoreEventsFromIdle running.
+ // Mark as we need to call ProcessEvents in next idle events.
+ mRequiredIdleRepeat = true;
+ }
}
}
void Adaptor::OnWindowShown()
{
- Dali::Accessibility::Bridge::GetCurrentBridge()->ApplicationShown();
-
if(PAUSED_WHILE_HIDDEN == mState)
{
// Adaptor can now be resumed
void Adaptor::OnWindowHidden()
{
- Dali::Accessibility::Bridge::GetCurrentBridge()->ApplicationHidden();
-
if(RUNNING == mState || READY == mState)
{
bool allWindowsHidden = true;
void Adaptor::OnDamaged(const DamageArea& area)
{
// This is needed for the case where Dali window is partially obscured
- RequestUpdate(false);
+ RequestUpdate();
}
void Adaptor::SurfaceResizePrepare(Dali::RenderSurfaceInterface* surface, SurfaceSize surfaceSize)
ProcessCoreEvents();
}
+
+ // Force rendering
+ for(auto&& iter : mWindows)
+ {
+ iter->GetSurface()->SetFullSwapNextFrame();
+ }
+
mThreadController->RequestUpdateOnce(updateMode);
}
}
return *mEnvironmentOptions;
}
+const TraceFactoryInterface& Adaptor::GetTraceFactory()
+{
+ return *mEnvironmentOptions;
+}
+
void Adaptor::RegisterProcessor(Integration::Processor& processor, bool postProcessor)
{
GetCore().RegisterProcessor(processor, postProcessor);
return mConfigurationManager->IsMultipleWindowSupported();
}
+int32_t Adaptor::GetRenderThreadId() const
+{
+ if(mThreadController)
+ {
+ return mThreadController->GetThreadId();
+ }
+ return 0;
+}
+
void Adaptor::RequestUpdateOnce()
{
if(mThreadController)
bool Adaptor::ProcessCoreEventsFromIdle()
{
+ // Reset repeat idler flag.
+ mRequiredIdleRepeat = false;
ProcessCoreEvents();
- // the idle handle automatically un-installs itself
- mNotificationOnIdleInstalled = false;
+ // If someone request ProcessCoreEvents during above ProcessCoreEvents call, we might need to run idle one more times.
+ // Else, the idle handle automatically un-installs itself
+ mNotificationOnIdleInstalled = mRequiredIdleRepeat;
- return false;
+ if(mRequiredIdleRepeat)
+ {
+ DALI_LOG_DEBUG_INFO("Required ProcessCoreEvents one more times\n");
+ }
+
+ return mRequiredIdleRepeat;
}
Dali::Internal::Adaptor::SceneHolder* Adaptor::GetWindow(Dali::Actor& actor)
mPlatformAbstraction(nullptr),
mCallbackManager(nullptr),
mNotificationOnIdleInstalled(false),
+ mRequiredIdleRepeat(false),
mNotificationTrigger(nullptr),
mDaliFeedbackPlugin(),
mFeedbackController(nullptr),
mPerformanceInterface(nullptr),
mKernelTracer(),
mSystemTracer(),
+ mTextureUploadManager(),
mObjectProfiler(nullptr),
+ mMemoryPoolTimerSlotDelegate(this),
mSocketFactory(),
+ mMutex(),
mThreadMode(threadMode),
mEnvironmentOptionsOwned(environmentOptions ? false : true /* If not provided then we own the object */),
mUseRemoteSurface(false),
mCallbackManager->RemoveIdleEntererCallback(callback);
}
+bool Adaptor::MemoryPoolTimeout()
+{
+ mCore->LogMemoryPools();
+ return true; // Keep logging forever
+}
+
} // namespace Adaptor
} // namespace Internal
projects / platform / core / uifw / dali-adaptor.git / blobdiff