X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fadaptor%2Fcommon%2Fadaptor-impl.cpp;h=e06310a26957df7c8a41ec4894c649403672c10c;hb=refs%2Fchanges%2F97%2F227397%2F12;hp=5ddb445766a284dbb5a94b0b5eed121fce577f11;hpb=39aa1ca3375a2f47686bfe95523c51ca914bb310;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 5ddb445..e06310a 100755 --- a/dali/internal/adaptor/common/adaptor-impl.cpp +++ b/dali/internal/adaptor/common/adaptor-impl.cpp @@ -1,5 +1,5 @@ /* - * 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. @@ -39,6 +39,7 @@ #include #include #include +#include #include #include // Temporary until Core is abstracted @@ -54,9 +55,9 @@ #include #include #include -#include #include #include +#include // For Utils::MakeUnique #include #include @@ -66,9 +67,13 @@ #include #include +#include +#include using Dali::TextAbstraction::FontClient; +extern std::string GetSystemCachePath(); + namespace Dali { @@ -80,7 +85,9 @@ namespace Adaptor 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 ) @@ -138,14 +145,6 @@ void Adaptor::Initialize( GraphicsFactory& graphicsFactory, Dali::Configuration: 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 ); @@ -156,7 +155,7 @@ void Adaptor::Initialize( GraphicsFactory& graphicsFactory, Dali::Configuration: mCallbackManager = CallbackManager::New(); - SceneHolderPtr defaultWindow = mWindows.front(); + Dali::Internal::Adaptor::SceneHolder* defaultWindow = mWindows.front(); DALI_ASSERT_DEBUG( defaultWindow->GetSurface() && "Surface not initialized" ); @@ -170,27 +169,30 @@ void Adaptor::Initialize( GraphicsFactory& graphicsFactory, Dali::Configuration: GlImplementation& mGLES = eglGraphics->GetGlesInterface(); EglSyncImplementation& eglSyncImpl = eglGraphics->GetSyncImplementation(); + EglContextHelperImplementation& eglContextHelperImpl = eglGraphics->GetContextHelperImplementation(); mCore = Integration::Core::New( *this, *mPlatformAbstraction, mGLES, eglSyncImpl, - 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() ); @@ -273,12 +275,39 @@ void Adaptor::Initialize( GraphicsFactory& graphicsFactory, Dali::Configuration: { 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( systemCachePath, eglGraphics, mThreadController ); } Adaptor::~Adaptor() @@ -298,7 +327,6 @@ Adaptor::~Adaptor() mWindows.clear(); delete mThreadController; // this will shutdown render thread, which will call Core::ContextDestroyed before exit - delete mVSyncMonitor; delete mObjectProfiler; delete mCore; @@ -335,7 +363,7 @@ void Adaptor::Start() // Start the callback manager mCallbackManager->Start(); - SceneHolderPtr defaultWindow = mWindows.front(); + Dali::Internal::Adaptor::SceneHolder* defaultWindow = mWindows.front(); unsigned int dpiHor, dpiVer; dpiHor = dpiVer = 0; @@ -346,12 +374,21 @@ void Adaptor::Start() 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 @@ -376,7 +413,7 @@ void Adaptor::Pause() } // Pause all windows event handlers when adaptor paused - for( SceneHolderPtr window : mWindows ) + for( auto window : mWindows ) { window->Pause(); } @@ -404,7 +441,7 @@ void Adaptor::Resume() mState = RUNNING; // Reset the event handlers when adaptor resumed - for( SceneHolderPtr window : mWindows ) + for( auto window : mWindows ) { window->Resume(); } @@ -499,13 +536,10 @@ void Adaptor::FeedKeyEvent( KeyEvent& keyEvent ) 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 ); @@ -560,18 +594,31 @@ void Adaptor::RemoveIdle( CallbackBase* callback ) mCallbackManager->RemoveIdleCallback( callback ); } +void Adaptor::ProcessIdle() +{ + bool idleProcessed = mCallbackManager->ProcessIdle(); + mNotificationOnIdleInstalled = mNotificationOnIdleInstalled && !idleProcessed; +} + void Adaptor::SetPreRenderCallback( CallbackBase* callback ) { 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; } @@ -644,11 +691,6 @@ void Adaptor::SetRenderRefreshRate( unsigned int numberOfVSyncsPerRender ) mThreadController->SetRenderRefreshRate( numberOfVSyncsPerRender ); } -void Adaptor::SetUseHardwareVSync( bool useHardware ) -{ - mVSyncMonitor->SetUseHardwareVSync( useHardware ); -} - Dali::DisplayConnection& Adaptor::GetDisplayConnectionInterface() { DALI_ASSERT_DEBUG( mDisplayConnection && "Display connection not created" ); @@ -671,11 +713,6 @@ TriggerEventInterface& Adaptor::GetProcessCoreEventsTrigger() return *mNotificationTrigger; } -TriggerEventFactoryInterface& Adaptor::GetTriggerEventFactoryInterface() -{ - return mTriggerEventFactory; -} - SocketFactoryInterface& Adaptor::GetSocketFactoryInterface() { return mSocketFactory; @@ -691,11 +728,6 @@ Dali::RenderSurfaceInterface* Adaptor::GetRenderSurfaceInterface() return nullptr; } -VSyncMonitorInterface* Adaptor::GetVSyncMonitorInterface() -{ - return mVSyncMonitor; -} - TraceInterface& Adaptor::GetKernelTraceInterface() { return mKernelTracer; @@ -717,6 +749,11 @@ Integration::PlatformAbstraction& Adaptor::GetPlatformAbstraction() const return *mPlatformAbstraction; } +void Adaptor::GetWindowContainerInterface( WindowContainer& windows ) +{ + windows = mWindows; +} + void Adaptor::DestroyTtsPlayer(Dali::TtsPlayer::Mode mode) { if( mTtsPlayers[mode] ) @@ -730,6 +767,24 @@ Any Adaptor::GetNativeWindowHandle() return mWindows.front()->GetNativeHandle(); } +Any Adaptor::GetNativeWindowHandle( Dali::Actor actor ) +{ + 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() { Any display; @@ -808,11 +863,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; } @@ -836,7 +890,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; @@ -846,19 +900,26 @@ 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: 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() ) { @@ -868,17 +929,29 @@ void Adaptor::OnWindowHidden() } // 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 ); } } @@ -891,19 +964,17 @@ void Adaptor::OnDamaged( const DamageArea& area ) 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() @@ -920,9 +991,22 @@ 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() @@ -950,11 +1034,21 @@ void Adaptor::UnregisterProcessor( Integration::Processor& processor ) GetCore().UnregisterProcessor(processor); } +bool Adaptor::IsMultipleWindowSupported() const +{ + return mConfigurationManager->IsMultipleWindowSupported(); +} + +bool Adaptor::IsRenderingWindows() const +{ + return ( mThreadController && mThreadController->IsRenderingWindows() ); +} + void Adaptor::RequestUpdateOnce() { if( mThreadController ) { - mThreadController->RequestUpdateOnce(); + mThreadController->RequestUpdateOnce( UpdateMode::NORMAL ); } } @@ -976,24 +1070,54 @@ Dali::Internal::Adaptor::SceneHolder* Adaptor::GetWindow( Dali::Actor& actor ) { 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( *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 ), @@ -1006,14 +1130,13 @@ Adaptor::Adaptor(Dali::Integration::SceneHolder window, Dali::Adaptor& adaptor, 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; }