/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
// CLASS HEADER
#include <dali/internal/adaptor/common/adaptor-impl.h>
+#include <dali/internal/adaptor/common/adaptor-builder-impl.h>
// EXTERNAL INCLUDES
-#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/common/stage.h>
#include <dali/public-api/actors/layer.h>
+#include <dali/public-api/object/any.h>
#include <dali/devel-api/actors/actor-devel.h>
#include <dali/integration-api/debug.h>
#include <dali/integration-api/core.h>
#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>
+
+#include <fstream>
// INTERNAL INCLUDES
+#include <dali/public-api/dali-adaptor-common.h>
#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/devel-api/text-abstraction/font-client.h>
#include <dali/internal/system/common/callback-manager.h>
-#include <dali/devel-api/adaptor-framework/render-surface.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/gles20/gl-proxy-implementation.h>
-#include <dali/internal/graphics/gles20/gl-implementation.h>
-#include <dali/internal/graphics/gles20/egl-sync-implementation.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/graphics/gles20/egl-factory.h>
-#include <dali/internal/input/common/imf-manager-impl.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/window-impl.h>
+#include <dali/internal/window-system/common/window-render-surface.h>
#include <dali/internal/system/common/logging.h>
-#include <dali/devel-api/adaptor-framework/image-loading.h>
#include <dali/internal/system/common/locale-utils.h>
+#include <dali/internal/imaging/common/image-loader-plugin-proxy.h>
+#include <dali/internal/imaging/common/image-loader.h>
+
+#include <dali/devel-api/adaptor-framework/file-stream.h>
using Dali::TextAbstraction::FontClient;
+extern std::string GetSystemCachePath();
+
namespace Dali
{
thread_local Adaptor* gThreadLocalAdaptor = NULL; // raw thread specific pointer to allow Adaptor::Get
} // unnamed namespace
-Dali::Adaptor* Adaptor::New( Any nativeWindow, RenderSurface *surface, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions )
+Dali::Adaptor* Adaptor::New( Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface *surface, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions )
{
Dali::Adaptor* adaptor = new Dali::Adaptor;
- Adaptor* impl = new Adaptor( nativeWindow, *adaptor, surface, environmentOptions );
+ Adaptor* impl = new Adaptor( window, *adaptor, surface, environmentOptions );
adaptor->mImpl = impl;
- impl->Initialize(configuration);
+ Dali::Internal::Adaptor::AdaptorBuilder* mAdaptorBuilder = new AdaptorBuilder();
+ auto graphicsFactory = mAdaptorBuilder->GetGraphicsFactory();
+
+ impl->Initialize( graphicsFactory, configuration );
+ delete mAdaptorBuilder; // Not needed anymore as the graphics interface has now been created
return adaptor;
}
-Dali::Adaptor* Adaptor::New( Dali::Window window, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions )
+Dali::Adaptor* Adaptor::New( Dali::Integration::SceneHolder window, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions )
{
- Any winId = window.GetNativeHandle();
-
- Window& windowImpl = Dali::GetImplementation(window);
- Dali::Adaptor* adaptor = New( winId, windowImpl.GetSurface(), configuration, environmentOptions );
- windowImpl.SetAdaptor(*adaptor);
+ Internal::Adaptor::SceneHolder& windowImpl = Dali::GetImplementation( window );
+ Dali::Adaptor* adaptor = New( window, windowImpl.GetSurface(), configuration, environmentOptions );
+ windowImpl.SetAdaptor( *adaptor );
return adaptor;
}
-void Adaptor::Initialize( Dali::Configuration::ContextLoss configuration )
+Dali::Adaptor* Adaptor::New( GraphicsFactory& graphicsFactory, Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface *surface, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions )
+{
+ Dali::Adaptor* adaptor = new Dali::Adaptor; // Public adaptor
+ Adaptor* impl = new Adaptor( window, *adaptor, surface, environmentOptions ); // Impl adaptor
+ adaptor->mImpl = impl;
+
+ impl->Initialize( graphicsFactory, configuration );
+
+ return adaptor;
+} // Called second
+
+Dali::Adaptor* Adaptor::New( GraphicsFactory& graphicsFactory, Dali::Integration::SceneHolder window, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions )
+{
+ Internal::Adaptor::SceneHolder& windowImpl = Dali::GetImplementation( window );
+ Dali::Adaptor* adaptor = New( graphicsFactory, window, windowImpl.GetSurface(), configuration, environmentOptions );
+ windowImpl.SetAdaptor( *adaptor );
+ return adaptor;
+} // Called first
+
+void Adaptor::Initialize( GraphicsFactory& graphicsFactory, Dali::Configuration::ContextLoss configuration )
{
// all threads here (event, update, and render) will send their logs to TIZEN Platform's LogMessage handler.
Dali::Integration::Log::LogFunction logFunction( Dali::TizenPlatform::LogMessage );
{
dataRetentionPolicy = ResourcePolicy::DALI_DISCARDS_ALL_DATA;
}
- // Note, Tizen does not use DALI_RETAINS_ALL_DATA, as it can reload images from
- // files automatically.
+
+ // Note, Tizen does not use DALI_RETAINS_ALL_DATA, as it can reload images from files automatically.
if( mEnvironmentOptions->PerformanceServerRequired() )
{
mCallbackManager = CallbackManager::New();
- PositionSize size = mSurface->GetPositionSize();
+ Dali::Internal::Adaptor::SceneHolder* defaultWindow = mWindows.front();
- mGestureManager = new GestureManager(*this, Vector2(size.width, size.height), mCallbackManager, *mEnvironmentOptions);
+ DALI_ASSERT_DEBUG( defaultWindow->GetSurface() && "Surface not initialized" );
- if( mEnvironmentOptions->GetGlesCallTime() > 0 )
- {
- mGLES = new GlProxyImplementation( *mEnvironmentOptions );
- }
- else
- {
- mGLES = new GlImplementation();
- }
+ mGraphics = &( graphicsFactory.Create() );
+ mGraphics->Initialize( mEnvironmentOptions );
- const Integration::DepthBufferAvailable depthBufferAvailable = static_cast< Integration::DepthBufferAvailable >( mEnvironmentOptions->DepthBufferRequired() );
- const Integration::StencilBufferAvailable stencilBufferAvailable = static_cast< Integration::StencilBufferAvailable >( mEnvironmentOptions->StencilBufferRequired() );
+ auto eglGraphics = static_cast<EglGraphics *>( mGraphics ); // This interface is temporary until Core has been updated to match
- mEglFactory = new EglFactory( mEnvironmentOptions->GetMultiSamplingLevel(), depthBufferAvailable, stencilBufferAvailable );
+ // This will only be created once
+ eglGraphics->Create();
- EglSyncImplementation* eglSyncImpl = mEglFactory->GetSyncImplementation();
+ GlImplementation& mGLES = eglGraphics->GetGlesInterface();
+ EglSyncImplementation& eglSyncImpl = eglGraphics->GetSyncImplementation();
+ EglContextHelperImplementation& eglContextHelperImpl = eglGraphics->GetContextHelperImplementation();
mCore = Integration::Core::New( *this,
*mPlatformAbstraction,
- *mGLES,
- *eglSyncImpl,
- *mGestureManager,
+ mGLES,
+ eglSyncImpl,
+ eglContextHelperImpl,
dataRetentionPolicy ,
( 0u != mEnvironmentOptions->GetRenderToFboInterval() ) ? Integration::RenderToFrameBuffer::TRUE : Integration::RenderToFrameBuffer::FALSE,
- depthBufferAvailable,
- stencilBufferAvailable );
+ mGraphics->GetDepthBufferRequired(),
+ mGraphics->GetStencilBufferRequired() );
+
+ defaultWindow->SetAdaptor( Get() );
+
+ Dali::Integration::SceneHolder defaultSceneHolder( defaultWindow );
+
+ mWindowCreatedSignal.Emit( defaultSceneHolder );
const unsigned int timeInterval = mEnvironmentOptions->GetObjectProfilerInterval();
if( 0u < timeInterval )
mNotificationTrigger = mTriggerEventFactory.CreateTriggerEvent( MakeCallback( this, &Adaptor::ProcessCoreEvents ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER);
- mVSyncMonitor = new VSyncMonitor;
+ mDisplayConnection = Dali::DisplayConnection::New( *mGraphics, defaultWindow->GetSurface()->GetSurfaceType() );
mThreadController = new ThreadController( *this, *mEnvironmentOptions );
{
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() );
+ }
// Set max texture size
if( mEnvironmentOptions->GetMaxTextureSize() > 0 )
{
- Dali::SetMaxTextureSize( mEnvironmentOptions->GetMaxTextureSize() );
+ Dali::TizenPlatform::ImageLoader::SetMaxTextureSize( mEnvironmentOptions->GetMaxTextureSize() );
}
- SetupSystemInformation();
+ std::string systemCachePath = GetSystemCachePath();
+ if ( ! systemCachePath.empty() )
+ {
+ Dali::FileStream fileStream( systemCachePath + "gpu-environment.conf", Dali::FileStream::READ | Dali::FileStream::TEXT );
+ std::fstream& stream = dynamic_cast<std::fstream&>( fileStream.GetStream() );
+ if( stream.is_open() )
+ {
+ std::string line;
+ while( std::getline( stream, line ) )
+ {
+ line.erase( line.find_last_not_of( " \t\r\n" ) + 1 );
+ line.erase( 0, line.find_first_not_of( " \t\r\n" ) );
+ if( '#' == *( line.cbegin() ) || line == "" )
+ {
+ continue;
+ }
+
+ std::istringstream stream( line );
+ std::string environmentVariableName, environmentVariableValue;
+ std::getline(stream, environmentVariableName, ' ');
+ if( environmentVariableName == "DALI_ENV_MAX_TEXTURE_SIZE" && mEnvironmentOptions->GetMaxTextureSize() == 0 )
+ {
+ std::getline(stream, environmentVariableValue);
+ setenv( environmentVariableName.c_str() , environmentVariableValue.c_str(), 1 );
+ Dali::TizenPlatform::ImageLoader::SetMaxTextureSize( std::atoi( environmentVariableValue.c_str() ) );
+ }
+ }
+ }
+ else
+ {
+ DALI_LOG_ERROR( "Fail to open file : %s\n", ( systemCachePath + "gpu-environment.conf" ).c_str() );
+ }
+ }
}
Adaptor::~Adaptor()
(*iter)->OnDestroy();
}
+ // Clear out all the handles to Windows
+ mWindows.clear();
+
delete mThreadController; // this will shutdown render thread, which will call Core::ContextDestroyed before exit
- delete mVSyncMonitor;
- delete mEventHandler;
delete mObjectProfiler;
delete mCore;
- delete mEglFactory;
- delete mGLES;
- delete mGestureManager;
+
+ delete mDisplayConnection;
delete mPlatformAbstraction;
delete mCallbackManager;
delete mPerformanceInterface;
+ mGraphics->Destroy();
+
// uninstall it on this thread (main actor thread)
Dali::Integration::Log::UninstallLogFunction();
void Adaptor::Start()
{
- // it doesn't support restart after stop at this moment
- // to support restarting, need more testing
+ // It doesn't support restart after stop at this moment to support restarting, need more testing
if( READY != mState )
{
return;
}
+ mCore->Initialize();
+
+ SetupSystemInformation();
+
// Start the callback manager
mCallbackManager->Start();
- // create event handler
- mEventHandler = new EventHandler( mSurface, *this, *mGestureManager, *this, mDragAndDropDetector );
-
- if( mDeferredRotationObserver != NULL )
- {
- mEventHandler->SetRotationObserver(mDeferredRotationObserver);
- mDeferredRotationObserver = NULL;
- }
+ Dali::Internal::Adaptor::SceneHolder* defaultWindow = mWindows.front();
unsigned int dpiHor, dpiVer;
dpiHor = dpiVer = 0;
- Dali::DisplayConnection::GetDpi(dpiHor, dpiVer);
- // tell core about the DPI value
- mCore->SetDpi(dpiHor, dpiVer);
+ defaultWindow->GetSurface()->GetDpi( dpiHor, dpiVer );
// set the DPI value for font rendering
FontClient fontClient = FontClient::Get();
fontClient.SetDpi( dpiHor, dpiVer );
- // Tell the core the size of the surface just before we start the render-thread
- PositionSize size = mSurface->GetPositionSize();
- mCore->SurfaceResized( size.width, size.height );
-
// Initialize the thread controller
mThreadController->Initialize();
+ if( !Dali::TizenPlatform::ImageLoader::MaxTextureSizeUpdated() )
+ {
+ auto eglGraphics = static_cast<EglGraphics *>( mGraphics );
+ GlImplementation& mGLES = eglGraphics->GetGlesInterface();
+ Dali::TizenPlatform::ImageLoader::SetMaxTextureSize( mGLES.GetMaxTextureSize() );
+
+ std::string systemCachePath = GetSystemCachePath();
+ if( ! systemCachePath.empty() )
+ {
+ const int dir_err = system( std::string( "mkdir " + systemCachePath ).c_str() );
+ if (-1 == dir_err)
+ {
+ printf("Error creating directory!n");
+ exit(1);
+ }
+
+ Dali::FileStream fileStream( systemCachePath + "gpu-environment.conf", Dali::FileStream::WRITE | Dali::FileStream::TEXT );
+ std::fstream& configFile = dynamic_cast<std::fstream&>( fileStream.GetStream() );
+ if( configFile.is_open() )
+ {
+ configFile << "DALI_ENV_MAX_TEXTURE_SIZE " << mGLES.GetMaxTextureSize() << std::endl;
+ }
+ }
+ }
+
ProcessCoreEvents(); // Ensure any startup messages are processed.
+ // Initialize the image loader plugin
+ Internal::Adaptor::ImageLoaderPluginProxy::Initialize();
+
for ( ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter )
{
(*iter)->OnStart();
(*iter)->OnPause();
}
- // Reset the event handler when adaptor paused
- if( mEventHandler )
+ // Pause all windows event handlers when adaptor paused
+ for( auto window : mWindows )
{
- mEventHandler->Pause();
+ window->Pause();
}
mThreadController->Pause();
// Ensure any messages queued during pause callbacks are processed by doing another update.
RequestUpdateOnce();
+
+ DALI_LOG_RELEASE_INFO( "Adaptor::Pause: Paused\n" );
+ }
+ else
+ {
+ DALI_LOG_RELEASE_INFO( "Adaptor::Pause: Not paused [%d]\n", mState );
}
}
{
mState = RUNNING;
- // Reset the event handler when adaptor resumed
- if( mEventHandler )
+ // Reset the event handlers when adaptor resumed
+ for( auto window : mWindows )
{
- mEventHandler->Resume();
+ window->Resume();
}
// Inform observers that we have resumed.
(*iter)->OnResume();
}
- // trigger processing of events queued up while paused
+ // Trigger processing of events queued up while paused
mCore->ProcessEvents();
// Do at end to ensure our first update/render after resumption includes the processed messages as well
mThreadController->Resume();
+
+ DALI_LOG_RELEASE_INFO( "Adaptor::Resume: Resumed\n");
+ }
+ else
+ {
+ DALI_LOG_RELEASE_INFO( "Adaptor::Resume: Not resumed [%d]\n", mState );
}
}
mThreadController->Stop();
// Delete the TTS player
- for(int i =0; i < Dali::TtsPlayer::MODE_NUM; i++)
+ for( int i =0; i < Dali::TtsPlayer::MODE_NUM; i++ )
{
- if(mTtsPlayers[i])
+ if( mTtsPlayers[i] )
{
mTtsPlayers[i].Reset();
}
}
- delete mEventHandler;
- mEventHandler = NULL;
+ // Destroy the image loader plugin
+ Internal::Adaptor::ImageLoaderPluginProxy::Destroy();
delete mNotificationTrigger;
mNotificationTrigger = NULL;
mCallbackManager->Stop();
mState = STOPPED;
+
+ DALI_LOG_RELEASE_INFO( "Adaptor::Stop\n" );
}
}
void Adaptor::FeedTouchPoint( TouchPoint& point, int timeStamp )
{
- mEventHandler->FeedTouchPoint( point, timeStamp );
+ Integration::Point convertedPoint( point );
+ mWindows.front()->FeedTouchPoint( convertedPoint, timeStamp );
}
void Adaptor::FeedWheelEvent( WheelEvent& wheelEvent )
{
- mEventHandler->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 )
{
- mEventHandler->FeedKeyEvent( keyEvent );
+ Integration::KeyEvent convertedEvent( keyEvent );
+ mWindows.front()->FeedKeyEvent( convertedEvent );
}
-void Adaptor::ReplaceSurface( Any nativeWindow, RenderSurface& surface )
+void Adaptor::ReplaceSurface( Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface& newSurface )
{
- PositionSize positionSize = surface.GetPositionSize();
+ Internal::Adaptor::SceneHolder* windowImpl = &Dali::GetImplementation( window );
+ for( auto windowPtr : mWindows )
+ {
+ if( windowPtr == windowImpl ) // the window is not deleted
+ {
+ mResizedSignal.Emit( mAdaptor );
- // let the core know the surface size has changed
- mCore->SurfaceResized( positionSize.width, positionSize.height );
+ windowImpl->SetSurface( &newSurface );
- mResizedSignal.Emit( mAdaptor );
+ // 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();
- mNativeWindow = nativeWindow;
- mSurface = &surface;
+ // This method blocks until the render thread has completed the replace.
+ mThreadController->ReplaceSurface( &newSurface );
+ break;
+ }
+ }
+}
- // flush the event queue to give the update-render thread chance
+void Adaptor::DeleteSurface( Dali::RenderSurfaceInterface& surface )
+{
+ // 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();
- // this method blocks until the render thread has completed the replace.
- mThreadController->ReplaceSurface(mSurface);
+ // This method blocks until the render thread has finished rendering the current surface.
+ mThreadController->DeleteSurface( &surface );
}
-RenderSurface& Adaptor::GetSurface() const
+Dali::RenderSurfaceInterface& Adaptor::GetSurface() const
{
- return *mSurface;
+ return *mWindows.front()->GetSurface();
}
void Adaptor::ReleaseSurfaceLock()
{
- mSurface->ReleaseLock();
+ mWindows.front()->GetSurface()->ReleaseLock();
}
Dali::TtsPlayer Adaptor::GetTtsPlayer(Dali::TtsPlayer::Mode mode)
{
- if(!mTtsPlayers[mode])
+ if( !mTtsPlayers[mode] )
{
// Create the TTS player when it needed, because it can reduce launching time.
mTtsPlayers[mode] = TtsPlayer::New(mode);
return mTtsPlayers[mode];
}
-bool Adaptor::AddIdle( CallbackBase* callback, bool forceAdd )
+bool Adaptor::AddIdle( CallbackBase* callback, bool hasReturnValue, bool forceAdd )
{
bool idleAdded(false);
// Only add an idle if the Adaptor is actually running
if( RUNNING == mState || READY == mState || forceAdd )
{
- idleAdded = mCallbackManager->AddIdleCallback( callback );
+ idleAdded = mCallbackManager->AddIdleCallback( callback, hasReturnValue );
}
return idleAdded;
mCallbackManager->RemoveIdleCallback( callback );
}
+void Adaptor::SetPreRenderCallback( CallbackBase* callback )
+{
+ mThreadController->SetPreRenderCallback( callback );
+}
+
+bool Adaptor::AddWindow( Dali::Integration::SceneHolder childWindow, const std::string& childWindowName, const std::string& childWindowClassName, bool childWindowMode )
+{
+ 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( &windowImpl );
+
+ mWindowCreatedSignal.Emit( childWindow );
+
+ return true;
+}
+
+bool Adaptor::RemoveWindow( Dali::Integration::SceneHolder* childWindow )
+{
+ Internal::Adaptor::SceneHolder& windowImpl = Dali::GetImplementation( *childWindow );
+ for ( WindowContainer::iterator iter = mWindows.begin(); iter != mWindows.end(); ++iter )
+ {
+ if( *iter == &windowImpl )
+ {
+ mWindows.erase( iter );
+ return true;
+ }
+ }
+
+ return false;
+}
+
+bool Adaptor::RemoveWindow( std::string childWindowName )
+{
+ for ( WindowContainer::iterator iter = mWindows.begin(); iter != mWindows.end(); ++iter )
+ {
+ if( ( *iter )->GetName() == childWindowName )
+ {
+ mWindows.erase( iter );
+ return true;
+ }
+ }
+
+ return false;
+}
+
+bool Adaptor::RemoveWindow( Internal::Adaptor::SceneHolder* childWindow )
+{
+ for ( WindowContainer::iterator iter = mWindows.begin(); iter != mWindows.end(); ++iter )
+ {
+ if( ( *iter )->GetId() == childWindow->GetId() )
+ {
+ mWindows.erase( iter );
+ return true;
+ }
+ }
+
+ return false;
+}
+
Dali::Adaptor& Adaptor::Get()
{
DALI_ASSERT_ALWAYS( IsAvailable() && "Adaptor not instantiated" );
mThreadController->SetRenderRefreshRate( numberOfVSyncsPerRender );
}
-void Adaptor::SetUseHardwareVSync( bool useHardware )
-{
- mVSyncMonitor->SetUseHardwareVSync( useHardware );
-}
-
-EglFactory& Adaptor::GetEGLFactory() const
+Dali::DisplayConnection& Adaptor::GetDisplayConnectionInterface()
{
- DALI_ASSERT_DEBUG( mEglFactory && "EGL Factory not created" );
- return *mEglFactory;
+ DALI_ASSERT_DEBUG( mDisplayConnection && "Display connection not created" );
+ return *mDisplayConnection;
}
-EglFactoryInterface& Adaptor::GetEGLFactoryInterface() const
+GraphicsInterface& Adaptor::GetGraphicsInterface()
{
- return *mEglFactory;
-}
-
-Integration::GlAbstraction& Adaptor::GetGlAbstraction() const
-{
- DALI_ASSERT_DEBUG( mGLES && "GLImplementation not created" );
- return *mGLES;
+ DALI_ASSERT_DEBUG( mGraphics && "Graphics interface not created" );
+ return *mGraphics;
}
Dali::Integration::PlatformAbstraction& Adaptor::GetPlatformAbstractionInterface()
return *mPlatformAbstraction;
}
-Dali::Integration::GlAbstraction& Adaptor::GetGlesInterface()
-{
- return *mGLES;
-}
-
TriggerEventInterface& Adaptor::GetProcessCoreEventsTrigger()
{
return *mNotificationTrigger;
return mSocketFactory;
}
-RenderSurface* Adaptor::GetRenderSurfaceInterface()
+Dali::RenderSurfaceInterface* Adaptor::GetRenderSurfaceInterface()
{
- return mSurface;
-}
+ if( !mWindows.empty() )
+ {
+ return mWindows.front()->GetSurface();
+ }
-VSyncMonitorInterface* Adaptor::GetVSyncMonitorInterface()
-{
- return mVSyncMonitor;
+ return nullptr;
}
TraceInterface& Adaptor::GetKernelTraceInterface()
return *mPlatformAbstraction;
}
-void Adaptor::SetDragAndDropDetector( DragAndDropDetectorPtr detector )
+void Adaptor::DestroyTtsPlayer(Dali::TtsPlayer::Mode mode)
{
- mDragAndDropDetector = detector;
-
- if ( mEventHandler )
+ if( mTtsPlayers[mode] )
{
- mEventHandler->SetDragAndDropDetector( detector );
+ mTtsPlayers[mode].Reset();
}
}
-void Adaptor::SetRotationObserver( RotationObserver* observer )
+Any Adaptor::GetNativeWindowHandle()
{
- if( mEventHandler )
- {
- mEventHandler->SetRotationObserver( observer );
- }
- else if( mState == READY )
- {
- // Set once event handler exists
- mDeferredRotationObserver = observer;
- }
+ return mWindows.front()->GetNativeHandle();
}
-void Adaptor::DestroyTtsPlayer(Dali::TtsPlayer::Mode mode)
+Any Adaptor::GetNativeWindowHandle( Dali::Actor actor )
{
- if(mTtsPlayers[mode])
+ Any nativeWindowHandle;
+
+ Dali::Integration::Scene scene = Dali::Integration::Scene::Get( actor );
+
+ for( auto sceneHolder : mWindows )
{
- mTtsPlayers[mode].Reset();
+ if ( scene == sceneHolder->GetScene() )
+ {
+ nativeWindowHandle = sceneHolder->GetNativeHandle();
+ break;
+ }
}
+
+ return nativeWindowHandle;
}
-void Adaptor::SetMinimumPinchDistance(float distance)
+Any Adaptor::GetGraphicsDisplay()
{
- if( mGestureManager )
+ Any display;
+
+ if (mGraphics)
{
- mGestureManager->SetMinimumPinchDistance(distance);
+ auto eglGraphics = static_cast<EglGraphics *>( mGraphics ); // This interface is temporary until Core has been updated to match
+
+ EglImplementation& eglImpl = eglGraphics->GetEglImplementation();
+ display = eglImpl.GetDisplay();
}
-}
-Any Adaptor::GetNativeWindowHandle()
-{
- return mNativeWindow;
+ return display;
}
void Adaptor::SetUseRemoteSurface(bool useRemoteSurface)
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;
}
// and we haven't installed the idle notification
if( ( ! mNotificationOnIdleInstalled ) && ( RUNNING == mState || READY == mState || forceProcess ) )
{
- mNotificationOnIdleInstalled = AddIdle( MakeCallback( this, &Adaptor::ProcessCoreEventsFromIdle ), forceProcess );
+ mNotificationOnIdleInstalled = AddIdleEnterer( MakeCallback( this, &Adaptor::ProcessCoreEventsFromIdle ), forceProcess );
}
}
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: Adaptor is not paused state.[%d]\n", mState );
+ }
}
void Adaptor::OnWindowHidden()
{
- if ( RUNNING == mState )
+ if( RUNNING == mState || READY == mState )
{
- Pause();
+ bool allWindowsHidden = true;
- // Adaptor cannot be resumed until the window is shown
- mState = PAUSED_WHILE_HIDDEN;
+ for( auto window : mWindows )
+ {
+ if ( window->IsVisible() )
+ {
+ allWindowsHidden = false;
+ break;
+ }
+ }
+
+ // Only pause the adaptor when all the windows are hidden
+ if( allWindowsHidden )
+ {
+ if( mState == RUNNING )
+ {
+ Pause();
+
+ // 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: Adaptor is not running state.[%d]\n", mState );
}
}
RequestUpdate( false );
}
-void Adaptor::SurfaceResizePrepare( SurfaceSize surfaceSize )
+void Adaptor::SurfaceResizePrepare( Dali::RenderSurfaceInterface* surface, SurfaceSize surfaceSize )
{
- // let the core know the surface size has changed
- mCore->SurfaceResized( surfaceSize.GetWidth(), surfaceSize.GetHeight() );
-
mResizedSignal.Emit( mAdaptor );
}
-void Adaptor::SurfaceResizeComplete( SurfaceSize surfaceSize )
+void Adaptor::SurfaceResizeComplete( Dali::RenderSurfaceInterface* surface, SurfaceSize surfaceSize )
{
- // flush the event queue to give the update-render thread chance
+ // 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();
- // this method blocks until the render thread has completed the resizing.
mThreadController->ResizeSurface();
}
{
GetCore().SceneCreated();
+ // 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();
+
// Start thread controller after the scene has been created
mThreadController->Start();
- // process after surface is created (registering to remote surface provider if required)
+ // 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;
+
+ Pause();
+
+ mState = PAUSED_WHILE_HIDDEN;
+
+ DALI_LOG_RELEASE_INFO( "Adaptor::NotifySceneCreated: Adaptor is paused\n" );
+ }
}
void Adaptor::NotifyLanguageChanged()
return *mEnvironmentOptions;
}
+void Adaptor::RegisterProcessor( Integration::Processor& processor )
+{
+ GetCore().RegisterProcessor(processor);
+}
+
+void Adaptor::UnregisterProcessor( Integration::Processor& processor )
+{
+ GetCore().UnregisterProcessor(processor);
+}
+
void Adaptor::RequestUpdateOnce()
{
if( mThreadController )
{
- mThreadController->RequestUpdateOnce();
+ mThreadController->RequestUpdateOnce( UpdateMode::NORMAL );
}
}
-void Adaptor::IndicatorSizeChanged(int height)
-{
- // let the core know the indicator height is changed
- mCore->SetTopMargin(height);
-}
-
-void Adaptor::ProcessCoreEventsFromIdle()
+bool Adaptor::ProcessCoreEventsFromIdle()
{
ProcessCoreEvents();
// the idle handle automatically un-installs itself
mNotificationOnIdleInstalled = false;
+
+ return false;
}
-Adaptor::Adaptor(Any nativeWindow, Dali::Adaptor& adaptor, RenderSurface* surface, EnvironmentOptions* environmentOptions)
+Dali::Internal::Adaptor::SceneHolder* Adaptor::GetWindow( Dali::Actor& actor )
+{
+ Dali::Integration::Scene scene = Dali::Integration::Scene::Get( actor );
+
+ for( auto window : mWindows )
+ {
+ if ( scene == window->GetScene() )
+ {
+ 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( NULL ),
- mThreadController( NULL ),
- mVSyncMonitor( NULL ),
- mGLES( NULL ),
- mGlSync( NULL ),
- mEglFactory( NULL ),
- mNativeWindow( nativeWindow ),
- mSurface( surface ),
- mPlatformAbstraction( NULL ),
- mEventHandler( NULL ),
- mCallbackManager( NULL ),
+ mCore( nullptr ),
+ mThreadController( nullptr ),
+ mGraphics( nullptr ),
+ mDisplayConnection( nullptr ),
+ mWindows(),
+ mPlatformAbstraction( nullptr ),
+ mCallbackManager( nullptr ),
mNotificationOnIdleInstalled( false ),
- mNotificationTrigger( NULL ),
- mGestureManager( NULL ),
+ mNotificationTrigger( nullptr ),
mDaliFeedbackPlugin(),
- mFeedbackController( NULL ),
+ mFeedbackController( nullptr ),
mTtsPlayers(),
mObservers(),
- mDragAndDropDetector(),
- mDeferredRotationObserver( NULL ),
mEnvironmentOptions( environmentOptions ? environmentOptions : new EnvironmentOptions /* Create the options if not provided */),
- mPerformanceInterface( NULL ),
+ mPerformanceInterface( nullptr ),
mKernelTracer(),
mSystemTracer(),
mTriggerEventFactory(),
- mObjectProfiler( NULL ),
+ 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(), &Dali::GetImplementation( window ) );
+
gThreadLocalAdaptor = this;
}
-// Stereoscopy
-
-void Adaptor::SetViewMode( ViewMode viewMode )
+void Adaptor::SetRootLayoutDirection( std::string locale )
{
- mSurface->SetViewMode( viewMode );
- mCore->SetViewMode( viewMode );
-}
+ Dali::Stage stage = Dali::Stage::GetCurrent();
-ViewMode Adaptor::GetViewMode() const
-{
- return mCore->GetViewMode();
+ stage.GetRootLayer().SetProperty( Dali::Actor::Property::LAYOUT_DIRECTION,
+ static_cast< LayoutDirection::Type >( Internal::Adaptor::Locale::GetDirection( std::string( locale ) ) ) );
}
-void Adaptor::SetStereoBase( float stereoBase )
+bool Adaptor::AddIdleEnterer( CallbackBase* callback, bool forceAdd )
{
- mCore->SetStereoBase( stereoBase );
-}
+ bool idleAdded( false );
-float Adaptor::GetStereoBase() const
-{
- return mCore->GetStereoBase();
+ // Only add an idle if the Adaptor is actually running
+ if( RUNNING == mState || READY == mState || forceAdd )
+ {
+ idleAdded = mCallbackManager->AddIdleEntererCallback( callback );
+ }
+
+ return idleAdded;
}
-void Adaptor::SetRootLayoutDirection( std::string locale )
+void Adaptor::RemoveIdleEnterer( CallbackBase* callback )
{
- Dali::Stage stage = Dali::Stage::GetCurrent();
-
- stage.GetRootLayer().SetProperty( Dali::Actor::Property::LAYOUT_DIRECTION,
- static_cast< LayoutDirection::Type >( Internal::Adaptor::Locale::GetDirection( std::string( locale ) ) ) );
+ mCallbackManager->RemoveIdleEntererCallback( callback );
}
} // namespace Adaptor
projects / platform / core / uifw / dali-adaptor.git / blobdiff