X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fadaptor%2Fcommon%2Fadaptor-impl.cpp;h=50d63ec58b3cd0229a3e979097cc9af2a819d86f;hb=078a6810ed0701920edb0d9d3f88e892dc441b71;hp=e2df71d76dab89c9fe996566e28782cfee083aad;hpb=37d8d7dca35290d61aeb300f8f97bb993998d4e4;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git diff --git a/dali/internal/adaptor/common/adaptor-impl.cpp b/dali/internal/adaptor/common/adaptor-impl.cpp index e2df71d..50d63ec 100755 --- a/dali/internal/adaptor/common/adaptor-impl.cpp +++ b/dali/internal/adaptor/common/adaptor-impl.cpp @@ -1,5 +1,5 @@ /* - * 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. @@ -17,50 +17,63 @@ // CLASS HEADER #include +#include // EXTERNAL INCLUDES #include #include +#include #include #include #include #include #include #include +#include #include +#include +#include + +#include // INTERNAL INCLUDES #include #include #include #include +#include + +#include +#include // Temporary until Core is abstracted #include #include #include #include -#include #include -#include -#include -#include +#include +#include +#include #include -#include #include -#include #include #include #include #include #include -#include #include +#include +#include + +#include using Dali::TextAbstraction::FontClient; +extern std::string GetSystemCachePath(); + namespace Dali { @@ -75,28 +88,49 @@ namespace 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 ); @@ -114,8 +148,8 @@ void Adaptor::Initialize( Dali::Configuration::ContextLoss configuration ) { 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() ) { @@ -127,35 +161,37 @@ void Adaptor::Initialize( Dali::Configuration::ContextLoss configuration ) 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( 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 ) @@ -165,7 +201,7 @@ void Adaptor::Initialize( Dali::Configuration::ContextLoss configuration ) 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 ); @@ -234,14 +270,58 @@ void Adaptor::Initialize( Dali::Configuration::ContextLoss configuration ) { 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( 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() @@ -257,19 +337,21 @@ 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(); @@ -282,45 +364,63 @@ Adaptor::~Adaptor() 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; - mSurface->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( 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( 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(); @@ -339,10 +439,10 @@ void Adaptor::Pause() (*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(); @@ -350,6 +450,12 @@ void Adaptor::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 ); } } @@ -361,10 +467,10 @@ void Adaptor::Resume() { 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. @@ -373,11 +479,17 @@ void Adaptor::Resume() (*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 ); } } @@ -395,16 +507,16 @@ void Adaptor::Stop() 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; @@ -412,6 +524,8 @@ void Adaptor::Stop() mCallbackManager->Stop(); mState = STOPPED; + + DALI_LOG_RELEASE_INFO( "Adaptor::Stop\n" ); } } @@ -430,52 +544,67 @@ void Adaptor::ContextRegained() 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); @@ -507,6 +636,62 @@ 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" ); @@ -533,26 +718,16 @@ void Adaptor::SetRenderRefreshRate( unsigned int numberOfVSyncsPerRender ) 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() @@ -560,11 +735,6 @@ Dali::Integration::PlatformAbstraction& Adaptor::GetPlatformAbstractionInterface return *mPlatformAbstraction; } -Dali::Integration::GlAbstraction& Adaptor::GetGlesInterface() -{ - return *mGLES; -} - TriggerEventInterface& Adaptor::GetProcessCoreEventsTrigger() { return *mNotificationTrigger; @@ -580,14 +750,14 @@ SocketFactoryInterface& Adaptor::GetSocketFactoryInterface() 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() @@ -611,48 +781,50 @@ Integration::PlatformAbstraction& Adaptor::GetPlatformAbstraction() const 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( 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) @@ -718,11 +890,10 @@ void Adaptor::RequestUpdate( bool forceUpdate ) 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; } @@ -746,7 +917,7 @@ void Adaptor::RequestProcessEventsOnIdle( bool forceProcess ) void Adaptor::OnWindowShown() { - if ( PAUSED_WHILE_HIDDEN == mState ) + if( PAUSED_WHILE_HIDDEN == mState ) { // Adaptor can now be resumed mState = PAUSED; @@ -756,16 +927,58 @@ void Adaptor::OnWindowShown() // 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 ); } } @@ -776,17 +989,14 @@ void Adaptor::OnDamaged( const DamageArea& area ) 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(); @@ -797,13 +1007,32 @@ void Adaptor::NotifySceneCreated() { 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() @@ -821,20 +1050,24 @@ const LogFactoryInterface& Adaptor::GetLogFactory() 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); -} - bool Adaptor::ProcessCoreEventsFromIdle() { ProcessCoreEvents(); @@ -845,66 +1078,83 @@ bool Adaptor::ProcessCoreEventsFromIdle() 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( *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" ); - gThreadLocalAdaptor = this; -} - -// Stereoscopy - -void Adaptor::SetViewMode( ViewMode viewMode ) -{ - mSurface->SetViewMode( viewMode ); - mCore->SetViewMode( viewMode ); -} - -ViewMode Adaptor::GetViewMode() const -{ - return mCore->GetViewMode(); -} + mWindows.insert( mWindows.begin(), &Dali::GetImplementation( window ) ); -void Adaptor::SetStereoBase( float stereoBase ) -{ - mCore->SetStereoBase( stereoBase ); -} - -float Adaptor::GetStereoBase() const -{ - return mCore->GetStereoBase(); + gThreadLocalAdaptor = this; } void Adaptor::SetRootLayoutDirection( std::string locale )