X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=adaptors%2Fcommon%2Fadaptor-impl.cpp;h=ff2479b0618251090c4d608b725b0a6ad1873e75;hb=28be57905493bfc096554ee75fc90fd53f27f31c;hp=c3dede88b2e8e44c2dbfa5b4ee862d705f844e7a;hpb=ead73b3116bb2a42386cdeb9ff421b9a37f32ec5;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git diff --git a/adaptors/common/adaptor-impl.cpp b/adaptors/common/adaptor-impl.cpp index c3dede8..ff2479b 100644 --- a/adaptors/common/adaptor-impl.cpp +++ b/adaptors/common/adaptor-impl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015 Samsung Electronics Co., Ltd. + * Copyright (c) 2017 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. @@ -20,6 +20,9 @@ // EXTERNAL INCLUDES #include +#include +#include +#include #include #include #include @@ -28,21 +31,18 @@ #include // INTERNAL INCLUDES -#include +#include #include #include #include #include -#include #include #include -#include +#include #include #include -#include -#include #include #include #include @@ -53,8 +53,12 @@ #include #include #include +#include #include +#include + +#include using Dali::TextAbstraction::FontClient; @@ -69,13 +73,13 @@ namespace Adaptor namespace { -__thread Adaptor* gThreadLocalAdaptor = NULL; // raw thread specific pointer to allow Adaptor::Get +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 ) +Dali::Adaptor* Adaptor::New( Any nativeWindow, RenderSurface *surface, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions ) { Dali::Adaptor* adaptor = new Dali::Adaptor; - Adaptor* impl = new Adaptor( nativeWindow, *adaptor, surface ); + Adaptor* impl = new Adaptor( nativeWindow, *adaptor, surface, environmentOptions ); adaptor->mImpl = impl; impl->Initialize(configuration); @@ -83,13 +87,22 @@ Dali::Adaptor* Adaptor::New( Any nativeWindow, RenderSurface *surface, Dali::Con return adaptor; } +Dali::Adaptor* Adaptor::New( Dali::Window 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); + return adaptor; +} void Adaptor::Initialize( 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 ); - mEnvironmentOptions.SetLogFunction( logFunction ); - mEnvironmentOptions.InstallLogFunction(); // install logging for main thread + mEnvironmentOptions->SetLogFunction( logFunction ); + mEnvironmentOptions->InstallLogFunction(); // install logging for main thread mPlatformAbstraction = new TizenPlatform::TizenPlatformAbstraction; @@ -100,84 +113,133 @@ void Adaptor::Initialize( Dali::Configuration::ContextLoss configuration ) ResourcePolicy::DataRetention dataRetentionPolicy = ResourcePolicy::DALI_DISCARDS_ALL_DATA; if( configuration == Dali::Configuration::APPLICATION_DOES_NOT_HANDLE_CONTEXT_LOSS ) { - dataRetentionPolicy = ResourcePolicy::DALI_RETAINS_MESH_DATA; + 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() ) + if( mEnvironmentOptions->PerformanceServerRequired() ) { - mPerformanceInterface = PerformanceInterfaceFactory::CreateInterface( *this, mEnvironmentOptions ); + mPerformanceInterface = PerformanceInterfaceFactory::CreateInterface( *this, *mEnvironmentOptions ); } mCallbackManager = CallbackManager::New(); PositionSize size = mSurface->GetPositionSize(); - mGestureManager = new GestureManager(*this, Vector2(size.width, size.height), mCallbackManager, mEnvironmentOptions); + mGestureManager = new GestureManager(*this, Vector2(size.width, size.height), mCallbackManager, *mEnvironmentOptions); - if( mEnvironmentOptions.GetGlesCallTime() > 0 ) + if( mEnvironmentOptions->GetGlesCallTime() > 0 ) { - mGLES = new GlProxyImplementation( mEnvironmentOptions ); + mGLES = new GlProxyImplementation( *mEnvironmentOptions ); } else { mGLES = new GlImplementation(); } - mEglFactory = new EglFactory(); + const Integration::DepthBufferAvailable depthBufferAvailable = static_cast< Integration::DepthBufferAvailable >( mEnvironmentOptions->DepthBufferRequired() ); + const Integration::StencilBufferAvailable stencilBufferAvailable = static_cast< Integration::StencilBufferAvailable >( mEnvironmentOptions->StencilBufferRequired() ); + + mEglFactory = new EglFactory( mEnvironmentOptions->GetMultiSamplingLevel(), depthBufferAvailable, stencilBufferAvailable ); EglSyncImplementation* eglSyncImpl = mEglFactory->GetSyncImplementation(); - mCore = Integration::Core::New( *this, *mPlatformAbstraction, *mGLES, *eglSyncImpl, *mGestureManager, dataRetentionPolicy ); + mCore = Integration::Core::New( *this, + *mPlatformAbstraction, + *mGLES, + *eglSyncImpl, + *mGestureManager, + dataRetentionPolicy , + ( 0u != mEnvironmentOptions->GetRenderToFboInterval() ) ? Integration::RenderToFrameBuffer::TRUE : Integration::RenderToFrameBuffer::FALSE, + depthBufferAvailable, + stencilBufferAvailable ); - mObjectProfiler = new ObjectProfiler(); + const unsigned int timeInterval = mEnvironmentOptions->GetObjectProfilerInterval(); + if( 0u < timeInterval ) + { + mObjectProfiler = new ObjectProfiler( timeInterval ); + } - mNotificationTrigger = new TriggerEvent( MakeCallback( this, &Adaptor::ProcessCoreEvents ) ); + mNotificationTrigger = mTriggerEventFactory.CreateTriggerEvent( MakeCallback( this, &Adaptor::ProcessCoreEvents ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER); mVSyncMonitor = new VSyncMonitor; - mUpdateRenderController = new UpdateRenderController( *this, mEnvironmentOptions ); - - mDaliFeedbackPlugin = new FeedbackPluginProxy( FeedbackPluginProxy::DEFAULT_OBJECT_NAME ); + mThreadController = new ThreadController( *this, *mEnvironmentOptions ); // Should be called after Core creation - if( mEnvironmentOptions.GetPanGestureLoggingLevel() ) + if( mEnvironmentOptions->GetPanGestureLoggingLevel() ) { Integration::EnableProfiling( Dali::Integration::PROFILING_TYPE_PAN_GESTURE ); } - if( mEnvironmentOptions.GetPanGesturePredictionMode() >= 0 ) + if( mEnvironmentOptions->GetPanGesturePredictionMode() >= 0 ) + { + Integration::SetPanGesturePredictionMode(mEnvironmentOptions->GetPanGesturePredictionMode()); + } + if( mEnvironmentOptions->GetPanGesturePredictionAmount() >= 0 ) + { + Integration::SetPanGesturePredictionAmount(mEnvironmentOptions->GetPanGesturePredictionAmount()); + } + if( mEnvironmentOptions->GetPanGestureMaximumPredictionAmount() >= 0 ) + { + Integration::SetPanGestureMaximumPredictionAmount(mEnvironmentOptions->GetPanGestureMaximumPredictionAmount()); + } + if( mEnvironmentOptions->GetPanGestureMinimumPredictionAmount() >= 0 ) { - Integration::SetPanGesturePredictionMode(mEnvironmentOptions.GetPanGesturePredictionMode()); + Integration::SetPanGestureMinimumPredictionAmount(mEnvironmentOptions->GetPanGestureMinimumPredictionAmount()); } - if( mEnvironmentOptions.GetPanGesturePredictionAmount() >= 0 ) + if( mEnvironmentOptions->GetPanGesturePredictionAmountAdjustment() >= 0 ) { - Integration::SetPanGesturePredictionAmount(mEnvironmentOptions.GetPanGesturePredictionAmount()); + Integration::SetPanGesturePredictionAmountAdjustment(mEnvironmentOptions->GetPanGesturePredictionAmountAdjustment()); } - if( mEnvironmentOptions.GetPanGestureMaximumPredictionAmount() >= 0 ) + if( mEnvironmentOptions->GetPanGestureSmoothingMode() >= 0 ) { - Integration::SetPanGestureMaximumPredictionAmount(mEnvironmentOptions.GetPanGestureMaximumPredictionAmount()); + Integration::SetPanGestureSmoothingMode(mEnvironmentOptions->GetPanGestureSmoothingMode()); } - if( mEnvironmentOptions.GetPanGestureMinimumPredictionAmount() >= 0 ) + if( mEnvironmentOptions->GetPanGestureSmoothingAmount() >= 0.0f ) { - Integration::SetPanGestureMinimumPredictionAmount(mEnvironmentOptions.GetPanGestureMinimumPredictionAmount()); + Integration::SetPanGestureSmoothingAmount(mEnvironmentOptions->GetPanGestureSmoothingAmount()); } - if( mEnvironmentOptions.GetPanGesturePredictionAmountAdjustment() >= 0 ) + if( mEnvironmentOptions->GetPanGestureUseActualTimes() >= 0 ) { - Integration::SetPanGesturePredictionAmountAdjustment(mEnvironmentOptions.GetPanGesturePredictionAmountAdjustment()); + Integration::SetPanGestureUseActualTimes( mEnvironmentOptions->GetPanGestureUseActualTimes() == 0 ? true : false ); } - if( mEnvironmentOptions.GetPanGestureSmoothingMode() >= 0 ) + if( mEnvironmentOptions->GetPanGestureInterpolationTimeRange() >= 0 ) { - Integration::SetPanGestureSmoothingMode(mEnvironmentOptions.GetPanGestureSmoothingMode()); + Integration::SetPanGestureInterpolationTimeRange( mEnvironmentOptions->GetPanGestureInterpolationTimeRange() ); } - if( mEnvironmentOptions.GetPanGestureSmoothingAmount() >= 0.0f ) + if( mEnvironmentOptions->GetPanGestureScalarOnlyPredictionEnabled() >= 0 ) { - Integration::SetPanGestureSmoothingAmount(mEnvironmentOptions.GetPanGestureSmoothingAmount()); + Integration::SetPanGestureScalarOnlyPredictionEnabled( mEnvironmentOptions->GetPanGestureScalarOnlyPredictionEnabled() == 0 ? true : false ); } - if( mEnvironmentOptions.GetWindowWidth() && mEnvironmentOptions.GetWindowHeight() ) + if( mEnvironmentOptions->GetPanGestureTwoPointPredictionEnabled() >= 0 ) { - SurfaceResized( PositionSize( 0, 0, mEnvironmentOptions.GetWindowWidth(), mEnvironmentOptions.GetWindowHeight() )); + Integration::SetPanGestureTwoPointPredictionEnabled( mEnvironmentOptions->GetPanGestureTwoPointPredictionEnabled() == 0 ? true : false ); } + if( mEnvironmentOptions->GetPanGestureTwoPointInterpolatePastTime() >= 0 ) + { + Integration::SetPanGestureTwoPointInterpolatePastTime( mEnvironmentOptions->GetPanGestureTwoPointInterpolatePastTime() ); + } + if( mEnvironmentOptions->GetPanGestureTwoPointVelocityBias() >= 0.0f ) + { + Integration::SetPanGestureTwoPointVelocityBias( mEnvironmentOptions->GetPanGestureTwoPointVelocityBias() ); + } + if( mEnvironmentOptions->GetPanGestureTwoPointAccelerationBias() >= 0.0f ) + { + Integration::SetPanGestureTwoPointAccelerationBias( mEnvironmentOptions->GetPanGestureTwoPointAccelerationBias() ); + } + if( mEnvironmentOptions->GetPanGestureMultitapSmoothingRange() >= 0 ) + { + Integration::SetPanGestureMultitapSmoothingRange( mEnvironmentOptions->GetPanGestureMultitapSmoothingRange() ); + } + + // Set max texture size + if( mEnvironmentOptions->GetMaxTextureSize() > 0 ) + { + Dali::SetMaxTextureSize( mEnvironmentOptions->GetMaxTextureSize() ); + } + + SetupSystemInformation(); } Adaptor::~Adaptor() @@ -193,16 +255,13 @@ Adaptor::~Adaptor() (*iter)->OnDestroy(); } - delete mUpdateRenderController; // this will shutdown render thread, which will call Core::ContextDestroyed before exit + 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 feedback controller before feedback plugin & style monitor dependencies - delete mFeedbackController; - delete mDaliFeedbackPlugin; delete mGLES; delete mGestureManager; delete mPlatformAbstraction; @@ -211,6 +270,12 @@ Adaptor::~Adaptor() // uninstall it on this thread (main actor thread) Dali::Integration::Log::UninstallLogFunction(); + + // Delete environment options if we own it + if( mEnvironmentOptionsOwned ) + { + delete mEnvironmentOptions; + } } void Adaptor::Start() @@ -249,19 +314,11 @@ void Adaptor::Start() PositionSize size = mSurface->GetPositionSize(); mCore->SurfaceResized( size.width, size.height ); - // Start the update & render threads - mUpdateRenderController->Start(); - - mState = RUNNING; + // Initialize the thread controller + mThreadController->Initialize(); ProcessCoreEvents(); // Ensure any startup messages are processed. - if ( !mFeedbackController ) - { - // Start sound & haptic feedback - mFeedbackController = new FeedbackController( *mDaliFeedbackPlugin ); - } - for ( ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter ) { (*iter)->OnStart(); @@ -283,12 +340,14 @@ void Adaptor::Pause() // Reset the event handler when adaptor paused if( mEventHandler ) { - mEventHandler->Reset(); + mEventHandler->Pause(); } - mUpdateRenderController->Pause(); - mCore->Suspend(); + mThreadController->Pause(); mState = PAUSED; + + // Ensure any messages queued during pause callbacks are processed by doing another update. + RequestUpdateOnce(); } } @@ -298,24 +357,12 @@ void Adaptor::Resume() // Only resume the adaptor if we are in the suspended state. if( PAUSED == mState ) { - // We put ResumeFrameTime first, as this was originally called at the start of mCore->Resume() - // If there were events pending, mCore->Resume() will call - // RenderController->RequestUpdate() - // UpdateRenderController->RequestUpdate() - // UpdateRenderSynchronization->RequestUpdate() - // and we should have reset the frame timers before allowing Core->Update() to be called. - //@todo Should we call UpdateRenderController->Resume before mCore->Resume()? - - mUpdateRenderController->ResumeFrameTime(); - mCore->Resume(); - mUpdateRenderController->Resume(); - mState = RUNNING; // Reset the event handler when adaptor resumed if( mEventHandler ) { - mEventHandler->Reset(); + mEventHandler->Resume(); } // Inform observers that we have resumed. @@ -324,7 +371,11 @@ void Adaptor::Resume() (*iter)->OnResume(); } - ProcessCoreEvents(); // Ensure any outstanding messages are processed + // 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(); } } @@ -339,8 +390,7 @@ void Adaptor::Stop() (*iter)->OnStop(); } - mUpdateRenderController->Stop(); - mCore->Suspend(); + mThreadController->Stop(); // Delete the TTS player for(int i =0; i < Dali::TtsPlayer::MODE_NUM; i++) @@ -363,12 +413,25 @@ void Adaptor::Stop() } } +void Adaptor::ContextLost() +{ + mCore->GetContextNotifier()->NotifyContextLost(); // Inform stage +} + +void Adaptor::ContextRegained() +{ + // Inform core, so that texture resources can be reloaded + mCore->RecoverFromContextLoss(); + + mCore->GetContextNotifier()->NotifyContextRegained(); // Inform stage +} + void Adaptor::FeedTouchPoint( TouchPoint& point, int timeStamp ) { mEventHandler->FeedTouchPoint( point, timeStamp ); } -void Adaptor::FeedWheelEvent( MouseWheelEvent& wheelEvent ) +void Adaptor::FeedWheelEvent( WheelEvent& wheelEvent ) { mEventHandler->FeedWheelEvent( wheelEvent ); } @@ -378,59 +441,24 @@ void Adaptor::FeedKeyEvent( KeyEvent& keyEvent ) mEventHandler->FeedKeyEvent( keyEvent ); } -bool Adaptor::MoveResize( const PositionSize& positionSize ) -{ - PositionSize old = mSurface->GetPositionSize(); - - // just resize the surface. The driver should automatically resize the egl Surface (untested) - // EGL Spec says : EGL window surfaces need to be resized when their corresponding native window - // is resized. Implementations typically use hooks into the OS and native window - // system to perform this resizing on demand, transparently to the client. - mSurface->MoveResize( positionSize ); - - if(old.width != positionSize.width || old.height != positionSize.height) - { - SurfaceSizeChanged(positionSize); - } - - return true; -} - -void Adaptor::SurfaceResized( const PositionSize& positionSize ) +void Adaptor::ReplaceSurface( Any nativeWindow, RenderSurface& surface ) { - PositionSize old = mSurface->GetPositionSize(); + PositionSize positionSize = surface.GetPositionSize(); - // Called by an application, when it has resized a window outside of Dali. - // The EGL driver automatically detects X Window resize calls, and resizes - // the EGL surface for us. - mSurface->MoveResize( positionSize ); + // let the core know the surface size has changed + mCore->SurfaceResized( positionSize.width, positionSize.height ); - if(old.width != positionSize.width || old.height != positionSize.height) - { - SurfaceSizeChanged(positionSize); - } -} + mResizedSignal.Emit( mAdaptor ); -void Adaptor::ReplaceSurface( Any nativeWindow, RenderSurface& surface ) -{ mNativeWindow = nativeWindow; mSurface = &surface; - SurfaceSizeChanged(mSurface->GetPositionSize()); - - // flush the event queue to give update and render threads 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(); - mCore->GetContextNotifier()->NotifyContextLost(); // Inform stage - // this method blocks until the render thread has completed the replace. - mUpdateRenderController->ReplaceSurface(mSurface); - - // Inform core, so that texture resources can be reloaded - mCore->RecoverFromContextLoss(); - - mCore->GetContextNotifier()->NotifyContextRegained(); // Inform stage + mThreadController->ReplaceSurface(mSurface); } RenderSurface& Adaptor::GetSurface() const @@ -454,30 +482,22 @@ Dali::TtsPlayer Adaptor::GetTtsPlayer(Dali::TtsPlayer::Mode mode) return mTtsPlayers[mode]; } -bool Adaptor::AddIdle( CallbackBase* callback ) +bool Adaptor::AddIdle( CallbackBase* callback, bool forceAdd ) { bool idleAdded(false); // Only add an idle if the Adaptor is actually running - if( RUNNING == mState ) + if( RUNNING == mState || READY == mState || forceAdd ) { - idleAdded = mCallbackManager->AddCallback( callback, CallbackManager::IDLE_PRIORITY ); + idleAdded = mCallbackManager->AddIdleCallback( callback ); } return idleAdded; } -bool Adaptor::CallFromMainLoop( CallbackBase* callback ) +void Adaptor::RemoveIdle( CallbackBase* callback ) { - bool callAdded(false); - - // Only allow the callback if the Adaptor is actually running - if ( RUNNING == mState ) - { - callAdded = mCallbackManager->AddCallback( callback, CallbackManager::DEFAULT_PRIORITY ); - } - - return callAdded; + mCallbackManager->RemoveIdleCallback( callback ); } Dali::Adaptor& Adaptor::Get() @@ -491,6 +511,11 @@ bool Adaptor::IsAvailable() return gThreadLocalAdaptor != NULL; } +void Adaptor::SceneCreated() +{ + mCore->SceneCreated(); +} + Dali::Integration::Core& Adaptor::GetCore() { return *mCore; @@ -498,7 +523,7 @@ Dali::Integration::Core& Adaptor::GetCore() void Adaptor::SetRenderRefreshRate( unsigned int numberOfVSyncsPerRender ) { - mUpdateRenderController->SetRenderRefreshRate( numberOfVSyncsPerRender ); + mThreadController->SetRenderRefreshRate( numberOfVSyncsPerRender ); } void Adaptor::SetUseHardwareVSync( bool useHardware ) @@ -533,7 +558,7 @@ Dali::Integration::GlAbstraction& Adaptor::GetGlesInterface() return *mGLES; } -TriggerEventInterface& Adaptor::GetTriggerEventInterface() +TriggerEventInterface& Adaptor::GetProcessCoreEventsTrigger() { return *mNotificationTrigger; } @@ -623,6 +648,11 @@ Any Adaptor::GetNativeWindowHandle() return mNativeWindow; } +void Adaptor::SetUseRemoteSurface(bool useRemoteSurface) +{ + mUseRemoteSurface = useRemoteSurface; +} + void Adaptor::AddObserver( LifeCycleObserver& observer ) { ObserverContainer::iterator match ( find(mObservers.begin(), mObservers.end(), &observer) ); @@ -669,24 +699,41 @@ void Adaptor::ProcessCoreEvents() } } -void Adaptor::RequestUpdate() +void Adaptor::RequestUpdate( bool forceUpdate ) { - // When Dali applications are partially visible behind the lock-screen, - // the indicator must be updated (therefore allow updates in the PAUSED state) - if ( PAUSED == mState || - RUNNING == mState ) + switch( mState ) { - mUpdateRenderController->RequestUpdate(); + case RUNNING: + { + mThreadController->RequestUpdate(); + break; + } + 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(); + } + break; + } + default: + { + // Do nothing + break; + } } } -void Adaptor::RequestProcessEventsOnIdle() +void Adaptor::RequestProcessEventsOnIdle( bool forceProcess ) { // Only request a notification if the Adaptor is actually running // and we haven't installed the idle notification - if( ( ! mNotificationOnIdleInstalled ) && ( RUNNING == mState ) ) + if( ( ! mNotificationOnIdleInstalled ) && ( RUNNING == mState || READY == mState || forceProcess ) ) { - mNotificationOnIdleInstalled = AddIdle( MakeCallback( this, &Adaptor::ProcessCoreEventsFromIdle ) ); + mNotificationOnIdleInstalled = AddIdle( MakeCallback( this, &Adaptor::ProcessCoreEventsFromIdle ), forceProcess ); } } @@ -706,7 +753,7 @@ void Adaptor::OnWindowShown() void Adaptor::OnWindowHidden() { - if ( STOPPED != mState ) + if ( RUNNING == mState ) { Pause(); @@ -719,33 +766,64 @@ void Adaptor::OnWindowHidden() void Adaptor::OnDamaged( const DamageArea& area ) { // This is needed for the case where Dali window is partially obscured - RequestUpdate(); + RequestUpdate( false ); } -void Adaptor::SurfaceSizeChanged(const PositionSize& positionSize) +void Adaptor::SurfaceResizePrepare( SurfaceSize surfaceSize ) { // let the core know the surface size has changed - mCore->SurfaceResized(positionSize.width, positionSize.height); + mCore->SurfaceResized( surfaceSize.GetWidth(), surfaceSize.GetHeight() ); mResizedSignal.Emit( mAdaptor ); } +void Adaptor::SurfaceResizeComplete( SurfaceSize surfaceSize ) +{ + // flush the event queue to give the update-render thread chance + // to start processing messages for new camera setup etc as soon as possible + ProcessCoreEvents(); + + // this method blocks until the render thread has completed the resizing. + mThreadController->ResizeSurface(); +} + +void Adaptor::NotifySceneCreated() +{ + GetCore().SceneCreated(); + + // Start thread controller after the scene has been created + mThreadController->Start(); + + // process after surface is created (registering to remote surface provider if required) + SurfaceInitialized(); + + mState = RUNNING; +} + void Adaptor::NotifyLanguageChanged() { mLanguageChangedSignal.Emit( mAdaptor ); } +void Adaptor::RenderOnce() +{ + RequestUpdateOnce(); +} + void Adaptor::RequestUpdateOnce() { - if( PAUSED_WHILE_HIDDEN != mState ) + if( mThreadController ) { - if( mUpdateRenderController ) - { - mUpdateRenderController->RequestUpdateOnce(); - } + mThreadController->RequestUpdateOnce(); } } +void Adaptor::IndicatorSizeChanged(int height) +{ + // let the core know the indicator height is changed + mCore->SetTopMargin(height); +} + void Adaptor::ProcessCoreEventsFromIdle() { ProcessCoreEvents(); @@ -754,15 +832,16 @@ void Adaptor::ProcessCoreEventsFromIdle() mNotificationOnIdleInstalled = false; } -Adaptor::Adaptor(Any nativeWindow, Dali::Adaptor& adaptor, RenderSurface* surface) +Adaptor::Adaptor(Any nativeWindow, Dali::Adaptor& adaptor, RenderSurface* surface, EnvironmentOptions* environmentOptions) : mResizedSignal(), mLanguageChangedSignal(), - mAdaptor(adaptor), - mState(READY), - mCore(NULL), - mUpdateRenderController(NULL), - mVSyncMonitor(NULL), + mAdaptor( adaptor ), + mState( READY ), + mCore( NULL ), + mThreadController( NULL ), + mVSyncMonitor( NULL ), mGLES( NULL ), + mGlSync( NULL ), mEglFactory( NULL ), mNativeWindow( nativeWindow ), mSurface( surface ), @@ -770,16 +849,23 @@ Adaptor::Adaptor(Any nativeWindow, Dali::Adaptor& adaptor, RenderSurface* surfac mEventHandler( NULL ), mCallbackManager( NULL ), mNotificationOnIdleInstalled( false ), - mNotificationTrigger(NULL), - mGestureManager(NULL), - mDaliFeedbackPlugin(NULL), - mFeedbackController(NULL), + mNotificationTrigger( NULL ), + mGestureManager( NULL ), + mDaliFeedbackPlugin(), + mFeedbackController( NULL ), + mTtsPlayers(), mObservers(), mDragAndDropDetector(), - mDeferredRotationObserver(NULL), - mEnvironmentOptions(), - mPerformanceInterface(NULL), - mObjectProfiler(NULL) + mDeferredRotationObserver( NULL ), + mEnvironmentOptions( environmentOptions ? environmentOptions : new EnvironmentOptions /* Create the options if not provided */), + mPerformanceInterface( NULL ), + mKernelTracer(), + mSystemTracer(), + mTriggerEventFactory(), + mObjectProfiler( NULL ), + 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; @@ -808,6 +894,14 @@ float Adaptor::GetStereoBase() const return mCore->GetStereoBase(); } +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 ) ) ) ); +} + } // namespace Adaptor } // namespace Internal