adaptors/common/adaptor-impl.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include "adaptor-impl.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <boost/thread/tss.hpp>
  23 #include <dali/public-api/common/dali-common.h>
  24 #include <dali/integration-api/debug.h>
  25 #include <dali/integration-api/core.h>
  26 #include <dali/integration-api/context-notifier.h>
  27 #include <dali/integration-api/profiling.h>
  28 #include <dali/integration-api/input-options.h>
  29 #include <dali/integration-api/events/touch-event-integ.h>
  30
  31 // INTERNAL INCLUDES
  32 #include <base/update-render-controller.h>
  33 #include <base/environment-variables.h>
  34 #include <base/performance-logging/performance-interface-factory.h>
  35 #include <base/lifecycle-observer.h>
  36
  37 #include <dali/public-api/text-abstraction/font-client.h>
  38
  39 #include <callback-manager.h>
  40 #include <trigger-event.h>
  41 #include <render-surface.h>
  42 #include <tts-player-impl.h>
  43 #include <accessibility-manager-impl.h>
  44 #include <timer-impl.h>
  45 #include <events/gesture-manager.h>
  46 #include <events/event-handler.h>
  47 #include <feedback/feedback-controller.h>
  48 #include <feedback/feedback-plugin-proxy.h>
  49 #include <gl/gl-proxy-implementation.h>
  50 #include <gl/gl-implementation.h>
  51 #include <gl/egl-sync-implementation.h>
  52 #include <gl/egl-image-extensions.h>
  53 #include <gl/egl-factory.h>
  54 #include <imf-manager-impl.h>
  55 #include <clipboard-impl.h>
  56 #include <vsync-monitor.h>
  57 #include <object-profiler.h>
  58 #include <base/display-connection.h>
  59
  60 #include <tizen-logging.h>
  61
  62 using Dali::TextAbstraction::FontClient;
  63
  64 namespace Dali
  65 {
  66
  67 namespace Internal
  68 {
  69
  70 namespace Adaptor
  71 {
  72
  73 namespace
  74 {
  75 boost::thread_specific_ptr<Adaptor> gThreadLocalAdaptor;
  76
  77 unsigned int GetIntegerEnvironmentVariable( const char* variable, unsigned int defaultValue )
  78 {
  79   const char* variableParameter = std::getenv(variable);
  80
  81   // if the parameter exists convert it to an integer, else return the default value
  82   unsigned int intValue = variableParameter ? atoi(variableParameter) : defaultValue;
  83   return intValue;
  84 }
  85
  86 bool GetIntegerEnvironmentVariable( const char* variable, int& intValue )
  87 {
  88   const char* variableParameter = std::getenv(variable);
  89
  90   if( !variableParameter )
  91   {
  92     return false;
  93   }
  94   // if the parameter exists convert it to an integer, else return the default value
  95   intValue = atoi(variableParameter);
  96   return true;
  97 }
  98
  99 bool GetFloatEnvironmentVariable( const char* variable, float& floatValue )
 100 {
 101   const char* variableParameter = std::getenv(variable);
 102
 103   if( !variableParameter )
 104   {
 105     return false;
 106   }
 107   // if the parameter exists convert it to an integer, else return the default value
 108   floatValue = atof(variableParameter);
 109   return true;
 110 }
 111
 112 } // unnamed namespace
 113
 114 Dali::Adaptor* Adaptor::New( Any nativeWindow, RenderSurface *surface, const DeviceLayout& baseLayout,
 115                              Dali::Configuration::ContextLoss configuration )
 116 {
 117   Dali::Adaptor* adaptor = new Dali::Adaptor;
 118   Adaptor* impl = new Adaptor( nativeWindow, *adaptor, surface, baseLayout );
 119   adaptor->mImpl = impl;
 120
 121   impl->Initialize(configuration);
 122
 123   return adaptor;
 124 }
 125
 126 void Adaptor::ParseEnvironmentOptions()
 127 {
 128   // get logging options
 129   unsigned int logFrameRateFrequency = GetIntegerEnvironmentVariable( DALI_ENV_FPS_TRACKING, 0 );
 130   unsigned int logupdateStatusFrequency = GetIntegerEnvironmentVariable( DALI_ENV_UPDATE_STATUS_INTERVAL, 0 );
 131   unsigned int logPerformanceStats = GetIntegerEnvironmentVariable( DALI_ENV_LOG_PERFORMANCE_STATS, 0 );
 132   unsigned int logPerformanceStatsFrequency = GetIntegerEnvironmentVariable( DALI_ENV_LOG_PERFORMANCE_STATS_FREQUENCY, 0 );
 133   unsigned int performanceTimeStampOutput= GetIntegerEnvironmentVariable( DALI_ENV_PERFORMANCE_TIMESTAMP_OUTPUT, 0 );
 134   unsigned int networkControl= GetIntegerEnvironmentVariable( DALI_ENV_NETWORK_CONTROL, 0 );
 135
 136   unsigned int logPanGesture = GetIntegerEnvironmentVariable( DALI_ENV_LOG_PAN_GESTURE, 0 );
 137
 138   // all threads here (event, update, and render) will send their logs to TIZEN Platform's LogMessage handler.
 139   Dali::Integration::Log::LogFunction  logFunction(Dali::TizenPlatform::LogMessage);
 140
 141   mEnvironmentOptions.SetLogOptions( logFunction, networkControl, logFrameRateFrequency, logupdateStatusFrequency, logPerformanceStats, logPerformanceStatsFrequency, performanceTimeStampOutput, logPanGesture );
 142
 143   int predictionMode;
 144   if( GetIntegerEnvironmentVariable(DALI_ENV_PAN_PREDICTION_MODE, predictionMode) )
 145   {
 146     mEnvironmentOptions.SetPanGesturePredictionMode(predictionMode);
 147   }
 148   int predictionAmount(-1);
 149   if( GetIntegerEnvironmentVariable(DALI_ENV_PAN_PREDICTION_AMOUNT, predictionAmount) )
 150   {
 151     if( predictionAmount < 0 )
 152     {
 153       // do not support times in the past
 154       predictionAmount = 0;
 155     }
 156     mEnvironmentOptions.SetPanGesturePredictionAmount(predictionAmount);
 157   }
 158   int minPredictionAmount(-1);
 159   if( GetIntegerEnvironmentVariable(DALI_ENV_PAN_MIN_PREDICTION_AMOUNT, minPredictionAmount) )
 160   {
 161     if( minPredictionAmount < 0 )
 162     {
 163       // do not support times in the past
 164       minPredictionAmount = 0;
 165     }
 166     mEnvironmentOptions.SetPanGestureMinimumPredictionAmount(minPredictionAmount);
 167   }
 168   int maxPredictionAmount(-1);
 169   if( GetIntegerEnvironmentVariable(DALI_ENV_PAN_MAX_PREDICTION_AMOUNT, maxPredictionAmount) )
 170   {
 171     if( minPredictionAmount > -1 && maxPredictionAmount < minPredictionAmount )
 172     {
 173       // maximum amount should not be smaller than minimum amount
 174       maxPredictionAmount = minPredictionAmount;
 175     }
 176     mEnvironmentOptions.SetPanGestureMaximumPredictionAmount(maxPredictionAmount);
 177   }
 178   int predictionAmountAdjustment(-1);
 179   if( GetIntegerEnvironmentVariable(DALI_ENV_PAN_PREDICTION_AMOUNT_ADJUSTMENT, predictionAmountAdjustment) )
 180   {
 181     if( predictionAmountAdjustment < 0 )
 182     {
 183       // negative amount doesn't make sense
 184       predictionAmountAdjustment = 0;
 185     }
 186     mEnvironmentOptions.SetPanGesturePredictionAmountAdjustment(predictionAmountAdjustment);
 187   }
 188   int smoothingMode;
 189   if( GetIntegerEnvironmentVariable(DALI_ENV_PAN_SMOOTHING_MODE, smoothingMode) )
 190   {
 191     mEnvironmentOptions.SetPanGestureSmoothingMode(smoothingMode);
 192   }
 193   float smoothingAmount = 1.0f;
 194   if( GetFloatEnvironmentVariable(DALI_ENV_PAN_SMOOTHING_AMOUNT, smoothingAmount) )
 195   {
 196     smoothingAmount = Clamp(smoothingAmount, 0.0f, 1.0f);
 197     mEnvironmentOptions.SetPanGestureSmoothingAmount(smoothingAmount);
 198   }
 199
 200   int minimumDistance(-1);
 201   if ( GetIntegerEnvironmentVariable(DALI_ENV_PAN_MINIMUM_DISTANCE, minimumDistance ))
 202   {
 203     mEnvironmentOptions.SetMinimumPanDistance( minimumDistance );
 204   }
 205
 206   int minimumEvents(-1);
 207   if ( GetIntegerEnvironmentVariable(DALI_ENV_PAN_MINIMUM_EVENTS, minimumEvents ))
 208   {
 209     mEnvironmentOptions.SetMinimumPanEvents( minimumEvents );
 210   }
 211
 212   int glesCallTime(0);
 213   if ( GetIntegerEnvironmentVariable(DALI_GLES_CALL_TIME, glesCallTime ))
 214   {
 215     mEnvironmentOptions.SetGlesCallTime( glesCallTime );
 216   }
 217
 218   int windowWidth(0), windowHeight(0);
 219   if ( GetIntegerEnvironmentVariable( DALI_WINDOW_WIDTH, windowWidth ) && GetIntegerEnvironmentVariable( DALI_WINDOW_HEIGHT, windowHeight ) )
 220   {
 221     mEnvironmentOptions.SetWindowWidth( windowWidth );
 222     mEnvironmentOptions.SetWindowHeight( windowHeight );
 223   }
 224
 225   mEnvironmentOptions.InstallLogFunction();
 226 }
 227
 228 void Adaptor::Initialize(Dali::Configuration::ContextLoss configuration)
 229 {
 230   ParseEnvironmentOptions();
 231
 232   mPlatformAbstraction = new TizenPlatform::TizenPlatformAbstraction;
 233
 234   std::string path;
 235   GetDataStoragePath( path );
 236   mPlatformAbstraction->SetDataStoragePath( path );
 237
 238   ResourcePolicy::DataRetention dataRetentionPolicy = ResourcePolicy::DALI_DISCARDS_ALL_DATA;
 239   if( configuration == Dali::Configuration::APPLICATION_DOES_NOT_HANDLE_CONTEXT_LOSS )
 240   {
 241     dataRetentionPolicy = ResourcePolicy::DALI_RETAINS_MESH_DATA;
 242   }
 243   // Note, Tizen does not use DALI_RETAINS_ALL_DATA, as it can reload images from
 244   // files automatically.
 245
 246   if( mEnvironmentOptions.PerformanceServerRequired() )
 247   {
 248     mPerformanceInterface = PerformanceInterfaceFactory::CreateInterface( *this, mEnvironmentOptions );
 249   }
 250
 251   mCallbackManager = CallbackManager::New();
 252
 253   PositionSize size = mSurface->GetPositionSize();
 254
 255   mGestureManager = new GestureManager(*this, Vector2(size.width, size.height), mCallbackManager, mEnvironmentOptions);
 256
 257   if( mEnvironmentOptions.GetGlesCallTime() > 0 )
 258   {
 259     mGLES = new GlProxyImplementation( mEnvironmentOptions );
 260   }
 261   else
 262   {
 263     mGLES = new GlImplementation();
 264   }
 265
 266   mEglFactory = new EglFactory();
 267
 268   EglSyncImplementation* eglSyncImpl = mEglFactory->GetSyncImplementation();
 269
 270   mCore = Integration::Core::New( *this, *mPlatformAbstraction, *mGLES, *eglSyncImpl, *mGestureManager, dataRetentionPolicy );
 271
 272   mObjectProfiler = new ObjectProfiler();
 273
 274   mNotificationTrigger = new TriggerEvent( MakeCallback( this, &Adaptor::ProcessCoreEvents ) );
 275
 276   mVSyncMonitor = new VSyncMonitor;
 277
 278   mUpdateRenderController = new UpdateRenderController( *this, mEnvironmentOptions );
 279
 280   mDaliFeedbackPlugin = new FeedbackPluginProxy( FeedbackPluginProxy::DEFAULT_OBJECT_NAME );
 281
 282   // Should be called after Core creation
 283   if( mEnvironmentOptions.GetPanGestureLoggingLevel() )
 284   {
 285     Integration::EnableProfiling( Dali::Integration::PROFILING_TYPE_PAN_GESTURE );
 286   }
 287   if( mEnvironmentOptions.GetPanGesturePredictionMode() >= 0 )
 288   {
 289     Integration::SetPanGesturePredictionMode(mEnvironmentOptions.GetPanGesturePredictionMode());
 290   }
 291   if( mEnvironmentOptions.GetPanGesturePredictionAmount() >= 0 )
 292   {
 293     Integration::SetPanGesturePredictionAmount(mEnvironmentOptions.GetPanGesturePredictionAmount());
 294   }
 295   if( mEnvironmentOptions.GetPanGestureMaximumPredictionAmount() >= 0 )
 296   {
 297     Integration::SetPanGestureMaximumPredictionAmount(mEnvironmentOptions.GetPanGestureMaximumPredictionAmount());
 298   }
 299   if( mEnvironmentOptions.GetPanGestureMinimumPredictionAmount() >= 0 )
 300   {
 301     Integration::SetPanGestureMinimumPredictionAmount(mEnvironmentOptions.GetPanGestureMinimumPredictionAmount());
 302   }
 303   if( mEnvironmentOptions.GetPanGesturePredictionAmountAdjustment() >= 0 )
 304   {
 305     Integration::SetPanGesturePredictionAmountAdjustment(mEnvironmentOptions.GetPanGesturePredictionAmountAdjustment());
 306   }
 307   if( mEnvironmentOptions.GetPanGestureSmoothingMode() >= 0 )
 308   {
 309     Integration::SetPanGestureSmoothingMode(mEnvironmentOptions.GetPanGestureSmoothingMode());
 310   }
 311   if( mEnvironmentOptions.GetPanGestureSmoothingAmount() >= 0.0f )
 312   {
 313     Integration::SetPanGestureSmoothingAmount(mEnvironmentOptions.GetPanGestureSmoothingAmount());
 314   }
 315   if( mEnvironmentOptions.GetWindowWidth() && mEnvironmentOptions.GetWindowHeight() )
 316   {
 317     SurfaceResized( PositionSize( 0, 0, mEnvironmentOptions.GetWindowWidth(), mEnvironmentOptions.GetWindowHeight() ));
 318   }
 319 }
 320
 321 Adaptor::~Adaptor()
 322 {
 323   // Ensure stop status
 324   Stop();
 325
 326   // Release first as we do not want any access to Adaptor as it is being destroyed.
 327   gThreadLocalAdaptor.release();
 328
 329   for ( ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter )
 330   {
 331     (*iter)->OnDestroy();
 332   }
 333
 334   delete mUpdateRenderController; // this will shutdown render thread, which will call Core::ContextDestroyed before exit
 335   delete mVSyncMonitor;
 336   delete mEventHandler;
 337   delete mObjectProfiler;
 338
 339   delete mCore;
 340   delete mEglFactory;
 341   // Delete feedback controller before feedback plugin & style monitor dependencies
 342   delete mFeedbackController;
 343   delete mDaliFeedbackPlugin;
 344   delete mGLES;
 345   delete mGestureManager;
 346   delete mPlatformAbstraction;
 347   delete mCallbackManager;
 348   delete mPerformanceInterface;
 349
 350   // uninstall it on this thread (main actor thread)
 351   Dali::Integration::Log::UninstallLogFunction();
 352 }
 353
 354 void Adaptor::Start()
 355 {
 356   // it doesn't support restart after stop at this moment
 357   // to support restarting, need more testing
 358   if( READY != mState )
 359   {
 360     return;
 361   }
 362
 363   // Start the callback manager
 364   mCallbackManager->Start();
 365
 366   // create event handler
 367   mEventHandler = new EventHandler( mSurface, *this, *mGestureManager, *this, mDragAndDropDetector );
 368
 369   if( mDeferredRotationObserver != NULL )
 370   {
 371     mEventHandler->SetRotationObserver(mDeferredRotationObserver);
 372     mDeferredRotationObserver = NULL;
 373   }
 374
 375   unsigned int dpiHor, dpiVer;
 376   dpiHor = dpiVer = 0;
 377   Dali::DisplayConnection::GetDpi(dpiHor, dpiVer);
 378
 379   // tell core about the DPI value
 380   mCore->SetDpi(dpiHor, dpiVer);
 381
 382   // set the DPI value for font rendering
 383   FontClient fontClient = FontClient::Get();
 384   fontClient.SetDpi( dpiHor, dpiVer );
 385
 386   // Tell the core the size of the surface just before we start the render-thread
 387   PositionSize size = mSurface->GetPositionSize();
 388   mCore->SurfaceResized( size.width, size.height );
 389
 390   // Start the update & render threads
 391   mUpdateRenderController->Start();
 392
 393   mState = RUNNING;
 394
 395   ProcessCoreEvents(); // Ensure any startup messages are processed.
 396
 397   if ( !mFeedbackController )
 398   {
 399     // Start sound & haptic feedback
 400     mFeedbackController = new FeedbackController( *mDaliFeedbackPlugin );
 401   }
 402
 403   for ( ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter )
 404   {
 405     (*iter)->OnStart();
 406   }
 407 }
 408
 409 // Dali::Internal::Adaptor::Adaptor::Pause
 410 void Adaptor::Pause()
 411 {
 412   // Only pause the adaptor if we're actually running.
 413   if( RUNNING == mState )
 414   {
 415     // Inform observers that we are about to be paused.
 416     for( ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter )
 417     {
 418       (*iter)->OnPause();
 419     }
 420
 421     // Reset the event handler when adaptor paused
 422     if( mEventHandler )
 423     {
 424       mEventHandler->Reset();
 425     }
 426
 427     mUpdateRenderController->Pause();
 428     mCore->Suspend();
 429     mState = PAUSED;
 430   }
 431 }
 432
 433 // Dali::Internal::Adaptor::Adaptor::Resume
 434 void Adaptor::Resume()
 435 {
 436   // Only resume the adaptor if we are in the suspended state.
 437   if( PAUSED == mState )
 438   {
 439     // We put ResumeFrameTime first, as this was originally called at the start of mCore->Resume()
 440     // If there were events pending, mCore->Resume() will call
 441     //   RenderController->RequestUpdate()
 442     //     UpdateRenderController->RequestUpdate()
 443     //       UpdateRenderSynchronization->RequestUpdate()
 444     // and we should have reset the frame timers before allowing Core->Update() to be called.
 445     //@todo Should we call UpdateRenderController->Resume before mCore->Resume()?
 446
 447     mUpdateRenderController->ResumeFrameTime();
 448     mCore->Resume();
 449     mUpdateRenderController->Resume();
 450
 451     mState = RUNNING;
 452
 453     // Reset the event handler when adaptor resumed
 454     if( mEventHandler )
 455     {
 456       mEventHandler->Reset();
 457     }
 458
 459     // Inform observers that we have resumed.
 460     for( ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter )
 461     {
 462       (*iter)->OnResume();
 463     }
 464
 465     ProcessCoreEvents(); // Ensure any outstanding messages are processed
 466   }
 467 }
 468
 469 void Adaptor::Stop()
 470 {
 471   if( RUNNING == mState ||
 472       PAUSED  == mState ||
 473       PAUSED_WHILE_HIDDEN == mState )
 474   {
 475     for( ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter )
 476     {
 477       (*iter)->OnStop();
 478     }
 479
 480     mUpdateRenderController->Stop();
 481     mCore->Suspend();
 482
 483     // Delete the TTS player
 484     for(int i =0; i < Dali::TtsPlayer::MODE_NUM; i++)
 485     {
 486       if(mTtsPlayers[i])
 487       {
 488         mTtsPlayers[i].Reset();
 489       }
 490     }
 491
 492     delete mEventHandler;
 493     mEventHandler = NULL;
 494
 495     delete mNotificationTrigger;
 496     mNotificationTrigger = NULL;
 497
 498     mCallbackManager->Stop();
 499
 500     mState = STOPPED;
 501   }
 502 }
 503
 504 void Adaptor::FeedTouchPoint( TouchPoint& point, int timeStamp )
 505 {
 506   mEventHandler->FeedTouchPoint( point, timeStamp );
 507 }
 508
 509 void Adaptor::FeedWheelEvent( MouseWheelEvent& wheelEvent )
 510 {
 511   mEventHandler->FeedWheelEvent( wheelEvent );
 512 }
 513
 514 void Adaptor::FeedKeyEvent( KeyEvent& keyEvent )
 515 {
 516   mEventHandler->FeedKeyEvent( keyEvent );
 517 }
 518
 519 bool Adaptor::MoveResize( const PositionSize& positionSize )
 520 {
 521   PositionSize old = mSurface->GetPositionSize();
 522
 523   // just resize the surface. The driver should automatically resize the egl Surface (untested)
 524   // EGL Spec says : EGL window surfaces need to be resized when their corresponding native window
 525   // is resized. Implementations typically use hooks into the OS and native window
 526   // system to perform this resizing on demand, transparently to the client.
 527   mSurface->MoveResize( positionSize );
 528
 529   if(old.width != positionSize.width || old.height != positionSize.height)
 530   {
 531     SurfaceSizeChanged(positionSize);
 532   }
 533
 534   return true;
 535 }
 536
 537 void Adaptor::SurfaceResized( const PositionSize& positionSize )
 538 {
 539   PositionSize old = mSurface->GetPositionSize();
 540
 541   // Called by an application, when it has resized a window outside of Dali.
 542   // The EGL driver automatically detects X Window resize calls, and resizes
 543   // the EGL surface for us.
 544   mSurface->MoveResize( positionSize );
 545
 546   if(old.width != positionSize.width || old.height != positionSize.height)
 547   {
 548     SurfaceSizeChanged(positionSize);
 549   }
 550 }
 551
 552 void Adaptor::ReplaceSurface( Any nativeWindow, RenderSurface& surface )
 553 {
 554   mNativeWindow = nativeWindow;
 555   mSurface = &surface;
 556
 557   SurfaceSizeChanged(mSurface->GetPositionSize());
 558
 559   // flush the event queue to give update and render threads chance
 560   // to start processing messages for new camera setup etc as soon as possible
 561   ProcessCoreEvents();
 562
 563   mCore->GetContextNotifier()->NotifyContextLost(); // Inform stage
 564
 565   // this method blocks until the render thread has completed the replace.
 566   mUpdateRenderController->ReplaceSurface(mSurface);
 567
 568   // Inform core, so that texture resources can be reloaded
 569   mCore->RecoverFromContextLoss();
 570
 571   mCore->GetContextNotifier()->NotifyContextRegained(); // Inform stage
 572 }
 573
 574 RenderSurface& Adaptor::GetSurface() const
 575 {
 576   return *mSurface;
 577 }
 578
 579 void Adaptor::ReleaseSurfaceLock()
 580 {
 581   mSurface->ReleaseLock();
 582 }
 583
 584 Dali::TtsPlayer Adaptor::GetTtsPlayer(Dali::TtsPlayer::Mode mode)
 585 {
 586   if(!mTtsPlayers[mode])
 587   {
 588     // Create the TTS player when it needed, because it can reduce launching time.
 589     mTtsPlayers[mode] = TtsPlayer::New(mode);
 590   }
 591
 592   return mTtsPlayers[mode];
 593 }
 594
 595 bool Adaptor::AddIdle( CallbackBase* callback )
 596 {
 597   bool idleAdded(false);
 598
 599   // Only add an idle if the Adaptor is actually running
 600   if( RUNNING == mState )
 601   {
 602     idleAdded = mCallbackManager->AddCallback( callback, CallbackManager::IDLE_PRIORITY );
 603   }
 604
 605   return idleAdded;
 606 }
 607
 608 bool Adaptor::CallFromMainLoop( CallbackBase* callback )
 609 {
 610   bool callAdded(false);
 611
 612   // Only allow the callback if the Adaptor is actually running
 613   if ( RUNNING == mState )
 614   {
 615     callAdded = mCallbackManager->AddCallback( callback, CallbackManager::DEFAULT_PRIORITY );
 616   }
 617
 618   return callAdded;
 619 }
 620
 621 Dali::Adaptor& Adaptor::Get()
 622 {
 623   DALI_ASSERT_ALWAYS( gThreadLocalAdaptor.get() != NULL && "Adaptor not instantiated" );
 624   return gThreadLocalAdaptor->mAdaptor;
 625 }
 626
 627 bool Adaptor::IsAvailable()
 628 {
 629   return gThreadLocalAdaptor.get() != NULL;
 630 }
 631
 632 Dali::Integration::Core& Adaptor::GetCore()
 633 {
 634   return *mCore;
 635 }
 636
 637 void Adaptor::SetRenderRefreshRate( unsigned int numberOfVSyncsPerRender )
 638 {
 639   mUpdateRenderController->SetRenderRefreshRate( numberOfVSyncsPerRender );
 640 }
 641
 642 void Adaptor::SetUseHardwareVSync( bool useHardware )
 643 {
 644   mVSyncMonitor->SetUseHardwareVSync( useHardware );
 645 }
 646
 647 EglFactory& Adaptor::GetEGLFactory() const
 648 {
 649   DALI_ASSERT_DEBUG( mEglFactory && "EGL Factory not created" );
 650   return *mEglFactory;
 651 }
 652
 653 EglFactoryInterface& Adaptor::GetEGLFactoryInterface() const
 654 {
 655   return *mEglFactory;
 656 }
 657
 658 Integration::GlAbstraction& Adaptor::GetGlAbstraction() const
 659 {
 660   DALI_ASSERT_DEBUG( mGLES && "GLImplementation not created" );
 661   return *mGLES;
 662 }
 663
 664 Dali::Integration::PlatformAbstraction& Adaptor::GetPlatformAbstractionInterface()
 665 {
 666   return *mPlatformAbstraction;
 667 }
 668
 669 Dali::Integration::GlAbstraction& Adaptor::GetGlesInterface()
 670 {
 671   return *mGLES;
 672 }
 673
 674 TriggerEventInterface& Adaptor::GetTriggerEventInterface()
 675 {
 676   return *mNotificationTrigger;
 677 }
 678
 679 TriggerEventFactoryInterface& Adaptor::GetTriggerEventFactoryInterface()
 680 {
 681   return mTriggerEventFactory;
 682 }
 683
 684 SocketFactoryInterface& Adaptor::GetSocketFactoryInterface()
 685 {
 686   return mSocketFactory;
 687 }
 688
 689 RenderSurface* Adaptor::GetRenderSurfaceInterface()
 690 {
 691   return mSurface;
 692 }
 693
 694 VSyncMonitorInterface* Adaptor::GetVSyncMonitorInterface()
 695 {
 696   return mVSyncMonitor;
 697 }
 698
 699 KernelTraceInterface& Adaptor::GetKernelTraceInterface()
 700 {
 701   return mKernelTracer;
 702 }
 703
 704 PerformanceInterface* Adaptor::GetPerformanceInterface()
 705 {
 706   return mPerformanceInterface;
 707 }
 708
 709 Integration::PlatformAbstraction& Adaptor::GetPlatformAbstraction() const
 710 {
 711   DALI_ASSERT_DEBUG( mPlatformAbstraction && "PlatformAbstraction not created" );
 712   return *mPlatformAbstraction;
 713 }
 714
 715 void Adaptor::SetDragAndDropDetector( DragAndDropDetectorPtr detector )
 716 {
 717   mDragAndDropDetector = detector;
 718
 719   if ( mEventHandler )
 720   {
 721     mEventHandler->SetDragAndDropDetector( detector );
 722   }
 723 }
 724
 725 void Adaptor::SetRotationObserver( RotationObserver* observer )
 726 {
 727   if( mEventHandler )
 728   {
 729     mEventHandler->SetRotationObserver( observer );
 730   }
 731   else if( mState == READY )
 732   {
 733     // Set once event handler exists
 734     mDeferredRotationObserver = observer;
 735   }
 736 }
 737
 738 void Adaptor::DestroyTtsPlayer(Dali::TtsPlayer::Mode mode)
 739 {
 740   if(mTtsPlayers[mode])
 741   {
 742     mTtsPlayers[mode].Reset();
 743   }
 744 }
 745
 746 void Adaptor::SetMinimumPinchDistance(float distance)
 747 {
 748   if( mGestureManager )
 749   {
 750     mGestureManager->SetMinimumPinchDistance(distance);
 751   }
 752 }
 753
 754 Any Adaptor::GetNativeWindowHandle()
 755 {
 756   return mNativeWindow;
 757 }
 758
 759 void Adaptor::AddObserver( LifeCycleObserver& observer )
 760 {
 761   ObserverContainer::iterator match ( find(mObservers.begin(), mObservers.end(), &observer) );
 762
 763   if ( match == mObservers.end() )
 764   {
 765     mObservers.push_back( &observer );
 766   }
 767 }
 768
 769 void Adaptor::RemoveObserver( LifeCycleObserver& observer )
 770 {
 771   ObserverContainer::iterator match ( find(mObservers.begin(), mObservers.end(), &observer) );
 772
 773   if ( match != mObservers.end() )
 774   {
 775     mObservers.erase( match );
 776   }
 777 }
 778
 779 void Adaptor::QueueCoreEvent(const Dali::Integration::Event& event)
 780 {
 781   if( mCore )
 782   {
 783     mCore->QueueEvent(event);
 784   }
 785 }
 786
 787 void Adaptor::ProcessCoreEvents()
 788 {
 789   if( mCore )
 790   {
 791     if( mPerformanceInterface )
 792     {
 793       mPerformanceInterface->AddMarker( PerformanceInterface::PROCESS_EVENTS_START );
 794     }
 795
 796     mCore->ProcessEvents();
 797
 798     if( mPerformanceInterface )
 799     {
 800       mPerformanceInterface->AddMarker( PerformanceInterface::PROCESS_EVENTS_END );
 801     }
 802   }
 803 }
 804
 805 void Adaptor::RequestUpdate()
 806 {
 807   // When Dali applications are partially visible behind the lock-screen,
 808   // the indicator must be updated (therefore allow updates in the PAUSED state)
 809   if ( PAUSED  == mState ||
 810        RUNNING == mState )
 811   {
 812     mUpdateRenderController->RequestUpdate();
 813   }
 814 }
 815
 816 void Adaptor::RequestProcessEventsOnIdle()
 817 {
 818   // Only request a notification if the Adaptor is actually running
 819   // and we haven't installed the idle notification
 820   if( ( ! mNotificationOnIdleInstalled ) && ( RUNNING == mState ) )
 821   {
 822     mNotificationOnIdleInstalled = AddIdle( MakeCallback( this, &Adaptor::ProcessCoreEventsFromIdle ) );
 823   }
 824 }
 825
 826 void Adaptor::OnWindowShown()
 827 {
 828   if ( PAUSED_WHILE_HIDDEN == mState )
 829   {
 830     // Adaptor can now be resumed
 831     mState = PAUSED;
 832
 833     Resume();
 834
 835     // Force a render task
 836     RequestUpdateOnce();
 837   }
 838 }
 839
 840 void Adaptor::OnWindowHidden()
 841 {
 842   if ( STOPPED != mState )
 843   {
 844     Pause();
 845
 846     // Adaptor cannot be resumed until the window is shown
 847     mState = PAUSED_WHILE_HIDDEN;
 848   }
 849 }
 850
 851 // Dali::Internal::Adaptor::Adaptor::OnDamaged
 852 void Adaptor::OnDamaged( const DamageArea& area )
 853 {
 854   // This is needed for the case where Dali window is partially obscured
 855   RequestUpdate();
 856 }
 857
 858 void Adaptor::SurfaceSizeChanged(const PositionSize& positionSize)
 859 {
 860   // let the core know the surface size has changed
 861   mCore->SurfaceResized(positionSize.width, positionSize.height);
 862
 863   mResizedSignal.Emit( mAdaptor );
 864 }
 865
 866 void Adaptor::NotifyLanguageChanged()
 867 {
 868   mLanguageChangedSignal.Emit( mAdaptor );
 869 }
 870
 871 void Adaptor::RequestUpdateOnce()
 872 {
 873   if( PAUSED_WHILE_HIDDEN != mState )
 874   {
 875     if( mUpdateRenderController )
 876     {
 877       mUpdateRenderController->RequestUpdateOnce();
 878     }
 879   }
 880 }
 881
 882 void Adaptor::ProcessCoreEventsFromIdle()
 883 {
 884   ProcessCoreEvents();
 885
 886   // the idle handle automatically un-installs itself
 887   mNotificationOnIdleInstalled = false;
 888 }
 889
 890 Adaptor::Adaptor(Any nativeWindow, Dali::Adaptor& adaptor, RenderSurface* surface, const DeviceLayout& baseLayout)
 891 : mResizedSignal(),
 892   mLanguageChangedSignal(),
 893   mAdaptor(adaptor),
 894   mState(READY),
 895   mCore(NULL),
 896   mUpdateRenderController(NULL),
 897   mVSyncMonitor(NULL),
 898   mGLES( NULL ),
 899   mEglFactory( NULL ),
 900   mNativeWindow( nativeWindow ),
 901   mSurface( surface ),
 902   mPlatformAbstraction( NULL ),
 903   mEventHandler( NULL ),
 904   mCallbackManager( NULL ),
 905   mNotificationOnIdleInstalled( false ),
 906   mNotificationTrigger(NULL),
 907   mGestureManager(NULL),
 908   mDaliFeedbackPlugin(NULL),
 909   mFeedbackController(NULL),
 910   mObservers(),
 911   mDragAndDropDetector(),
 912   mDeferredRotationObserver(NULL),
 913   mBaseLayout(baseLayout),
 914   mEnvironmentOptions(),
 915   mPerformanceInterface(NULL),
 916   mObjectProfiler(NULL)
 917 {
 918   DALI_ASSERT_ALWAYS( gThreadLocalAdaptor.get() == NULL && "Cannot create more than one Adaptor per thread" );
 919   gThreadLocalAdaptor.reset(this);
 920 }
 921
 922 // Stereoscopy
 923
 924 void Adaptor::SetViewMode( ViewMode viewMode )
 925 {
 926   mSurface->SetViewMode( viewMode );
 927   mCore->SetViewMode( viewMode );
 928 }
 929
 930 ViewMode Adaptor::GetViewMode() const
 931 {
 932   return mCore->GetViewMode();
 933 }
 934
 935 void Adaptor::SetStereoBase( float stereoBase )
 936 {
 937   mCore->SetStereoBase( stereoBase );
 938 }
 939
 940 float Adaptor::GetStereoBase() const
 941 {
 942   return mCore->GetStereoBase();
 943 }
 944
 945 } // namespace Adaptor
 946
 947 } // namespace Internal
 948
 949 } // namespace Dali