#define DALI_FILE_STREAM_H
/*
- * 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.
*/
enum FileMode ///< FileType format
{
- BINARY = 0x1, ///< File stream will be opened as a binary
- TEXT = 0x2, ///< File stream will be opened as text
- READ = 0x4, ///< File stream will be opened for reading
- WRITE = 0x8, ///< File stream will be opende for writing
+ BINARY = 1 << 0, ///< File stream will be opened as a binary
+ TEXT = 1 << 1, ///< File stream will be opened as text
+ READ = 1 << 2, ///< File stream will be opened for reading
+ WRITE = 1 << 3, ///< File stream will be opened for writing
+ APPEND = 1 << 4, ///< File stream will be opened for appending
};
/**
return mBufferStream;
}
- std::ios_base::openmode openMode;
- if( mMode & Dali::FileStream::WRITE )
+ int openMode = 0;
+
+ if( mMode & Dali::FileStream::APPEND )
{
- openMode = ( std::ios::out | std::ios::ate );
+ openMode |= ( std::ios::out | std::ios::app );
}
- else
+ else if( mMode & Dali::FileStream::WRITE )
+ {
+ openMode |= ( std::ios::out | std::ios::ate );
+ }
+
+ if( mMode & Dali::FileStream::READ )
{
- openMode = std::ios::in;
+ openMode |= std::ios::in;
}
if( mMode & Dali::FileStream::BINARY )
if( !mFileName.empty() )
{
- mFileStream.open( mFileName, openMode );
+ mFileStream.open( mFileName, static_cast<std::ios_base::openmode>( openMode ) );
if( !mFileStream.is_open() )
{
- DALI_LOG_WARNING( "stream open failed for: \"%s\", in mode: \"%d\".\n", mFileName, static_cast<int>( openMode ) );
+ DALI_LOG_WARNING( "stream open failed for: \"%s\", in mode: \"%d\".\n", mFileName.c_str(), openMode );
}
return mFileStream;
}
if( !mBufferStream.rdbuf()->in_avail() )
{
DALI_LOG_WARNING( "File open failed for memory buffer at location: \"%p\", of size: \"%u\", in mode: \"%d\".\n",
- static_cast<void*>( mBuffer ), static_cast<unsigned>( mDataSize ), static_cast<int>( openMode ) );
+ static_cast<void*>( mBuffer ), static_cast<unsigned>( mDataSize ), openMode );
}
}
char openMode[16] = { 0 };
int i = 0;
- if( mMode & Dali::FileStream::WRITE )
+ if( mMode & Dali::FileStream::APPEND )
+ {
+ openMode[i++] = 'a';
+ }
+ else if( mMode & Dali::FileStream::WRITE )
{
openMode[i++] = 'w';
}
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/integration-api/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/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 )
{
Integration::SetPinchGestureMinimumDistance( mEnvironmentOptions->GetMinimumPinchDistance() );
}
- if( mEnvironmentOptions->GetLongPressMinimumHoldingTime() >= 0 )
+ if( mEnvironmentOptions->GetMinimumPinchTouchEvents() >= 0 )
{
- Integration::SetLongPressMinimumHoldingTime( mEnvironmentOptions->GetLongPressMinimumHoldingTime() );
+ Integration::SetPinchGestureMinimumTouchEvents( mEnvironmentOptions->GetMinimumPinchTouchEvents() );
}
-
- // Set max texture size
- if( mEnvironmentOptions->GetMaxTextureSize() > 0 )
+ if( mEnvironmentOptions->GetMinimumPinchTouchEventsAfterStart() >= 0 )
{
- Dali::TizenPlatform::ImageLoader::SetMaxTextureSize( mEnvironmentOptions->GetMaxTextureSize() );
+ 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() )
+ const int dir_err = system( std::string( "mkdir " + systemCachePath ).c_str() );
+ if (-1 == dir_err)
{
- 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() );
+ printf( "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();
+ 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.
bool Adaptor::IsMultipleWindowSupported() const
{
- auto eglGraphics = static_cast<EglGraphics *>( mGraphics );
- EglImplementation& eglImpl = eglGraphics->GetEglImplementation();
- bool ret = eglImpl.IsSurfacelessContextSupported();
- return ret;
+ return mConfigurationManager->IsMultipleWindowSupported();
}
void Adaptor::RequestUpdateOnce()
mGraphics( nullptr ),
mDisplayConnection( nullptr ),
mWindows(),
+ mConfigurationManager( nullptr ),
mPlatformAbstraction( nullptr ),
mCallbackManager( nullptr ),
mNotificationOnIdleInstalled( false ),
#define DALI_INTERNAL_ADAPTOR_IMPL_H
/*
- * 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 LifeCycleObserver;
class ObjectProfiler;
class SceneHolder;
+class ConfigurationManager;
/**
* Implementation of the Adaptor class.
Dali::DisplayConnection* mDisplayConnection; ///< Display connection
WindowContainer mWindows; ///< A container of all the Windows that are currently created
+ std::unique_ptr<ConfigurationManager> mConfigurationManager; ///< Configuration manager
+
TizenPlatform::TizenPlatformAbstraction* mPlatformAbstraction; ///< Platform abstraction
CallbackManager* mCallbackManager; ///< Used to install callbacks
ObjectProfiler* mObjectProfiler; ///< Tracks object lifetime for profiling
SocketFactory mSocketFactory; ///< Socket factory
const bool mEnvironmentOptionsOwned:1; ///< Whether we own the EnvironmentOptions (and thus, need to delete it)
- bool mUseRemoteSurface; ///< whether the remoteSurface is used or not
+ bool mUseRemoteSurface:1; ///< whether the remoteSurface is used or not
public:
inline static Adaptor& GetImplementation(Dali::Adaptor& adaptor) { return *adaptor.mImpl; }
/*
- * 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.
: mFpsTracker( environmentOptions ),
mUpdateStatusLogger( environmentOptions ),
mEventThreadSemaphore(),
+ mGraphicsInitializeSemaphore(),
mUpdateRenderThreadWaitCondition(),
mAdaptorInterfaces( adaptorInterfaces ),
mPerformanceInterface( adaptorInterfaces.GetPerformanceInterface() ),
TriggerEventFactoryInterface& triggerFactory = mAdaptorInterfaces.GetTriggerEventFactoryInterface();
mSleepTrigger = triggerFactory.CreateTriggerEvent( MakeCallback( this, &CombinedUpdateRenderController::ProcessSleepRequest ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER );
- sem_init( &mEventThreadSemaphore, 0, 0 ); // Initialize to 0 so that it just waits if sem_post has not been called
+ // Initialize to 0 so that it just waits if sem_post has not been called
+ sem_init( &mEventThreadSemaphore, 0, 0 );
+ sem_init( &mGraphicsInitializeSemaphore, 0, 0 );
}
CombinedUpdateRenderController::~CombinedUpdateRenderController()
}
}
+void CombinedUpdateRenderController::WaitForGraphicsInitialization()
+{
+ LOG_EVENT_TRACE;
+
+ if( mUpdateRenderThread )
+ {
+ LOG_EVENT( "Waiting for graphics initialisation, event-thread blocked" );
+
+ // Wait until the graphics has been initialised
+ sem_wait( &mGraphicsInitializeSemaphore );
+
+ LOG_EVENT( "graphics initialised, event-thread continuing" );
+ }
+}
+
void CombinedUpdateRenderController::ResizeSurface()
{
LOG_EVENT_TRACE;
Dali::DisplayConnection& displayConnection = mAdaptorInterfaces.GetDisplayConnectionInterface();
displayConnection.Initialize();
+ // EGL has been initialised at this point
+ NotifyGraphicsInitialised();
+
RenderSurfaceInterface* currentSurface = nullptr;
GraphicsInterface& graphics = mAdaptorInterfaces.GetGraphicsInterface();
sem_post( &mEventThreadSemaphore );
}
+void CombinedUpdateRenderController::NotifyGraphicsInitialised()
+{
+ sem_post( &mGraphicsInitializeSemaphore );
+}
+
void CombinedUpdateRenderController::AddPerformanceMarker( PerformanceInterface::MarkerType type )
{
if( mPerformanceInterface )
#define DALI_INTERNAL_COMBINED_UPDATE_RENDER_CONTROLLER_H
/*
- * 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.
virtual void ResizeSurface();
/**
+ * @copydoc ThreadControllerInterface::WaitForGraphicsInitialization()
+ */
+ virtual void WaitForGraphicsInitialization();
+
+ /**
* @copydoc ThreadControllerInterface::SetRenderRefreshRate()
*/
virtual void SetRenderRefreshRate( unsigned int numberOfFramesPerRender );
void NotifyThreadInitialised();
/**
+ * Called by the update-render thread when graphics has been initialised.
+ */
+ void NotifyGraphicsInitialised();
+
+ /**
* Helper to add a performance marker to the performance server (if it's active)
* @param[in] type performance marker type
*/
UpdateStatusLogger mUpdateStatusLogger; ///< Object that logs the update-status as required.
sem_t mEventThreadSemaphore; ///< Used by the event thread to ensure all threads have been initialised, and when replacing the surface.
+ sem_t mGraphicsInitializeSemaphore; ///< Used by the render thread to ensure the graphics has been initialised.
ConditionalWait mUpdateRenderThreadWaitCondition; ///< The wait condition for the update-render-thread.
#define DALI_INTERNAL_THREAD_CONTROLLER_INTERFACE_H
/*
- * 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.
virtual void ResizeSurface() = 0;
/**
+ * Wait until the graphics is initialised.
+ */
+ virtual void WaitForGraphicsInitialization() = 0;
+
+ /**
* @copydoc Dali::Adaptor::SetRenderRefreshRate()
*/
virtual void SetRenderRefreshRate( unsigned int numberOfVSyncsPerRender ) = 0;
void Adaptor::SetupSystemInformation()
{
- if( system_settings_set_changed_cb( SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE, OnSystemLanguageChanged, this ) != SYSTEM_SETTINGS_ERROR_NONE )
+ if( system_settings_add_changed_cb( SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE, OnSystemLanguageChanged, this ) != SYSTEM_SETTINGS_ERROR_NONE )
{
- DALI_LOG_ERROR( "DALI system_settings_set_changed_cb failed.\n" );
+ DALI_LOG_ERROR( "DALI system_settings_add_changed_cb failed.\n" );
return;
}
}
eglBindAPI(EGL_OPENGL_ES_API);
- mGlesInitialized = true;
mIsOwnSurface = isOwnSurface;
}
}
}
+ mGlesInitialized = true;
+
// We want to display this information all the time, so use the LogMessage directly
Integration::Log::LogMessage(Integration::Log::DebugInfo, "EGL Information\n"
" Vendor: %s\n"
--- /dev/null
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/system/common/configuration-manager.h>
+
+// EXTERNAL INCLUDES
+#include <fstream>
+#include <dali/integration-api/debug.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/file-stream.h>
+#include <dali/internal/graphics/gles/egl-graphics.h>
+#include <dali/internal/system/common/environment-options.h>
+#include <dali/internal/system/common/environment-variables.h>
+#include <dali/internal/system/common/thread-controller.h>
+
+namespace Dali
+{
+
+namespace Internal
+{
+
+namespace Adaptor
+{
+
+namespace
+{
+
+const std::string SYSTEM_CACHE_FILE = "gpu-environment.conf";
+const std::string DALI_ENV_MULTIPLE_WINDOW_SUPPORT = "DALI_ENV_MULTIPLE_WINDOW_SUPPORT";
+
+bool RetrieveKeyFromFile( std::fstream& stream, std::string key, std::string& value )
+{
+ bool keyFound = false;
+
+ 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 name;
+ std::getline(stream, name, ' ');
+ if( name == key )
+ {
+ std::getline(stream, value);
+ keyFound = true;
+ break;
+ }
+ }
+
+ return keyFound;
+}
+
+
+} // unnamed namespace
+
+ConfigurationManager::ConfigurationManager( std::string systemCachePath, EglGraphics* eglGraphics, ThreadController* threadController )
+: mSystemCacheFilePath( systemCachePath + SYSTEM_CACHE_FILE ),
+ mFileStream( new Dali::FileStream( mSystemCacheFilePath, Dali::FileStream::READ | Dali::FileStream::APPEND | Dali::FileStream::TEXT ) ),
+ mEglGraphics( eglGraphics ),
+ mThreadController( threadController ),
+ mMaxTextureSize( 0u ),
+ mIsMultipleWindowSupported( true ),
+ mMaxTextureSizeCached( false ) ,
+ mIsMultipleWindowSupportedCached( false )
+{
+}
+
+ConfigurationManager::~ConfigurationManager()
+{
+}
+
+unsigned int ConfigurationManager::GetMaxTextureSize()
+{
+ if ( !mMaxTextureSizeCached )
+ {
+ std::fstream& configFile = dynamic_cast<std::fstream&>( mFileStream->GetStream() );
+ if( configFile.is_open() )
+ {
+ std::string environmentVariableValue;
+ if( RetrieveKeyFromFile( configFile, DALI_ENV_MAX_TEXTURE_SIZE, environmentVariableValue ) )
+ {
+ mMaxTextureSize = std::atoi( environmentVariableValue.c_str() );
+ }
+ else
+ {
+ GlImplementation& mGLES = mEglGraphics->GetGlesInterface();
+ mMaxTextureSize = mGLES.GetMaxTextureSize();
+
+ configFile.clear();
+ configFile << DALI_ENV_MAX_TEXTURE_SIZE << " " << mMaxTextureSize << std::endl;
+ }
+
+ mMaxTextureSizeCached = true;
+
+ if ( mIsMultipleWindowSupportedCached )
+ {
+ configFile.close();
+ }
+ }
+ else
+ {
+ DALI_LOG_ERROR( "Fail to open file : %s\n", mSystemCacheFilePath.c_str() );
+ }
+ }
+
+ return mMaxTextureSize;
+}
+
+bool ConfigurationManager::IsMultipleWindowSupported()
+{
+ if ( !mIsMultipleWindowSupportedCached )
+ {
+ std::fstream& configFile = dynamic_cast<std::fstream&>( mFileStream->GetStream() );
+ if( configFile.is_open() )
+ {
+ std::string environmentVariableValue;
+ if( RetrieveKeyFromFile( configFile, DALI_ENV_MULTIPLE_WINDOW_SUPPORT, environmentVariableValue ) )
+ {
+ mIsMultipleWindowSupported = std::atoi( environmentVariableValue.c_str() );
+ }
+ else
+ {
+ EglImplementation& eglImpl = mEglGraphics->GetEglImplementation();
+ if ( !eglImpl.IsGlesInitialized() )
+ {
+ // Wait until GLES is initialised, but this will happen once.
+ // This method blocks until the render thread has initialised the graphics.
+ mThreadController->WaitForGraphicsInitialization();
+ }
+
+ // Query from GLES and save the cache
+ mIsMultipleWindowSupported = eglImpl.IsSurfacelessContextSupported();
+
+ configFile.clear();
+ configFile << DALI_ENV_MULTIPLE_WINDOW_SUPPORT << " " << mIsMultipleWindowSupported << std::endl;
+ }
+
+ mIsMultipleWindowSupportedCached = true;
+
+ if ( mMaxTextureSizeCached )
+ {
+ configFile.close();
+ }
+ }
+ else
+ {
+ DALI_LOG_ERROR( "Fail to open file : %s\n", mSystemCacheFilePath.c_str() );
+ }
+ }
+
+ return mIsMultipleWindowSupported;
+}
+
+} // Adaptor
+
+} // Internal
+
+} // Dali
--- /dev/null
+#ifndef DALI_INTERNAL_ENVIRONMENT_CONFIGURATION_MANAGER_H
+#define DALI_INTERNAL_ENVIRONMENT_CONFIGURATION_MANAGER_H
+
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <memory>
+#include <string>
+
+namespace Dali
+{
+
+class FileStream;
+
+namespace Internal
+{
+namespace Adaptor
+{
+
+class EglGraphics;
+class ThreadController;
+
+/**
+ * This class retrieves and caches the system configuration.
+ *
+ */
+class ConfigurationManager
+{
+public:
+
+ /**
+ * @brief Constructor
+ */
+ ConfigurationManager( std::string systemCachePath, EglGraphics* eglGraphics, ThreadController* threadController );
+
+ /**
+ * @brief Virtual Destructor for interface cleanup
+ */
+ virtual ~ConfigurationManager();
+
+ /**
+ * @brief Get the maximum texture size.
+ * @return The maximum texture size
+ */
+ unsigned int GetMaxTextureSize();
+
+ /**
+ * @brief Check whether multiple window is supported
+ * @return Whether multiple window is supported
+ */
+ bool IsMultipleWindowSupported();
+
+ // Deleted copy constructor.
+ ConfigurationManager( const ConfigurationManager& ) = delete;
+
+ // Deleted move constructor.
+ ConfigurationManager( const ConfigurationManager&& ) = delete;
+
+ // Deleted assignment operator.
+ ConfigurationManager& operator=( const ConfigurationManager& ) = delete;
+
+ // Deleted move assignment operator.
+ ConfigurationManager& operator=( const ConfigurationManager&& ) = delete;
+
+private: // Data
+
+ std::string mSystemCacheFilePath; ///< The path of system cache file
+ std::unique_ptr<FileStream> mFileStream; ///< The file stream to access the system cache
+ EglGraphics* mEglGraphics; ///< EGL graphics
+ ThreadController* mThreadController; ///< The thread controller
+ unsigned int mMaxTextureSize; ///< The largest texture that the GL can handle
+ bool mIsMultipleWindowSupported:1; ///< Whether multiple window is supported by the GLES
+ bool mMaxTextureSizeCached:1; ///< Whether we have checked the maximum texture size
+ bool mIsMultipleWindowSupportedCached:1; ///< Whether we have checked the support of multiple window
+};
+
+} // Adaptor
+} // Internal
+} // Dali
+
+#endif // DALI_INTERNAL_ENVIRONMENT_CONFIGURATION_MANAGER_H
mPanMinimumDistance( -1 ),
mPanMinimumEvents( -1 ),
mPinchMinimumDistance( -1.0f ),
+ mPinchMinimumTouchEvents( -1 ),
+ mPinchMinimumTouchEventsAfterStart( -1 ),
+ mRotationMinimumTouchEvents( -1 ),
+ mRotationMinimumTouchEventsAfterStart( -1 ),
mLongPressMinimumHoldingTime( -1 ),
mGlesCallTime( 0 ),
mMultiSamplingLevel( DEFAULT_MULTI_SAMPLING_LEVEL ),
return mPinchMinimumDistance;
}
+int EnvironmentOptions::GetMinimumPinchTouchEvents() const
+{
+ return mPinchMinimumTouchEvents;
+}
+
+int EnvironmentOptions::GetMinimumPinchTouchEventsAfterStart() const
+{
+ return mPinchMinimumTouchEventsAfterStart;
+}
+
+int EnvironmentOptions::GetMinimumRotationTouchEvents() const
+{
+ return mRotationMinimumTouchEvents;
+}
+
+int EnvironmentOptions::GetMinimumRotationTouchEventsAfterStart() const
+{
+ return mRotationMinimumTouchEventsAfterStart;
+}
+
int EnvironmentOptions::GetLongPressMinimumHoldingTime() const
{
return mLongPressMinimumHoldingTime;
mPinchMinimumDistance = pinchMinimumDistance;
}
+ int pinchMinimumTouchEvents = -1;
+ if( GetIntegerEnvironmentVariable( DALI_ENV_PINCH_MINIMUM_TOUCH_EVENTS, pinchMinimumTouchEvents ) )
+ {
+ mPinchMinimumTouchEvents = pinchMinimumTouchEvents;
+ }
+
+ int pinchMinimumTouchEventsAfterStart = -1;
+ if( GetIntegerEnvironmentVariable( DALI_ENV_PINCH_MINIMUM_TOUCH_EVENTS_AFTER_START, pinchMinimumTouchEventsAfterStart ) )
+ {
+ mPinchMinimumTouchEventsAfterStart = pinchMinimumTouchEventsAfterStart;
+ }
+
+ int rotationMinimumTouchEvents = -1;
+ if( GetIntegerEnvironmentVariable( DALI_ENV_ROTATION_MINIMUM_TOUCH_EVENTS, rotationMinimumTouchEvents ) )
+ {
+ mRotationMinimumTouchEvents = rotationMinimumTouchEvents;
+ }
+
+ int rotationMinimumTouchEventsAfterStart = -1;
+ if( GetIntegerEnvironmentVariable( DALI_ENV_ROTATION_MINIMUM_TOUCH_EVENTS_AFTER_START, rotationMinimumTouchEventsAfterStart ) )
+ {
+ mRotationMinimumTouchEventsAfterStart = rotationMinimumTouchEventsAfterStart;
+ }
+
int longPressMinimumHoldingTime = -1;
if( GetIntegerEnvironmentVariable( DALI_ENV_LONG_PRESS_MINIMUM_HOLDING_TIME, longPressMinimumHoldingTime ) )
{
float GetMinimumPinchDistance() const;
/**
+ * @return The minimum touch events required before a pinch can be started (-1 means it's not set)
+ */
+ int GetMinimumPinchTouchEvents() const;
+
+ /**
+ * @return The minimum touch events required after a pinch started (-1 means it's not set)
+ */
+ int GetMinimumPinchTouchEventsAfterStart() const;
+
+ /**
+ * @return The minimum touch events required before a rotation can be started (-1 means it's not set)
+ */
+ int GetMinimumRotationTouchEvents() const;
+
+ /**
+ * @return The minimum touch events required after a rotation started (-1 means it's not set)
+ */
+ int GetMinimumRotationTouchEventsAfterStart() const;
+
+ /**
* @return The minimum holding time required to be recognized as a long press gesture (milliseconds)
*/
int GetLongPressMinimumHoldingTime() const;
int mPanMinimumDistance; ///< minimum distance required before pan starts
int mPanMinimumEvents; ///< minimum events required before pan starts
float mPinchMinimumDistance; ///< minimum number of pixels moved before a pinch starts
+ int mPinchMinimumTouchEvents; ///< minimum events required before a pinch starts
+ int mPinchMinimumTouchEventsAfterStart; ///< minimum events required after a pinch started
+ int mRotationMinimumTouchEvents; ///< minimum events required before a rotation starts
+ int mRotationMinimumTouchEventsAfterStart; ///< minimum events required after a rotation started
int mLongPressMinimumHoldingTime; ///< minimum holding time required to be recognized as a long press gesture (millisecond)
int mGlesCallTime; ///< time in seconds between status updates
int mMultiSamplingLevel; ///< The number of samples required in multisample buffers
#define DALI_ENV_PAN_MINIMUM_DISTANCE "DALI_PAN_MINIMUM_DISTANCE"
#define DALI_ENV_PAN_MINIMUM_EVENTS "DALI_PAN_MINIMUM_EVENTS"
-#define DALI_ENV_PINCH_MINIMUM_DISTANCE "DALI_PINCH_MINIMUM_DISTANCE"
+// Pinch-Gesture
+#define DALI_ENV_PINCH_MINIMUM_DISTANCE "DALI_PINCH_MINIMUM_DISTANCE"
+#define DALI_ENV_PINCH_MINIMUM_TOUCH_EVENTS "DALI_PINCH_MINIMUM_TOUCH_EVENTS"
+#define DALI_ENV_PINCH_MINIMUM_TOUCH_EVENTS_AFTER_START "DALI_PINCH_MINIMUM_TOUCH_EVENTS_AFTER_START"
+
+// Rotation-Gesture
+#define DALI_ENV_ROTATION_MINIMUM_TOUCH_EVENTS "DALI_ROTATION_MINIMUM_TOUCH_EVENTS"
+#define DALI_ENV_ROTATION_MINIMUM_TOUCH_EVENTS_AFTER_START "DALI_ROTATION_MINIMUM_TOUCH_EVENTS_AFTER_START"
/**
* The minimum holding time required to be recognized as a long press gesture (milliseconds)
/*
- * Copyright (c) 2018 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.
mThreadControllerInterface->ResizeSurface();
}
+void ThreadController::WaitForGraphicsInitialization()
+{
+ mThreadControllerInterface->WaitForGraphicsInitialization();
+}
+
void ThreadController::SetRenderRefreshRate(unsigned int numberOfVSyncsPerRender )
{
mThreadControllerInterface->SetRenderRefreshRate( numberOfVSyncsPerRender );
#define DALI_INTERNAL_THREAD_CONTROLLER_H
/*
- * 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.
void ResizeSurface();
/**
+ * Wait until the graphics is initialised.
+ */
+ void WaitForGraphicsInitialization();
+
+ /**
* @copydoc Dali::Adaptor::SetRenderRefreshRate()
*/
void SetRenderRefreshRate( unsigned int numberOfVSyncsPerRender );
${adaptor_system_dir}/common/abort-handler.cpp
${adaptor_system_dir}/common/color-controller-impl.cpp
${adaptor_system_dir}/common/command-line-options.cpp
+ ${adaptor_system_dir}/common/configuration-manager.cpp
${adaptor_system_dir}/common/environment-options.cpp
${adaptor_system_dir}/common/fps-tracker.cpp
${adaptor_system_dir}/common/frame-time-stamp.cpp
mCameraActor.Unparent();
mCameraActor.Reset();
- DALI_ASSERT_ALWAYS(mRenderTask && "RenderTask is NULL.");
+ DALI_ASSERT_ALWAYS( mRenderTask && "RenderTask is NULL." );
Dali::RenderTaskList taskList = Dali::Stage::GetCurrent().GetRenderTaskList();
- Dali::RenderTask firstTask = taskList.GetTask( 0u );
-
- // Stop rendering via frame-buffers as empty handle is used to clear target
- firstTask.SetFrameBuffer( Dali::FrameBuffer() );
-
taskList.RemoveTask( mRenderTask );
mRenderTask.Reset();
}
const unsigned int ADAPTOR_MAJOR_VERSION = 1;
const unsigned int ADAPTOR_MINOR_VERSION = 4;
-const unsigned int ADAPTOR_MICRO_VERSION = 55;
+const unsigned int ADAPTOR_MICRO_VERSION = 57;
const char * const ADAPTOR_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
Name: dali-adaptor
Summary: The DALi Tizen Adaptor
-Version: 1.4.55
+Version: 1.4.57
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT
projects / platform / core / uifw / dali-adaptor.git / commitdiff