adaptors/common/adaptor-impl.cpp

   1 /*
   2  * Copyright (c) 2017 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 <dali/public-api/common/dali-common.h>
  23 #include <dali/integration-api/debug.h>
  24 #include <dali/integration-api/core.h>
  25 #include <dali/integration-api/context-notifier.h>
  26 #include <dali/integration-api/profiling.h>
  27 #include <dali/integration-api/input-options.h>
  28 #include <dali/integration-api/events/touch-event-integ.h>
  29
  30 // INTERNAL INCLUDES
  31 #include <base/thread-controller.h>
  32 #include <base/performance-logging/performance-interface-factory.h>
  33 #include <base/lifecycle-observer.h>
  34
  35 #include <dali/devel-api/text-abstraction/font-client.h>
  36
  37 #include <callback-manager.h>
  38 #include <render-surface.h>
  39 #include <tts-player-impl.h>
  40 #include <accessibility-adaptor-impl.h>
  41 #include <events/gesture-manager.h>
  42 #include <events/event-handler.h>
  43 #include <gl/gl-proxy-implementation.h>
  44 #include <gl/gl-implementation.h>
  45 #include <gl/egl-sync-implementation.h>
  46 #include <gl/egl-image-extensions.h>
  47 #include <gl/egl-factory.h>
  48 #include <imf-manager-impl.h>
  49 #include <clipboard-impl.h>
  50 #include <vsync-monitor.h>
  51 #include <object-profiler.h>
  52 #include <base/display-connection.h>
  53 #include <window-impl.h>
  54
  55 #include <tizen-logging.h>
  56 #include <image-loading.h>
  57
  58 using Dali::TextAbstraction::FontClient;
  59
  60 namespace Dali
  61 {
  62
  63 namespace Internal
  64 {
  65
  66 namespace Adaptor
  67 {
  68
  69 namespace
  70 {
  71 __thread Adaptor* gThreadLocalAdaptor = NULL; // raw thread specific pointer to allow Adaptor::Get
  72 } // unnamed namespace
  73
  74 Dali::Adaptor* Adaptor::New( Any nativeWindow, RenderSurface *surface, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions )
  75 {
  76   Dali::Adaptor* adaptor = new Dali::Adaptor;
  77   Adaptor* impl = new Adaptor( nativeWindow, *adaptor, surface, environmentOptions );
  78   adaptor->mImpl = impl;
  79
  80   impl->Initialize(configuration);
  81
  82   return adaptor;
  83 }
  84
  85 Dali::Adaptor* Adaptor::New( Dali::Window window, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions )
  86 {
  87   Any winId = window.GetNativeHandle();
  88   Window& windowImpl = Dali::GetImplementation(window);
  89   Dali::Adaptor* adaptor = New( winId, windowImpl.GetSurface(), configuration, environmentOptions );
  90   windowImpl.SetAdaptor(*adaptor);
  91   return adaptor;
  92 }
  93
  94 void Adaptor::Initialize( Dali::Configuration::ContextLoss configuration )
  95 {
  96   // all threads here (event, update, and render) will send their logs to TIZEN Platform's LogMessage handler.
  97   Dali::Integration::Log::LogFunction logFunction( Dali::TizenPlatform::LogMessage );
  98   mEnvironmentOptions->SetLogFunction( logFunction );
  99   mEnvironmentOptions->InstallLogFunction(); // install logging for main thread
 100
 101   mPlatformAbstraction = new TizenPlatform::TizenPlatformAbstraction;
 102
 103   std::string path;
 104   GetDataStoragePath( path );
 105   mPlatformAbstraction->SetDataStoragePath( path );
 106
 107   ResourcePolicy::DataRetention dataRetentionPolicy = ResourcePolicy::DALI_DISCARDS_ALL_DATA;
 108   if( configuration == Dali::Configuration::APPLICATION_DOES_NOT_HANDLE_CONTEXT_LOSS )
 109   {
 110     dataRetentionPolicy = ResourcePolicy::DALI_DISCARDS_ALL_DATA;
 111   }
 112   // Note, Tizen does not use DALI_RETAINS_ALL_DATA, as it can reload images from
 113   // files automatically.
 114
 115   if( mEnvironmentOptions->PerformanceServerRequired() )
 116   {
 117     mPerformanceInterface = PerformanceInterfaceFactory::CreateInterface( *this, *mEnvironmentOptions );
 118   }
 119
 120   mCallbackManager = CallbackManager::New();
 121
 122   PositionSize size = mSurface->GetPositionSize();
 123
 124   mGestureManager = new GestureManager(*this, Vector2(size.width, size.height), mCallbackManager, *mEnvironmentOptions);
 125
 126   if( mEnvironmentOptions->GetGlesCallTime() > 0 )
 127   {
 128     mGLES = new GlProxyImplementation( *mEnvironmentOptions );
 129   }
 130   else
 131   {
 132     mGLES = new GlImplementation();
 133   }
 134
 135   mEglFactory = new EglFactory( mEnvironmentOptions->GetMultiSamplingLevel() );
 136
 137   EglSyncImplementation* eglSyncImpl = mEglFactory->GetSyncImplementation();
 138
 139   mCore = Integration::Core::New( *this, *mPlatformAbstraction, *mGLES, *eglSyncImpl, *mGestureManager, dataRetentionPolicy );
 140
 141   const unsigned int timeInterval = mEnvironmentOptions->GetObjectProfilerInterval();
 142   if( 0u < timeInterval )
 143   {
 144     mObjectProfiler = new ObjectProfiler( timeInterval );
 145   }
 146
 147   mNotificationTrigger = mTriggerEventFactory.CreateTriggerEvent( MakeCallback( this, &Adaptor::ProcessCoreEvents ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER);
 148
 149   mVSyncMonitor = new VSyncMonitor;
 150
 151   mThreadController = new ThreadController( *this, *mEnvironmentOptions );
 152
 153   // Should be called after Core creation
 154   if( mEnvironmentOptions->GetPanGestureLoggingLevel() )
 155   {
 156     Integration::EnableProfiling( Dali::Integration::PROFILING_TYPE_PAN_GESTURE );
 157   }
 158   if( mEnvironmentOptions->GetPanGesturePredictionMode() >= 0 )
 159   {
 160     Integration::SetPanGesturePredictionMode(mEnvironmentOptions->GetPanGesturePredictionMode());
 161   }
 162   if( mEnvironmentOptions->GetPanGesturePredictionAmount() >= 0 )
 163   {
 164     Integration::SetPanGesturePredictionAmount(mEnvironmentOptions->GetPanGesturePredictionAmount());
 165   }
 166   if( mEnvironmentOptions->GetPanGestureMaximumPredictionAmount() >= 0 )
 167   {
 168     Integration::SetPanGestureMaximumPredictionAmount(mEnvironmentOptions->GetPanGestureMaximumPredictionAmount());
 169   }
 170   if( mEnvironmentOptions->GetPanGestureMinimumPredictionAmount() >= 0 )
 171   {
 172     Integration::SetPanGestureMinimumPredictionAmount(mEnvironmentOptions->GetPanGestureMinimumPredictionAmount());
 173   }
 174   if( mEnvironmentOptions->GetPanGesturePredictionAmountAdjustment() >= 0 )
 175   {
 176     Integration::SetPanGesturePredictionAmountAdjustment(mEnvironmentOptions->GetPanGesturePredictionAmountAdjustment());
 177   }
 178   if( mEnvironmentOptions->GetPanGestureSmoothingMode() >= 0 )
 179   {
 180     Integration::SetPanGestureSmoothingMode(mEnvironmentOptions->GetPanGestureSmoothingMode());
 181   }
 182   if( mEnvironmentOptions->GetPanGestureSmoothingAmount() >= 0.0f )
 183   {
 184     Integration::SetPanGestureSmoothingAmount(mEnvironmentOptions->GetPanGestureSmoothingAmount());
 185   }
 186
 187   // Set max texture size
 188   if( mEnvironmentOptions->GetMaxTextureSize() > 0 )
 189   {
 190     Dali::SetMaxTextureSize( mEnvironmentOptions->GetMaxTextureSize() );
 191   }
 192 }
 193
 194 Adaptor::~Adaptor()
 195 {
 196   // Ensure stop status
 197   Stop();
 198
 199   // set to NULL first as we do not want any access to Adaptor as it is being destroyed.
 200   gThreadLocalAdaptor = NULL;
 201
 202   for ( ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter )
 203   {
 204     (*iter)->OnDestroy();
 205   }
 206
 207   delete mThreadController; // this will shutdown render thread, which will call Core::ContextDestroyed before exit
 208   delete mVSyncMonitor;
 209   delete mEventHandler;
 210   delete mObjectProfiler;
 211
 212   delete mCore;
 213   delete mEglFactory;
 214   delete mGLES;
 215   delete mGestureManager;
 216   delete mPlatformAbstraction;
 217   delete mCallbackManager;
 218   delete mPerformanceInterface;
 219
 220   // uninstall it on this thread (main actor thread)
 221   Dali::Integration::Log::UninstallLogFunction();
 222
 223   // Delete environment options if we own it
 224   if( mEnvironmentOptionsOwned )
 225   {
 226     delete mEnvironmentOptions;
 227   }
 228 }
 229
 230 void Adaptor::Start()
 231 {
 232   // it doesn't support restart after stop at this moment
 233   // to support restarting, need more testing
 234   if( READY != mState )
 235   {
 236     return;
 237   }
 238
 239   // Start the callback manager
 240   mCallbackManager->Start();
 241
 242   // create event handler
 243   mEventHandler = new EventHandler( mSurface, *this, *mGestureManager, *this, mDragAndDropDetector );
 244
 245   if( mDeferredRotationObserver != NULL )
 246   {
 247     mEventHandler->SetRotationObserver(mDeferredRotationObserver);
 248     mDeferredRotationObserver = NULL;
 249   }
 250
 251   unsigned int dpiHor, dpiVer;
 252   dpiHor = dpiVer = 0;
 253   Dali::DisplayConnection::GetDpi(dpiHor, dpiVer);
 254
 255   // tell core about the DPI value
 256   mCore->SetDpi(dpiHor, dpiVer);
 257
 258   // set the DPI value for font rendering
 259   FontClient fontClient = FontClient::Get();
 260   fontClient.SetDpi( dpiHor, dpiVer );
 261
 262   // Tell the core the size of the surface just before we start the render-thread
 263   PositionSize size = mSurface->GetPositionSize();
 264   mCore->SurfaceResized( size.width, size.height );
 265
 266   // Initialize the thread controller
 267   mThreadController->Initialize();
 268
 269   mState = RUNNING;
 270
 271   ProcessCoreEvents(); // Ensure any startup messages are processed.
 272
 273   for ( ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter )
 274   {
 275     (*iter)->OnStart();
 276   }
 277 }
 278
 279 // Dali::Internal::Adaptor::Adaptor::Pause
 280 void Adaptor::Pause()
 281 {
 282   // Only pause the adaptor if we're actually running.
 283   if( RUNNING == mState )
 284   {
 285     // Inform observers that we are about to be paused.
 286     for( ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter )
 287     {
 288       (*iter)->OnPause();
 289     }
 290
 291     // Reset the event handler when adaptor paused
 292     if( mEventHandler )
 293     {
 294       mEventHandler->Pause();
 295     }
 296
 297     mThreadController->Pause();
 298     mCore->Suspend();
 299     mState = PAUSED;
 300   }
 301 }
 302
 303 // Dali::Internal::Adaptor::Adaptor::Resume
 304 void Adaptor::Resume()
 305 {
 306   // Only resume the adaptor if we are in the suspended state.
 307   if( PAUSED == mState )
 308   {
 309     mState = RUNNING;
 310
 311     // Reset the event handler when adaptor resumed
 312     if( mEventHandler )
 313     {
 314       mEventHandler->Resume();
 315     }
 316
 317     // Inform observers that we have resumed.
 318     for( ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter )
 319     {
 320       (*iter)->OnResume();
 321     }
 322
 323     // Resume core so it processes any requests as well
 324     mCore->Resume();
 325
 326     // Do at end to ensure our first update/render after resumption includes the processed messages as well
 327     mThreadController->Resume();
 328   }
 329 }
 330
 331 void Adaptor::Stop()
 332 {
 333   if( RUNNING == mState ||
 334       PAUSED  == mState ||
 335       PAUSED_WHILE_HIDDEN == mState )
 336   {
 337     for( ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter )
 338     {
 339       (*iter)->OnStop();
 340     }
 341
 342     mThreadController->Stop();
 343     mCore->Suspend();
 344
 345     // Delete the TTS player
 346     for(int i =0; i < Dali::TtsPlayer::MODE_NUM; i++)
 347     {
 348       if(mTtsPlayers[i])
 349       {
 350         mTtsPlayers[i].Reset();
 351       }
 352     }
 353
 354     delete mEventHandler;
 355     mEventHandler = NULL;
 356
 357     delete mNotificationTrigger;
 358     mNotificationTrigger = NULL;
 359
 360     mCallbackManager->Stop();
 361
 362     mState = STOPPED;
 363   }
 364 }
 365
 366 void Adaptor::ContextLost()
 367 {
 368   mCore->GetContextNotifier()->NotifyContextLost(); // Inform stage
 369 }
 370
 371 void Adaptor::ContextRegained()
 372 {
 373   // Inform core, so that texture resources can be reloaded
 374   mCore->RecoverFromContextLoss();
 375
 376   mCore->GetContextNotifier()->NotifyContextRegained(); // Inform stage
 377 }
 378
 379 void Adaptor::FeedTouchPoint( TouchPoint& point, int timeStamp )
 380 {
 381   mEventHandler->FeedTouchPoint( point, timeStamp );
 382 }
 383
 384 void Adaptor::FeedWheelEvent( WheelEvent& wheelEvent )
 385 {
 386   mEventHandler->FeedWheelEvent( wheelEvent );
 387 }
 388
 389 void Adaptor::FeedKeyEvent( KeyEvent& keyEvent )
 390 {
 391   mEventHandler->FeedKeyEvent( keyEvent );
 392 }
 393
 394 void Adaptor::ReplaceSurface( Any nativeWindow, RenderSurface& surface )
 395 {
 396   PositionSize positionSize = surface.GetPositionSize();
 397
 398   // let the core know the surface size has changed
 399   mCore->SurfaceResized( positionSize.width, positionSize.height );
 400
 401   mResizedSignal.Emit( mAdaptor );
 402
 403   mNativeWindow = nativeWindow;
 404   mSurface = &surface;
 405
 406   // flush the event queue to give the update-render thread chance
 407   // to start processing messages for new camera setup etc as soon as possible
 408   ProcessCoreEvents();
 409
 410   // this method blocks until the render thread has completed the replace.
 411   mThreadController->ReplaceSurface(mSurface);
 412 }
 413
 414 RenderSurface& Adaptor::GetSurface() const
 415 {
 416   return *mSurface;
 417 }
 418
 419 void Adaptor::ReleaseSurfaceLock()
 420 {
 421   mSurface->ReleaseLock();
 422 }
 423
 424 Dali::TtsPlayer Adaptor::GetTtsPlayer(Dali::TtsPlayer::Mode mode)
 425 {
 426   if(!mTtsPlayers[mode])
 427   {
 428     // Create the TTS player when it needed, because it can reduce launching time.
 429     mTtsPlayers[mode] = TtsPlayer::New(mode);
 430   }
 431
 432   return mTtsPlayers[mode];
 433 }
 434
 435 bool Adaptor::AddIdle( CallbackBase* callback )
 436 {
 437   bool idleAdded(false);
 438
 439   // Only add an idle if the Adaptor is actually running
 440   if( RUNNING == mState )
 441   {
 442     idleAdded = mCallbackManager->AddIdleCallback( callback );
 443   }
 444
 445   return idleAdded;
 446 }
 447
 448 void Adaptor::RemoveIdle( CallbackBase* callback )
 449 {
 450   mCallbackManager->RemoveIdleCallback( callback );
 451 }
 452
 453 Dali::Adaptor& Adaptor::Get()
 454 {
 455   DALI_ASSERT_ALWAYS( IsAvailable() && "Adaptor not instantiated" );
 456   return gThreadLocalAdaptor->mAdaptor;
 457 }
 458
 459 bool Adaptor::IsAvailable()
 460 {
 461   return gThreadLocalAdaptor != NULL;
 462 }
 463
 464 void Adaptor::SceneCreated()
 465 {
 466   mCore->SceneCreated();
 467 }
 468
 469 Dali::Integration::Core& Adaptor::GetCore()
 470 {
 471   return *mCore;
 472 }
 473
 474 void Adaptor::SetRenderRefreshRate( unsigned int numberOfVSyncsPerRender )
 475 {
 476   mThreadController->SetRenderRefreshRate( numberOfVSyncsPerRender );
 477 }
 478
 479 void Adaptor::SetUseHardwareVSync( bool useHardware )
 480 {
 481   mVSyncMonitor->SetUseHardwareVSync( useHardware );
 482 }
 483
 484 EglFactory& Adaptor::GetEGLFactory() const
 485 {
 486   DALI_ASSERT_DEBUG( mEglFactory && "EGL Factory not created" );
 487   return *mEglFactory;
 488 }
 489
 490 EglFactoryInterface& Adaptor::GetEGLFactoryInterface() const
 491 {
 492   return *mEglFactory;
 493 }
 494
 495 Integration::GlAbstraction& Adaptor::GetGlAbstraction() const
 496 {
 497   DALI_ASSERT_DEBUG( mGLES && "GLImplementation not created" );
 498   return *mGLES;
 499 }
 500
 501 Dali::Integration::PlatformAbstraction& Adaptor::GetPlatformAbstractionInterface()
 502 {
 503   return *mPlatformAbstraction;
 504 }
 505
 506 Dali::Integration::GlAbstraction& Adaptor::GetGlesInterface()
 507 {
 508   return *mGLES;
 509 }
 510
 511 TriggerEventInterface& Adaptor::GetProcessCoreEventsTrigger()
 512 {
 513   return *mNotificationTrigger;
 514 }
 515
 516 TriggerEventFactoryInterface& Adaptor::GetTriggerEventFactoryInterface()
 517 {
 518   return mTriggerEventFactory;
 519 }
 520
 521 SocketFactoryInterface& Adaptor::GetSocketFactoryInterface()
 522 {
 523   return mSocketFactory;
 524 }
 525
 526 RenderSurface* Adaptor::GetRenderSurfaceInterface()
 527 {
 528   return mSurface;
 529 }
 530
 531 VSyncMonitorInterface* Adaptor::GetVSyncMonitorInterface()
 532 {
 533   return mVSyncMonitor;
 534 }
 535
 536 TraceInterface& Adaptor::GetKernelTraceInterface()
 537 {
 538   return mKernelTracer;
 539 }
 540
 541 TraceInterface& Adaptor::GetSystemTraceInterface()
 542 {
 543   return mSystemTracer;
 544 }
 545
 546 PerformanceInterface* Adaptor::GetPerformanceInterface()
 547 {
 548   return mPerformanceInterface;
 549 }
 550
 551 Integration::PlatformAbstraction& Adaptor::GetPlatformAbstraction() const
 552 {
 553   DALI_ASSERT_DEBUG( mPlatformAbstraction && "PlatformAbstraction not created" );
 554   return *mPlatformAbstraction;
 555 }
 556
 557 void Adaptor::SetDragAndDropDetector( DragAndDropDetectorPtr detector )
 558 {
 559   mDragAndDropDetector = detector;
 560
 561   if ( mEventHandler )
 562   {
 563     mEventHandler->SetDragAndDropDetector( detector );
 564   }
 565 }
 566
 567 void Adaptor::SetRotationObserver( RotationObserver* observer )
 568 {
 569   if( mEventHandler )
 570   {
 571     mEventHandler->SetRotationObserver( observer );
 572   }
 573   else if( mState == READY )
 574   {
 575     // Set once event handler exists
 576     mDeferredRotationObserver = observer;
 577   }
 578 }
 579
 580 void Adaptor::DestroyTtsPlayer(Dali::TtsPlayer::Mode mode)
 581 {
 582   if(mTtsPlayers[mode])
 583   {
 584     mTtsPlayers[mode].Reset();
 585   }
 586 }
 587
 588 void Adaptor::SetMinimumPinchDistance(float distance)
 589 {
 590   if( mGestureManager )
 591   {
 592     mGestureManager->SetMinimumPinchDistance(distance);
 593   }
 594 }
 595
 596 Any Adaptor::GetNativeWindowHandle()
 597 {
 598   return mNativeWindow;
 599 }
 600
 601 void Adaptor::SetUseRemoteSurface(bool useRemoteSurface)
 602 {
 603   mUseRemoteSurface = useRemoteSurface;
 604 }
 605
 606 void Adaptor::AddObserver( LifeCycleObserver& observer )
 607 {
 608   ObserverContainer::iterator match ( find(mObservers.begin(), mObservers.end(), &observer) );
 609
 610   if ( match == mObservers.end() )
 611   {
 612     mObservers.push_back( &observer );
 613   }
 614 }
 615
 616 void Adaptor::RemoveObserver( LifeCycleObserver& observer )
 617 {
 618   ObserverContainer::iterator match ( find(mObservers.begin(), mObservers.end(), &observer) );
 619
 620   if ( match != mObservers.end() )
 621   {
 622     mObservers.erase( match );
 623   }
 624 }
 625
 626 void Adaptor::QueueCoreEvent(const Dali::Integration::Event& event)
 627 {
 628   if( mCore )
 629   {
 630     mCore->QueueEvent(event);
 631   }
 632 }
 633
 634 void Adaptor::ProcessCoreEvents()
 635 {
 636   if( mCore )
 637   {
 638     if( mPerformanceInterface )
 639     {
 640       mPerformanceInterface->AddMarker( PerformanceInterface::PROCESS_EVENTS_START );
 641     }
 642
 643     mCore->ProcessEvents();
 644
 645     if( mPerformanceInterface )
 646     {
 647       mPerformanceInterface->AddMarker( PerformanceInterface::PROCESS_EVENTS_END );
 648     }
 649   }
 650 }
 651
 652 void Adaptor::RequestUpdate()
 653 {
 654   // When Dali applications are partially visible behind the lock-screen,
 655   // the indicator must be updated (therefore allow updates in the PAUSED state)
 656   if ( PAUSED  == mState ||
 657        RUNNING == mState )
 658   {
 659     mThreadController->RequestUpdate();
 660   }
 661 }
 662
 663 void Adaptor::RequestProcessEventsOnIdle()
 664 {
 665   // Only request a notification if the Adaptor is actually running
 666   // and we haven't installed the idle notification
 667   if( ( ! mNotificationOnIdleInstalled ) && ( RUNNING == mState ) )
 668   {
 669     mNotificationOnIdleInstalled = AddIdle( MakeCallback( this, &Adaptor::ProcessCoreEventsFromIdle ) );
 670   }
 671 }
 672
 673 void Adaptor::OnWindowShown()
 674 {
 675   if ( PAUSED_WHILE_HIDDEN == mState )
 676   {
 677     // Adaptor can now be resumed
 678     mState = PAUSED;
 679
 680     Resume();
 681
 682     // Force a render task
 683     RequestUpdateOnce();
 684   }
 685 }
 686
 687 void Adaptor::OnWindowHidden()
 688 {
 689   if ( STOPPED != mState )
 690   {
 691     Pause();
 692
 693     // Adaptor cannot be resumed until the window is shown
 694     mState = PAUSED_WHILE_HIDDEN;
 695   }
 696 }
 697
 698 // Dali::Internal::Adaptor::Adaptor::OnDamaged
 699 void Adaptor::OnDamaged( const DamageArea& area )
 700 {
 701   // This is needed for the case where Dali window is partially obscured
 702   RequestUpdate();
 703 }
 704
 705 void Adaptor::SurfaceResizePrepare( Dali::Adaptor::SurfaceSize surfaceSize )
 706 {
 707   // let the core know the surface size has changed
 708   mCore->SurfaceResized( surfaceSize.GetWidth(), surfaceSize.GetHeight() );
 709
 710   mResizedSignal.Emit( mAdaptor );
 711 }
 712
 713 void Adaptor::SurfaceResizeComplete( Dali::Adaptor::SurfaceSize surfaceSize )
 714 {
 715   // flush the event queue to give the update-render thread chance
 716   // to start processing messages for new camera setup etc as soon as possible
 717   ProcessCoreEvents();
 718
 719   // this method blocks until the render thread has completed the resizing.
 720   mThreadController->ResizeSurface();
 721 }
 722
 723 void Adaptor::NotifySceneCreated()
 724 {
 725   GetCore().SceneCreated();
 726
 727   // Start thread controller after the scene has been created
 728   mThreadController->Start();
 729
 730   // process after surface is created (registering to remote surface provider if required)
 731   SurfaceInitialized();
 732 }
 733
 734 void Adaptor::NotifyLanguageChanged()
 735 {
 736   mLanguageChangedSignal.Emit( mAdaptor );
 737 }
 738
 739 void Adaptor::RequestUpdateOnce()
 740 {
 741   if( PAUSED_WHILE_HIDDEN != mState )
 742   {
 743     if( mThreadController )
 744     {
 745       mThreadController->RequestUpdateOnce();
 746     }
 747   }
 748 }
 749
 750 void Adaptor::IndicatorSizeChanged(int height)
 751 {
 752   // let the core know the indicator height is changed
 753   mCore->SetTopMargin(height);
 754 }
 755
 756 void Adaptor::ProcessCoreEventsFromIdle()
 757 {
 758   ProcessCoreEvents();
 759
 760   // the idle handle automatically un-installs itself
 761   mNotificationOnIdleInstalled = false;
 762 }
 763
 764 Adaptor::Adaptor(Any nativeWindow, Dali::Adaptor& adaptor, RenderSurface* surface, EnvironmentOptions* environmentOptions)
 765 : mResizedSignal(),
 766   mLanguageChangedSignal(),
 767   mAdaptor( adaptor ),
 768   mState( READY ),
 769   mCore( NULL ),
 770   mThreadController( NULL ),
 771   mVSyncMonitor( NULL ),
 772   mGLES( NULL ),
 773   mGlSync( NULL ),
 774   mEglFactory( NULL ),
 775   mNativeWindow( nativeWindow ),
 776   mSurface( surface ),
 777   mPlatformAbstraction( NULL ),
 778   mEventHandler( NULL ),
 779   mCallbackManager( NULL ),
 780   mNotificationOnIdleInstalled( false ),
 781   mNotificationTrigger( NULL ),
 782   mGestureManager( NULL ),
 783   mDaliFeedbackPlugin(),
 784   mFeedbackController( NULL ),
 785   mTtsPlayers(),
 786   mObservers(),
 787   mDragAndDropDetector(),
 788   mDeferredRotationObserver( NULL ),
 789   mEnvironmentOptions( environmentOptions ? environmentOptions : new EnvironmentOptions /* Create the options if not provided */),
 790   mPerformanceInterface( NULL ),
 791   mKernelTracer(),
 792   mSystemTracer(),
 793   mTriggerEventFactory(),
 794   mObjectProfiler( NULL ),
 795   mSocketFactory(),
 796   mEnvironmentOptionsOwned( environmentOptions ? false : true /* If not provided then we own the object */ ),
 797   mUseRemoteSurface( false )
 798 {
 799   DALI_ASSERT_ALWAYS( !IsAvailable() && "Cannot create more than one Adaptor per thread" );
 800   gThreadLocalAdaptor = this;
 801 }
 802
 803 // Stereoscopy
 804
 805 void Adaptor::SetViewMode( ViewMode viewMode )
 806 {
 807   mSurface->SetViewMode( viewMode );
 808   mCore->SetViewMode( viewMode );
 809 }
 810
 811 ViewMode Adaptor::GetViewMode() const
 812 {
 813   return mCore->GetViewMode();
 814 }
 815
 816 void Adaptor::SetStereoBase( float stereoBase )
 817 {
 818   mCore->SetStereoBase( stereoBase );
 819 }
 820
 821 float Adaptor::GetStereoBase() const
 822 {
 823   return mCore->GetStereoBase();
 824 }
 825
 826 } // namespace Adaptor
 827
 828 } // namespace Internal
 829
 830 } // namespace Dali