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 TraceInterface& Adaptor::GetKernelTraceInterface()
 700 {
 701   return mKernelTracer;
 702 }
 703
 704 TraceInterface& Adaptor::GetSystemTraceInterface()
 705 {
 706   return mSystemTracer;
 707 }
 708
 709 PerformanceInterface* Adaptor::GetPerformanceInterface()
 710 {
 711   return mPerformanceInterface;
 712 }
 713
 714 Integration::PlatformAbstraction& Adaptor::GetPlatformAbstraction() const
 715 {
 716   DALI_ASSERT_DEBUG( mPlatformAbstraction && "PlatformAbstraction not created" );
 717   return *mPlatformAbstraction;
 718 }
 719
 720 void Adaptor::SetDragAndDropDetector( DragAndDropDetectorPtr detector )
 721 {
 722   mDragAndDropDetector = detector;
 723
 724   if ( mEventHandler )
 725   {
 726     mEventHandler->SetDragAndDropDetector( detector );
 727   }
 728 }
 729
 730 void Adaptor::SetRotationObserver( RotationObserver* observer )
 731 {
 732   if( mEventHandler )
 733   {
 734     mEventHandler->SetRotationObserver( observer );
 735   }
 736   else if( mState == READY )
 737   {
 738     // Set once event handler exists
 739     mDeferredRotationObserver = observer;
 740   }
 741 }
 742
 743 void Adaptor::DestroyTtsPlayer(Dali::TtsPlayer::Mode mode)
 744 {
 745   if(mTtsPlayers[mode])
 746   {
 747     mTtsPlayers[mode].Reset();
 748   }
 749 }
 750
 751 void Adaptor::SetMinimumPinchDistance(float distance)
 752 {
 753   if( mGestureManager )
 754   {
 755     mGestureManager->SetMinimumPinchDistance(distance);
 756   }
 757 }
 758
 759 Any Adaptor::GetNativeWindowHandle()
 760 {
 761   return mNativeWindow;
 762 }
 763
 764 void Adaptor::AddObserver( LifeCycleObserver& observer )
 765 {
 766   ObserverContainer::iterator match ( find(mObservers.begin(), mObservers.end(), &observer) );
 767
 768   if ( match == mObservers.end() )
 769   {
 770     mObservers.push_back( &observer );
 771   }
 772 }
 773
 774 void Adaptor::RemoveObserver( LifeCycleObserver& observer )
 775 {
 776   ObserverContainer::iterator match ( find(mObservers.begin(), mObservers.end(), &observer) );
 777
 778   if ( match != mObservers.end() )
 779   {
 780     mObservers.erase( match );
 781   }
 782 }
 783
 784 void Adaptor::QueueCoreEvent(const Dali::Integration::Event& event)
 785 {
 786   if( mCore )
 787   {
 788     mCore->QueueEvent(event);
 789   }
 790 }
 791
 792 void Adaptor::ProcessCoreEvents()
 793 {
 794   if( mCore )
 795   {
 796     if( mPerformanceInterface )
 797     {
 798       mPerformanceInterface->AddMarker( PerformanceInterface::PROCESS_EVENTS_START );
 799     }
 800
 801     mCore->ProcessEvents();
 802
 803     if( mPerformanceInterface )
 804     {
 805       mPerformanceInterface->AddMarker( PerformanceInterface::PROCESS_EVENTS_END );
 806     }
 807   }
 808 }
 809
 810 void Adaptor::RequestUpdate()
 811 {
 812   // When Dali applications are partially visible behind the lock-screen,
 813   // the indicator must be updated (therefore allow updates in the PAUSED state)
 814   if ( PAUSED  == mState ||
 815        RUNNING == mState )
 816   {
 817     mUpdateRenderController->RequestUpdate();
 818   }
 819 }
 820
 821 void Adaptor::RequestProcessEventsOnIdle()
 822 {
 823   // Only request a notification if the Adaptor is actually running
 824   // and we haven't installed the idle notification
 825   if( ( ! mNotificationOnIdleInstalled ) && ( RUNNING == mState ) )
 826   {
 827     mNotificationOnIdleInstalled = AddIdle( MakeCallback( this, &Adaptor::ProcessCoreEventsFromIdle ) );
 828   }
 829 }
 830
 831 void Adaptor::OnWindowShown()
 832 {
 833   if ( PAUSED_WHILE_HIDDEN == mState )
 834   {
 835     // Adaptor can now be resumed
 836     mState = PAUSED;
 837
 838     Resume();
 839
 840     // Force a render task
 841     RequestUpdateOnce();
 842   }
 843 }
 844
 845 void Adaptor::OnWindowHidden()
 846 {
 847   if ( STOPPED != mState )
 848   {
 849     Pause();
 850
 851     // Adaptor cannot be resumed until the window is shown
 852     mState = PAUSED_WHILE_HIDDEN;
 853   }
 854 }
 855
 856 // Dali::Internal::Adaptor::Adaptor::OnDamaged
 857 void Adaptor::OnDamaged( const DamageArea& area )
 858 {
 859   // This is needed for the case where Dali window is partially obscured
 860   RequestUpdate();
 861 }
 862
 863 void Adaptor::SurfaceSizeChanged(const PositionSize& positionSize)
 864 {
 865   // let the core know the surface size has changed
 866   mCore->SurfaceResized(positionSize.width, positionSize.height);
 867
 868   mResizedSignal.Emit( mAdaptor );
 869 }
 870
 871 void Adaptor::NotifyLanguageChanged()
 872 {
 873   mLanguageChangedSignal.Emit( mAdaptor );
 874 }
 875
 876 void Adaptor::RequestUpdateOnce()
 877 {
 878   if( PAUSED_WHILE_HIDDEN != mState )
 879   {
 880     if( mUpdateRenderController )
 881     {
 882       mUpdateRenderController->RequestUpdateOnce();
 883     }
 884   }
 885 }
 886
 887 void Adaptor::ProcessCoreEventsFromIdle()
 888 {
 889   ProcessCoreEvents();
 890
 891   // the idle handle automatically un-installs itself
 892   mNotificationOnIdleInstalled = false;
 893 }
 894
 895 Adaptor::Adaptor(Any nativeWindow, Dali::Adaptor& adaptor, RenderSurface* surface, const DeviceLayout& baseLayout)
 896 : mResizedSignal(),
 897   mLanguageChangedSignal(),
 898   mAdaptor(adaptor),
 899   mState(READY),
 900   mCore(NULL),
 901   mUpdateRenderController(NULL),
 902   mVSyncMonitor(NULL),
 903   mGLES( NULL ),
 904   mEglFactory( NULL ),
 905   mNativeWindow( nativeWindow ),
 906   mSurface( surface ),
 907   mPlatformAbstraction( NULL ),
 908   mEventHandler( NULL ),
 909   mCallbackManager( NULL ),
 910   mNotificationOnIdleInstalled( false ),
 911   mNotificationTrigger(NULL),
 912   mGestureManager(NULL),
 913   mDaliFeedbackPlugin(NULL),
 914   mFeedbackController(NULL),
 915   mObservers(),
 916   mDragAndDropDetector(),
 917   mDeferredRotationObserver(NULL),
 918   mBaseLayout(baseLayout),
 919   mEnvironmentOptions(),
 920   mPerformanceInterface(NULL),
 921   mObjectProfiler(NULL)
 922 {
 923   DALI_ASSERT_ALWAYS( gThreadLocalAdaptor.get() == NULL && "Cannot create more than one Adaptor per thread" );
 924   gThreadLocalAdaptor.reset(this);
 925 }
 926
 927 // Stereoscopy
 928
 929 void Adaptor::SetViewMode( ViewMode viewMode )
 930 {
 931   mSurface->SetViewMode( viewMode );
 932   mCore->SetViewMode( viewMode );
 933 }
 934
 935 ViewMode Adaptor::GetViewMode() const
 936 {
 937   return mCore->GetViewMode();
 938 }
 939
 940 void Adaptor::SetStereoBase( float stereoBase )
 941 {
 942   mCore->SetStereoBase( stereoBase );
 943 }
 944
 945 float Adaptor::GetStereoBase() const
 946 {
 947   return mCore->GetStereoBase();
 948 }
 949
 950 } // namespace Adaptor
 951
 952 } // namespace Internal
 953
 954 } // namespace Dali