/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/context-notifier.h>
#include <dali/integration-api/profiling.h>
#include <dali/integration-api/input-options.h>
+#include <dali/integration-api/events/key-event-integ.h>
#include <dali/integration-api/events/touch-event-integ.h>
+#include <dali/integration-api/events/wheel-event-integ.h>
#include <dali/integration-api/processor-interface.h>
// INTERNAL INCLUDES
#include <dali/internal/system/common/thread-controller.h>
#include <dali/internal/system/common/performance-interface-factory.h>
#include <dali/internal/adaptor/common/lifecycle-observer.h>
+#include <dali/internal/adaptor/common/thread-controller-interface.h>
#include <dali/internal/graphics/gles/egl-graphics-factory.h>
#include <dali/internal/graphics/gles/egl-graphics.h> // Temporary until Core is abstracted
#include <dali/internal/system/common/callback-manager.h>
#include <dali/internal/accessibility/common/tts-player-impl.h>
#include <dali/internal/accessibility/common/accessibility-adaptor-impl.h>
-#include <dali/internal/input/common/gesture-manager.h>
#include <dali/internal/window-system/common/event-handler.h>
#include <dali/internal/graphics/gles/gl-proxy-implementation.h>
#include <dali/internal/graphics/gles/gl-implementation.h>
#include <dali/internal/graphics/gles/egl-sync-implementation.h>
#include <dali/internal/graphics/common/egl-image-extensions.h>
#include <dali/internal/clipboard/common/clipboard-impl.h>
-#include <dali/internal/graphics/common/vsync-monitor.h>
#include <dali/internal/system/common/object-profiler.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/window-impl.h>
#include <dali/internal/window-system/common/window-render-surface.h>
#include <dali/internal/imaging/common/image-loader-plugin-proxy.h>
#include <dali/internal/imaging/common/image-loader.h>
+#include <dali/internal/system/common/configuration-manager.h>
+#include <dali/internal/system/common/environment-variables.h>
using Dali::TextAbstraction::FontClient;
+extern std::string GetSystemCachePath();
+
namespace Dali
{
namespace
{
+
thread_local Adaptor* gThreadLocalAdaptor = NULL; // raw thread specific pointer to allow Adaptor::Get
+
} // unnamed namespace
Dali::Adaptor* Adaptor::New( Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface *surface, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions )
GetDataStoragePath( path );
mPlatformAbstraction->SetDataStoragePath( path );
- ResourcePolicy::DataRetention dataRetentionPolicy = ResourcePolicy::DALI_DISCARDS_ALL_DATA;
- if( configuration == Dali::Configuration::APPLICATION_DOES_NOT_HANDLE_CONTEXT_LOSS )
- {
- dataRetentionPolicy = ResourcePolicy::DALI_DISCARDS_ALL_DATA;
- }
-
- // Note, Tizen does not use DALI_RETAINS_ALL_DATA, as it can reload images from files automatically.
-
if( mEnvironmentOptions->PerformanceServerRequired() )
{
mPerformanceInterface = PerformanceInterfaceFactory::CreateInterface( *this, *mEnvironmentOptions );
mCallbackManager = CallbackManager::New();
- SceneHolderPtr defaultWindow = mWindows.front();
+ Dali::Internal::Adaptor::SceneHolder* defaultWindow = mWindows.front();
DALI_ASSERT_DEBUG( defaultWindow->GetSurface() && "Surface not initialized" );
- PositionSize size = defaultWindow->GetSurface()->GetPositionSize();
-
- mGestureManager = new GestureManager(*this, Vector2(static_cast<float>(size.width), static_cast<float>(size.height)), mCallbackManager, *mEnvironmentOptions);
-
mGraphics = &( graphicsFactory.Create() );
mGraphics->Initialize( mEnvironmentOptions );
GlImplementation& mGLES = eglGraphics->GetGlesInterface();
EglSyncImplementation& eglSyncImpl = eglGraphics->GetSyncImplementation();
+ EglContextHelperImplementation& eglContextHelperImpl = eglGraphics->GetContextHelperImplementation();
mCore = Integration::Core::New( *this,
*mPlatformAbstraction,
mGLES,
eglSyncImpl,
- *mGestureManager,
- dataRetentionPolicy ,
+ eglContextHelperImpl,
( 0u != mEnvironmentOptions->GetRenderToFboInterval() ) ? Integration::RenderToFrameBuffer::TRUE : Integration::RenderToFrameBuffer::FALSE,
mGraphics->GetDepthBufferRequired(),
mGraphics->GetStencilBufferRequired() );
defaultWindow->SetAdaptor( Get() );
+ Dali::Integration::SceneHolder defaultSceneHolder( defaultWindow );
+
+ mWindowCreatedSignal.Emit( defaultSceneHolder );
+
const unsigned int timeInterval = mEnvironmentOptions->GetObjectProfilerInterval();
if( 0u < timeInterval )
{
mObjectProfiler = new ObjectProfiler( timeInterval );
}
- mNotificationTrigger = mTriggerEventFactory.CreateTriggerEvent( MakeCallback( this, &Adaptor::ProcessCoreEvents ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER);
-
- mVSyncMonitor = new VSyncMonitor;
+ mNotificationTrigger = TriggerEventFactory::CreateTriggerEvent( MakeCallback( this, &Adaptor::ProcessCoreEvents ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER);
mDisplayConnection = Dali::DisplayConnection::New( *mGraphics, defaultWindow->GetSurface()->GetSurfaceType() );
{
Integration::SetPanGestureMultitapSmoothingRange( mEnvironmentOptions->GetPanGestureMultitapSmoothingRange() );
}
+ if( mEnvironmentOptions->GetMinimumPanDistance() >= 0 )
+ {
+ Integration::SetPanGestureMinimumDistance( mEnvironmentOptions->GetMinimumPanDistance() );
+ }
+ if( mEnvironmentOptions->GetMinimumPanEvents() >= 0 )
+ {
+ Integration::SetPanGestureMinimumPanEvents( mEnvironmentOptions->GetMinimumPanEvents() );
+ }
+ if( mEnvironmentOptions->GetMinimumPinchDistance() >= 0 )
+ {
+ Integration::SetPinchGestureMinimumDistance( mEnvironmentOptions->GetMinimumPinchDistance() );
+ }
+ if( mEnvironmentOptions->GetMinimumPinchTouchEvents() >= 0 )
+ {
+ Integration::SetPinchGestureMinimumTouchEvents( mEnvironmentOptions->GetMinimumPinchTouchEvents() );
+ }
+ if( mEnvironmentOptions->GetMinimumPinchTouchEventsAfterStart() >= 0 )
+ {
+ Integration::SetPinchGestureMinimumTouchEventsAfterStart( mEnvironmentOptions->GetMinimumPinchTouchEventsAfterStart() );
+ }
+ if( mEnvironmentOptions->GetMinimumRotationTouchEvents() >= 0 )
+ {
+ Integration::SetRotationGestureMinimumTouchEvents( mEnvironmentOptions->GetMinimumRotationTouchEvents() );
+ }
+ if( mEnvironmentOptions->GetMinimumRotationTouchEventsAfterStart() >= 0 )
+ {
+ Integration::SetRotationGestureMinimumTouchEventsAfterStart( mEnvironmentOptions->GetMinimumRotationTouchEventsAfterStart() );
+ }
+ if( mEnvironmentOptions->GetLongPressMinimumHoldingTime() >= 0 )
+ {
+ Integration::SetLongPressMinimumHoldingTime( mEnvironmentOptions->GetLongPressMinimumHoldingTime() );
+ }
- // Set max texture size
- if( mEnvironmentOptions->GetMaxTextureSize() > 0 )
+ std::string systemCachePath = GetSystemCachePath();
+ if( ! systemCachePath.empty() )
{
- Dali::TizenPlatform::ImageLoader::SetMaxTextureSize( mEnvironmentOptions->GetMaxTextureSize() );
+ const int dir_err = system( std::string( "mkdir " + systemCachePath ).c_str() );
+ if (-1 == dir_err)
+ {
+ printf( "Error creating system cache directory: %s!\n", systemCachePath.c_str() );
+ exit(1);
+ }
}
+
+ mConfigurationManager = Utils::MakeUnique<ConfigurationManager>( systemCachePath, eglGraphics, mThreadController );
}
Adaptor::~Adaptor()
mWindows.clear();
delete mThreadController; // this will shutdown render thread, which will call Core::ContextDestroyed before exit
- delete mVSyncMonitor;
delete mObjectProfiler;
delete mCore;
- delete mGestureManager;
delete mDisplayConnection;
delete mPlatformAbstraction;
delete mCallbackManager;
// Start the callback manager
mCallbackManager->Start();
- SceneHolderPtr defaultWindow = mWindows.front();
+ Dali::Internal::Adaptor::SceneHolder* defaultWindow = mWindows.front();
unsigned int dpiHor, dpiVer;
dpiHor = dpiVer = 0;
FontClient fontClient = FontClient::Get();
fontClient.SetDpi( dpiHor, dpiVer );
- // Tell the core the size of the surface just before we start the render-thread
- mCore->SurfaceResized( defaultWindow->GetSurface() );
-
// Initialize the thread controller
mThreadController->Initialize();
+ // Set max texture size
+ if( mEnvironmentOptions->GetMaxTextureSize() > 0 )
+ {
+ Dali::TizenPlatform::ImageLoader::SetMaxTextureSize( mEnvironmentOptions->GetMaxTextureSize() );
+ }
+ else
+ {
+ unsigned int maxTextureSize = mConfigurationManager->GetMaxTextureSize();
+ setenv( DALI_ENV_MAX_TEXTURE_SIZE, std::to_string( maxTextureSize ).c_str(), 1 );
+ Dali::TizenPlatform::ImageLoader::SetMaxTextureSize( maxTextureSize );
+ }
+
ProcessCoreEvents(); // Ensure any startup messages are processed.
// Initialize the image loader plugin
}
// Pause all windows event handlers when adaptor paused
- for( SceneHolderPtr window : mWindows )
+ for( auto window : mWindows )
{
window->Pause();
}
mState = RUNNING;
// Reset the event handlers when adaptor resumed
- for( SceneHolderPtr window : mWindows )
+ for( auto window : mWindows )
{
window->Resume();
}
void Adaptor::FeedTouchPoint( TouchPoint& point, int timeStamp )
{
- mWindows.front()->FeedTouchPoint( point, timeStamp );
+ Integration::Point convertedPoint( point );
+ mWindows.front()->FeedTouchPoint( convertedPoint, timeStamp );
}
void Adaptor::FeedWheelEvent( WheelEvent& wheelEvent )
{
- mWindows.front()->FeedWheelEvent( wheelEvent );
+ Integration::WheelEvent event( static_cast< Integration::WheelEvent::Type >(wheelEvent.type), wheelEvent.direction, wheelEvent.modifiers, wheelEvent.point, wheelEvent.z, wheelEvent.timeStamp );
+ mWindows.front()->FeedWheelEvent( event );
}
void Adaptor::FeedKeyEvent( KeyEvent& keyEvent )
{
- mWindows.front()->FeedKeyEvent( keyEvent );
+ Integration::KeyEvent convertedEvent( keyEvent );
+ mWindows.front()->FeedKeyEvent( convertedEvent );
}
void Adaptor::ReplaceSurface( Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface& newSurface )
{
Internal::Adaptor::SceneHolder* windowImpl = &Dali::GetImplementation( window );
- for( SceneHolderPtr windowPtr : mWindows )
+ for( auto windowPtr : mWindows )
{
- if( windowPtr.Get() == windowImpl ) // the window is not deleted
+ if( windowPtr == windowImpl ) // the window is not deleted
{
- // Let the core know the surface size has changed
- mCore->SurfaceResized( &newSurface );
-
mResizedSignal.Emit( mAdaptor );
windowImpl->SetSurface( &newSurface );
mThreadController->SetPreRenderCallback( callback );
}
-bool Adaptor::AddWindow( Dali::Integration::SceneHolder* childWindow, const std::string& childWindowName, const std::string& childWindowClassName, const bool& childWindowMode )
+bool Adaptor::AddWindow( Dali::Integration::SceneHolder childWindow, const std::string& childWindowName, const std::string& childWindowClassName, bool childWindowMode )
{
- Internal::Adaptor::SceneHolder& windowImpl = Dali::GetImplementation( *childWindow );
+ Internal::Adaptor::SceneHolder& windowImpl = Dali::GetImplementation( childWindow );
windowImpl.SetAdaptor( Get() );
// Add the new Window to the container - the order is not important
- mWindows.push_back( SceneHolderPtr( &windowImpl ) );
+ mWindows.push_back( &windowImpl );
+
+ Dali::RenderSurfaceInterface* surface = windowImpl.GetSurface();
+
+ mThreadController->AddSurface( surface );
+
+ mWindowCreatedSignal.Emit( childWindow );
+
return true;
}
mThreadController->SetRenderRefreshRate( numberOfVSyncsPerRender );
}
-void Adaptor::SetUseHardwareVSync( bool useHardware )
-{
- mVSyncMonitor->SetUseHardwareVSync( useHardware );
-}
-
Dali::DisplayConnection& Adaptor::GetDisplayConnectionInterface()
{
DALI_ASSERT_DEBUG( mDisplayConnection && "Display connection not created" );
return *mNotificationTrigger;
}
-TriggerEventFactoryInterface& Adaptor::GetTriggerEventFactoryInterface()
-{
- return mTriggerEventFactory;
-}
-
SocketFactoryInterface& Adaptor::GetSocketFactoryInterface()
{
return mSocketFactory;
return nullptr;
}
-VSyncMonitorInterface* Adaptor::GetVSyncMonitorInterface()
-{
- return mVSyncMonitor;
-}
-
TraceInterface& Adaptor::GetKernelTraceInterface()
{
return mKernelTracer;
return *mPlatformAbstraction;
}
+void Adaptor::GetWindowContainerInterface( WindowContainer& windows )
+{
+ windows = mWindows;
+}
+
void Adaptor::DestroyTtsPlayer(Dali::TtsPlayer::Mode mode)
{
if( mTtsPlayers[mode] )
}
}
-void Adaptor::SetMinimumPinchDistance(float distance)
+Any Adaptor::GetNativeWindowHandle()
{
- if( mGestureManager )
- {
- mGestureManager->SetMinimumPinchDistance(distance);
- }
+ return mWindows.front()->GetNativeHandle();
}
-Any Adaptor::GetNativeWindowHandle()
+Any Adaptor::GetNativeWindowHandle( Dali::Actor actor )
{
- return mWindows.front()->GetNativeHandle();
+ Any nativeWindowHandle;
+
+ Dali::Integration::Scene scene = Dali::Integration::Scene::Get( actor );
+
+ for( auto sceneHolder : mWindows )
+ {
+ if ( scene == sceneHolder->GetScene() )
+ {
+ nativeWindowHandle = sceneHolder->GetNativeHandle();
+ break;
+ }
+ }
+
+ return nativeWindowHandle;
}
Any Adaptor::GetGraphicsDisplay()
case PAUSED:
case PAUSED_WHILE_HIDDEN:
{
- // When Dali applications are partially visible behind the lock-screen,
- // the indicator must be updated (therefore allow updates in the PAUSED state)
if( forceUpdate )
{
- mThreadController->RequestUpdateOnce();
+ // Update (and resource upload) without rendering
+ mThreadController->RequestUpdateOnce( UpdateMode::SKIP_RENDER );
}
break;
}
void Adaptor::OnWindowShown()
{
- if ( PAUSED_WHILE_HIDDEN == mState )
+ if( PAUSED_WHILE_HIDDEN == mState )
{
// Adaptor can now be resumed
mState = PAUSED;
// Force a render task
RequestUpdateOnce();
}
+ else if( RUNNING == mState )
+ {
+ // Force a render task
+ RequestUpdateOnce();
+
+ DALI_LOG_RELEASE_INFO( "Adaptor::OnWindowShown: Update requested.\n" );
+ }
else
{
- DALI_LOG_RELEASE_INFO( "Adaptor::OnWindowShown: Not shown [%d]\n", mState );
+ DALI_LOG_RELEASE_INFO( "Adaptor::OnWindowShown: Adaptor is not paused state.[%d]\n", mState );
}
}
void Adaptor::OnWindowHidden()
{
- if ( RUNNING == mState )
+ if( RUNNING == mState || READY == mState )
{
bool allWindowsHidden = true;
- for( SceneHolderPtr window : mWindows )
+ for( auto window : mWindows )
{
if ( window->IsVisible() )
{
}
// Only pause the adaptor when all the windows are hidden
- if ( allWindowsHidden )
+ if( allWindowsHidden )
{
- Pause();
+ if( mState == RUNNING )
+ {
+ Pause();
- // Adaptor cannot be resumed until any window is shown
- mState = PAUSED_WHILE_HIDDEN;
+ // Adaptor cannot be resumed until any window is shown
+ mState = PAUSED_WHILE_HIDDEN;
+ }
+ else // mState is READY
+ {
+ // Pause the adaptor after the state gets RUNNING
+ mState = PAUSED_WHILE_INITIALIZING;
+ }
+ }
+ else
+ {
+ DALI_LOG_RELEASE_INFO( "Adaptor::OnWindowHidden: Some windows are shown. Don't pause adaptor.\n" );
}
}
else
{
- DALI_LOG_RELEASE_INFO( "Adaptor::OnWindowHidden: Not hidden [%d]\n", mState );
+ DALI_LOG_RELEASE_INFO( "Adaptor::OnWindowHidden: Adaptor is not running state.[%d]\n", mState );
}
}
void Adaptor::SurfaceResizePrepare( Dali::RenderSurfaceInterface* surface, SurfaceSize surfaceSize )
{
- // Let the core know the surface size has changed
- mCore->SurfaceResized( surface );
-
mResizedSignal.Emit( mAdaptor );
}
void Adaptor::SurfaceResizeComplete( Dali::RenderSurfaceInterface* surface, SurfaceSize surfaceSize )
{
+ // Nofify surface resizing before flushing event queue
+ mThreadController->ResizeSurface();
+
// Flush the event queue to give the update-render thread chance
// to start processing messages for new camera setup etc as soon as possible
ProcessCoreEvents();
-
- mThreadController->ResizeSurface();
}
void Adaptor::NotifySceneCreated()
// Process after surface is created (registering to remote surface provider if required)
SurfaceInitialized();
- mState = RUNNING;
+ if( mState != PAUSED_WHILE_INITIALIZING )
+ {
+ mState = RUNNING;
+
+ DALI_LOG_RELEASE_INFO( "Adaptor::NotifySceneCreated: Adaptor is running\n" );
+ }
+ else
+ {
+ mState = RUNNING;
- DALI_LOG_RELEASE_INFO( "Adaptor::NotifySceneCreated\n" );
+ Pause();
+
+ mState = PAUSED_WHILE_HIDDEN;
+
+ DALI_LOG_RELEASE_INFO( "Adaptor::NotifySceneCreated: Adaptor is paused\n" );
+ }
}
void Adaptor::NotifyLanguageChanged()
GetCore().UnregisterProcessor(processor);
}
+bool Adaptor::IsMultipleWindowSupported() const
+{
+ return mConfigurationManager->IsMultipleWindowSupported();
+}
+
void Adaptor::RequestUpdateOnce()
{
if( mThreadController )
{
- mThreadController->RequestUpdateOnce();
+ mThreadController->RequestUpdateOnce( UpdateMode::NORMAL );
}
}
{
if ( scene == window->GetScene() )
{
- return window.Get();
+ return window;
}
}
return nullptr;
}
+Dali::WindowContainer Adaptor::GetWindows() const
+{
+ Dali::WindowContainer windows;
+
+ for ( auto iter = mWindows.begin(); iter != mWindows.end(); ++iter )
+ {
+ // Downcast to Dali::Window
+ Dali::Window window( dynamic_cast<Dali::Internal::Adaptor::Window*>( *iter ) );
+ if ( window )
+ {
+ windows.push_back( window );
+ }
+ }
+
+ return windows;
+}
+
+Dali::SceneHolderList Adaptor::GetSceneHolders() const
+{
+ Dali::SceneHolderList sceneHolderList;
+
+ for( auto iter = mWindows.begin(); iter != mWindows.end(); ++iter )
+ {
+ sceneHolderList.push_back( Dali::Integration::SceneHolder( *iter ) );
+ }
+
+ return sceneHolderList;
+}
+
Adaptor::Adaptor(Dali::Integration::SceneHolder window, Dali::Adaptor& adaptor, Dali::RenderSurfaceInterface* surface, EnvironmentOptions* environmentOptions)
: mResizedSignal(),
mLanguageChangedSignal(),
+ mWindowCreatedSignal(),
mAdaptor( adaptor ),
mState( READY ),
mCore( nullptr ),
mThreadController( nullptr ),
- mVSyncMonitor( nullptr ),
mGraphics( nullptr ),
mDisplayConnection( nullptr ),
mWindows(),
+ mConfigurationManager( nullptr ),
mPlatformAbstraction( nullptr ),
mCallbackManager( nullptr ),
mNotificationOnIdleInstalled( false ),
mNotificationTrigger( nullptr ),
- mGestureManager( nullptr ),
mDaliFeedbackPlugin(),
mFeedbackController( nullptr ),
mTtsPlayers(),
mPerformanceInterface( nullptr ),
mKernelTracer(),
mSystemTracer(),
- mTriggerEventFactory(),
mObjectProfiler( nullptr ),
mSocketFactory(),
mEnvironmentOptionsOwned( environmentOptions ? false : true /* If not provided then we own the object */ ),
mUseRemoteSurface( false )
{
DALI_ASSERT_ALWAYS( !IsAvailable() && "Cannot create more than one Adaptor per thread" );
- mWindows.insert( mWindows.begin(), SceneHolderPtr( &Dali::GetImplementation( window ) ) );
+ mWindows.insert( mWindows.begin(), &Dali::GetImplementation( window ) );
gThreadLocalAdaptor = this;
}