/*
- * 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.
// CLASS HEADER
#include <dali/internal/adaptor/common/adaptor-impl.h>
+#include <dali/internal/addons/common/addon-manager-impl.h>
+#include <dali/internal/addons/common/addon-manager-factory.h>
#include <dali/internal/adaptor/common/adaptor-builder-impl.h>
// EXTERNAL INCLUDES
-#include <dali/public-api/common/stage.h>
+#include <errno.h>
+#include <sys/stat.h>
#include <dali/public-api/actors/layer.h>
#include <dali/public-api/object/any.h>
+#include <dali/public-api/object/object-registry.h>
+#include <dali/public-api/events/wheel-event.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/events/touch-event-integ.h>
#include <dali/integration-api/events/wheel-event-integ.h>
#include <dali/integration-api/processor-interface.h>
-
-#include <fstream>
+#include <dali/integration-api/addon-manager.h>
// 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/internal/clipboard/common/clipboard-impl.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/devel-api/adaptor-framework/file-stream.h>
+#include <dali/internal/system/common/configuration-manager.h>
+#include <dali/internal/system/common/environment-variables.h>
using Dali::TextAbstraction::FontClient;
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 );
DALI_ASSERT_DEBUG( defaultWindow->GetSurface() && "Surface not initialized" );
- mGraphics = &( graphicsFactory.Create() );
+ mGraphics = std::unique_ptr< GraphicsInterface >( &graphicsFactory.Create() );
mGraphics->Initialize( mEnvironmentOptions );
- auto eglGraphics = static_cast<EglGraphics *>( mGraphics ); // This interface is temporary until Core has been updated to match
+ GraphicsInterface* graphics = mGraphics.get(); // This interface is temporary until Core has been updated to match
+ auto eglGraphics = static_cast<EglGraphics *>( graphics );
// This will only be created once
eglGraphics->Create();
EglSyncImplementation& eglSyncImpl = eglGraphics->GetSyncImplementation();
EglContextHelperImplementation& eglContextHelperImpl = eglGraphics->GetContextHelperImplementation();
+ // Create the AddOnManager
+ mAddOnManager.reset( Dali::Internal::AddOnManagerFactory::CreateAddOnManager() );
+
mCore = Integration::Core::New( *this,
*mPlatformAbstraction,
mGLES,
eglSyncImpl,
eglContextHelperImpl,
- dataRetentionPolicy ,
( 0u != mEnvironmentOptions->GetRenderToFboInterval() ) ? Integration::RenderToFrameBuffer::TRUE : Integration::RenderToFrameBuffer::FALSE,
mGraphics->GetDepthBufferRequired(),
- mGraphics->GetStencilBufferRequired() );
+ mGraphics->GetStencilBufferRequired(),
+ mGraphics->GetPartialUpdateRequired() );
+
defaultWindow->SetAdaptor( Get() );
const unsigned int timeInterval = mEnvironmentOptions->GetObjectProfilerInterval();
if( 0u < timeInterval )
{
- mObjectProfiler = new ObjectProfiler( timeInterval );
+ mObjectProfiler = new ObjectProfiler( mCore->GetObjectRegistry(), timeInterval );
}
- mNotificationTrigger = mTriggerEventFactory.CreateTriggerEvent( MakeCallback( this, &Adaptor::ProcessCoreEvents ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER);
+ mNotificationTrigger = TriggerEventFactory::CreateTriggerEvent( MakeCallback( this, &Adaptor::ProcessCoreEvents ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER);
mDisplayConnection = Dali::DisplayConnection::New( *mGraphics, defaultWindow->GetSurface()->GetSurfaceType() );
- mThreadController = new ThreadController( *this, *mEnvironmentOptions );
+ mThreadController = new ThreadController( *this, *mEnvironmentOptions, mThreadMode );
// Should be called after Core creation
if( mEnvironmentOptions->GetPanGestureLoggingLevel() )
{
Integration::SetPinchGestureMinimumDistance( mEnvironmentOptions->GetMinimumPinchDistance() );
}
-
- // Set max texture size
- if( mEnvironmentOptions->GetMaxTextureSize() > 0 )
+ if( mEnvironmentOptions->GetMinimumPinchTouchEvents() >= 0 )
{
- Dali::TizenPlatform::ImageLoader::SetMaxTextureSize( mEnvironmentOptions->GetMaxTextureSize() );
+ 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() );
}
std::string systemCachePath = GetSystemCachePath();
- if ( ! systemCachePath.empty() )
+ 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
+ const int dir_err = mkdir( systemCachePath.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH );
+ if ( 0 != dir_err && errno != EEXIST )
{
- DALI_LOG_ERROR( "Fail to open file : %s\n", ( systemCachePath + "gpu-environment.conf" ).c_str() );
+ DALI_LOG_ERROR( "Error creating system cache directory: %s!\n", systemCachePath.c_str() );
+ exit( 1 );
}
}
+
+ mConfigurationManager = Utils::MakeUnique<ConfigurationManager>( systemCachePath, eglGraphics, mThreadController );
}
Adaptor::~Adaptor()
// Initialize the thread controller
mThreadController->Initialize();
- if( !Dali::TizenPlatform::ImageLoader::MaxTextureSizeUpdated() )
+ // Set max texture size
+ if( mEnvironmentOptions->GetMaxTextureSize() > 0 )
{
- 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;
- }
- }
+ Dali::TizenPlatform::ImageLoader::SetMaxTextureSize( mEnvironmentOptions->GetMaxTextureSize() );
+ }
+ else
+ {
+ unsigned int maxTextureSize = mConfigurationManager->GetMaxTextureSize();
+ Dali::TizenPlatform::ImageLoader::SetMaxTextureSize( maxTextureSize );
}
ProcessCoreEvents(); // Ensure any startup messages are processed.
{
(*iter)->OnStart();
}
+
+ if (mAddOnManager)
+ {
+ mAddOnManager->Start();
+ }
}
// Dali::Internal::Adaptor::Adaptor::Pause
(*iter)->OnPause();
}
+ // Extensions
+ if (mAddOnManager)
+ {
+ mAddOnManager->Pause();
+ }
+
// Pause all windows event handlers when adaptor paused
for( auto window : mWindows )
{
window->Resume();
}
+ // Resume AddOnManager
+ if (mAddOnManager)
+ {
+ mAddOnManager->Resume();
+ }
+
// Inform observers that we have resumed.
for( ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter )
{
(*iter)->OnStop();
}
+ if (mAddOnManager)
+ {
+ mAddOnManager->Stop();
+ }
+
mThreadController->Stop();
// Delete the TTS player
mWindows.front()->FeedTouchPoint( convertedPoint, timeStamp );
}
-void Adaptor::FeedWheelEvent( WheelEvent& wheelEvent )
+void Adaptor::FeedWheelEvent( Dali::WheelEvent& wheelEvent )
{
- Integration::WheelEvent event( static_cast< Integration::WheelEvent::Type >(wheelEvent.type), wheelEvent.direction, wheelEvent.modifiers, wheelEvent.point, wheelEvent.z, wheelEvent.timeStamp );
+ Integration::WheelEvent event( static_cast< Integration::WheelEvent::Type >( wheelEvent.GetType() ), wheelEvent.GetDirection(), wheelEvent.GetModifiers(), wheelEvent.GetPoint(), wheelEvent.GetDelta(), wheelEvent.GetTime() );
mWindows.front()->FeedWheelEvent( event );
}
-void Adaptor::FeedKeyEvent( KeyEvent& keyEvent )
+void Adaptor::FeedKeyEvent( Dali::KeyEvent& keyEvent )
{
- Integration::KeyEvent convertedEvent( keyEvent );
+ Integration::KeyEvent convertedEvent( keyEvent.GetKeyName(), keyEvent.GetLogicalKey(), keyEvent.GetKeyString(), keyEvent.GetKeyCode(), keyEvent.GetKeyModifier(), keyEvent.GetTime(), static_cast< Integration::KeyEvent::State >( keyEvent.GetState() ), keyEvent.GetCompose(), keyEvent.GetDeviceName(), keyEvent.GetDeviceClass(), keyEvent.GetDeviceSubclass() );
mWindows.front()->FeedKeyEvent( convertedEvent );
}
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, bool childWindowMode )
+bool Adaptor::AddWindow( Dali::Integration::SceneHolder 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( &windowImpl );
+ Dali::RenderSurfaceInterface* surface = windowImpl.GetSurface();
+
+ mThreadController->AddSurface( surface );
+
mWindowCreatedSignal.Emit( childWindow );
return true;
GraphicsInterface& Adaptor::GetGraphicsInterface()
{
DALI_ASSERT_DEBUG( mGraphics && "Graphics interface not created" );
- return *mGraphics;
+ return *( mGraphics.get() );
}
Dali::Integration::PlatformAbstraction& Adaptor::GetPlatformAbstractionInterface()
return *mNotificationTrigger;
}
-TriggerEventFactoryInterface& Adaptor::GetTriggerEventFactoryInterface()
-{
- return mTriggerEventFactory;
-}
-
SocketFactoryInterface& Adaptor::GetSocketFactoryInterface()
{
return mSocketFactory;
return *mPlatformAbstraction;
}
+void Adaptor::GetWindowContainerInterface( WindowContainer& windows )
+{
+ windows = mWindows;
+}
+
void Adaptor::DestroyTtsPlayer(Dali::TtsPlayer::Mode mode)
{
if( mTtsPlayers[mode] )
if (mGraphics)
{
- auto eglGraphics = static_cast<EglGraphics *>( mGraphics ); // This interface is temporary until Core has been updated to match
+ GraphicsInterface* graphics = mGraphics.get(); // This interface is temporary until Core has been updated to match
+ auto eglGraphics = static_cast<EglGraphics *>( graphics );
EglImplementation& eglImpl = eglGraphics->GetEglImplementation();
display = eglImpl.GetDisplay();
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;
}
DALI_LOG_RELEASE_INFO( "Adaptor::OnWindowShown: Update requested.\n" );
}
+ else if( PAUSED_WHILE_INITIALIZING == mState )
+ {
+ // Change the state to READY again. It will be changed to RUNNING after the adaptor is started.
+ mState = READY;
+ }
else
{
DALI_LOG_RELEASE_INFO( "Adaptor::OnWindowShown: Adaptor is not paused state.[%d]\n", mState );
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()
void Adaptor::RenderOnce()
{
- RequestUpdateOnce();
+ if( mThreadController )
+ {
+ UpdateMode updateMode;
+ if( mThreadMode == ThreadMode::NORMAL )
+ {
+ updateMode = UpdateMode::NORMAL;
+ }
+ else
+ {
+ updateMode = UpdateMode::FORCE_RENDER;
+
+ ProcessCoreEvents();
+ }
+ mThreadController->RequestUpdateOnce( updateMode );
+ }
}
const LogFactoryInterface& Adaptor::GetLogFactory()
GetCore().UnregisterProcessor(processor);
}
+bool Adaptor::IsMultipleWindowSupported() const
+{
+ return mConfigurationManager->IsMultipleWindowSupported();
+}
+
void Adaptor::RequestUpdateOnce()
{
if( mThreadController )
{
- mThreadController->RequestUpdateOnce();
+ mThreadController->RequestUpdateOnce( UpdateMode::NORMAL );
}
}
return sceneHolderList;
}
+Dali::ObjectRegistry Adaptor::GetObjectRegistry() const
+{
+ Dali::ObjectRegistry registry;
+ if( mCore )
+ {
+ registry = mCore->GetObjectRegistry();
+ }
+ return registry;
+}
+
Adaptor::Adaptor(Dali::Integration::SceneHolder window, Dali::Adaptor& adaptor, Dali::RenderSurfaceInterface* surface, EnvironmentOptions* environmentOptions)
: mResizedSignal(),
mLanguageChangedSignal(),
mGraphics( nullptr ),
mDisplayConnection( nullptr ),
mWindows(),
+ mConfigurationManager( nullptr ),
mPlatformAbstraction( nullptr ),
mCallbackManager( nullptr ),
mNotificationOnIdleInstalled( false ),
mPerformanceInterface( nullptr ),
mKernelTracer(),
mSystemTracer(),
- mTriggerEventFactory(),
mObjectProfiler( nullptr ),
mSocketFactory(),
+ mThreadMode( ThreadMode::NORMAL ),
mEnvironmentOptionsOwned( environmentOptions ? false : true /* If not provided then we own the object */ ),
mUseRemoteSurface( false )
{
void Adaptor::SetRootLayoutDirection( std::string locale )
{
- 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 ) ) ) );
+ for ( auto& window : mWindows )
+ {
+ Dali::Actor root = window->GetRootLayer();
+ root.SetProperty( Dali::Actor::Property::LAYOUT_DIRECTION,
+ static_cast< LayoutDirection::Type >( Internal::Adaptor::Locale::GetDirection( std::string( locale ) ) ) );
+ }
}
bool Adaptor::AddIdleEnterer( CallbackBase* callback, bool forceAdd )
idleAdded = mCallbackManager->AddIdleEntererCallback( callback );
}
+ if( !idleAdded )
+ {
+ // Delete callback
+ delete callback;
+ }
+
return idleAdded;
}
projects / platform / core / uifw / dali-adaptor.git / blobdiff