adaptors/common/adaptor-impl.cpp

   1 /*
   2  * Copyright (c) 2015 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
  57 using Dali::TextAbstraction::FontClient;
  58
  59 namespace Dali
  60 {
  61
  62 namespace Internal
  63 {
  64
  65 namespace Adaptor
  66 {
  67
  68 namespace
  69 {
  70 __thread Adaptor* gThreadLocalAdaptor = NULL; // raw thread specific pointer to allow Adaptor::Get
  71 } // unnamed namespace
  72
  73 Dali::Adaptor* Adaptor::New( Any nativeWindow, RenderSurface *surface, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions )
  74 {
  75   Dali::Adaptor* adaptor = new Dali::Adaptor;
  76   Adaptor* impl = new Adaptor( nativeWindow, *adaptor, surface, environmentOptions );
  77   adaptor->mImpl = impl;
  78
  79   impl->Initialize(configuration);
  80
  81   return adaptor;
  82 }
  83
  84 Dali::Adaptor* Adaptor::New( Dali::Window window, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions )
  85 {
  86   Any winId = window.GetNativeHandle();
  87
  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();
 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
 188 Adaptor::~Adaptor()
 189 {
 190   // Ensure stop status
 191   Stop();
 192
 193   // set to NULL first as we do not want any access to Adaptor as it is being destroyed.
 194   gThreadLocalAdaptor = NULL;
 195
 196   for ( ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter )
 197   {
 198     (*iter)->OnDestroy();
 199   }
 200
 201   delete mThreadController; // this will shutdown render thread, which will call Core::ContextDestroyed before exit
 202   delete mVSyncMonitor;
 203   delete mEventHandler;
 204   delete mObjectProfiler;
 205
 206   delete mCore;
 207   delete mEglFactory;
 208   delete mGLES;
 209   delete mGestureManager;
 210   delete mPlatformAbstraction;
 211   delete mCallbackManager;
 212   delete mPerformanceInterface;
 213
 214   // uninstall it on this thread (main actor thread)
 215   Dali::Integration::Log::UninstallLogFunction();
 216
 217   // Delete environment options if we own it
 218   if( mEnvironmentOptionsOwned )
 219   {
 220     delete mEnvironmentOptions;
 221   }
 222 }
 223
 224 void Adaptor::Start()
 225 {
 226   // it doesn't support restart after stop at this moment
 227   // to support restarting, need more testing
 228   if( READY != mState )
 229   {
 230     return;
 231   }
 232
 233   // Start the callback manager
 234   mCallbackManager->Start();
 235
 236   // create event handler
 237   mEventHandler = new EventHandler( mSurface, *this, *mGestureManager, *this, mDragAndDropDetector );
 238
 239   if( mDeferredRotationObserver != NULL )
 240   {
 241     mEventHandler->SetRotationObserver(mDeferredRotationObserver);
 242     mDeferredRotationObserver = NULL;
 243   }
 244
 245   unsigned int dpiHor, dpiVer;
 246   dpiHor = dpiVer = 0;
 247   Dali::DisplayConnection::GetDpi(dpiHor, dpiVer);
 248
 249   // tell core about the DPI value
 250   mCore->SetDpi(dpiHor, dpiVer);
 251
 252   // set the DPI value for font rendering
 253   FontClient fontClient = FontClient::Get();
 254   fontClient.SetDpi( dpiHor, dpiVer );
 255
 256   // Tell the core the size of the surface just before we start the render-thread
 257   PositionSize size = mSurface->GetPositionSize();
 258   mCore->SurfaceResized( size.width, size.height );
 259
 260   // Initialize the thread controller
 261   mThreadController->Initialize();
 262
 263   mState = RUNNING;
 264
 265   ProcessCoreEvents(); // Ensure any startup messages are processed.
 266
 267   for ( ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter )
 268   {
 269     (*iter)->OnStart();
 270   }
 271 }
 272
 273 // Dali::Internal::Adaptor::Adaptor::Pause
 274 void Adaptor::Pause()
 275 {
 276   // Only pause the adaptor if we're actually running.
 277   if( RUNNING == mState )
 278   {
 279     // Inform observers that we are about to be paused.
 280     for( ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter )
 281     {
 282       (*iter)->OnPause();
 283     }
 284
 285     // Reset the event handler when adaptor paused
 286     if( mEventHandler )
 287     {
 288       mEventHandler->Pause();
 289     }
 290
 291     mThreadController->Pause();
 292     mCore->Suspend();
 293     mState = PAUSED;
 294   }
 295 }
 296
 297 // Dali::Internal::Adaptor::Adaptor::Resume
 298 void Adaptor::Resume()
 299 {
 300   // Only resume the adaptor if we are in the suspended state.
 301   if( PAUSED == mState )
 302   {
 303     // Resume core first
 304     mCore->Resume();
 305
 306     mState = RUNNING;
 307
 308     // Reset the event handler when adaptor resumed
 309     if( mEventHandler )
 310     {
 311       mEventHandler->Resume();
 312     }
 313
 314     // Inform observers that we have resumed.
 315     for( ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter )
 316     {
 317       (*iter)->OnResume();
 318     }
 319
 320     ProcessCoreEvents(); // Ensure any outstanding messages are processed
 321
 322     // Ensure our first update includes the processed messages
 323     mThreadController->Resume();
 324   }
 325 }
 326
 327 void Adaptor::Stop()
 328 {
 329   if( RUNNING == mState ||
 330       PAUSED  == mState ||
 331       PAUSED_WHILE_HIDDEN == mState )
 332   {
 333     for( ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter )
 334     {
 335       (*iter)->OnStop();
 336     }
 337
 338     mThreadController->Stop();
 339     mCore->Suspend();
 340
 341     // Delete the TTS player
 342     for(int i =0; i < Dali::TtsPlayer::MODE_NUM; i++)
 343     {
 344       if(mTtsPlayers[i])
 345       {
 346         mTtsPlayers[i].Reset();
 347       }
 348     }
 349
 350     delete mEventHandler;
 351     mEventHandler = NULL;
 352
 353     delete mNotificationTrigger;
 354     mNotificationTrigger = NULL;
 355
 356     mCallbackManager->Stop();
 357
 358     mState = STOPPED;
 359   }
 360 }
 361
 362 void Adaptor::ContextLost()
 363 {
 364   mCore->GetContextNotifier()->NotifyContextLost(); // Inform stage
 365 }
 366
 367 void Adaptor::ContextRegained()
 368 {
 369   // Inform core, so that texture resources can be reloaded
 370   mCore->RecoverFromContextLoss();
 371
 372   mCore->GetContextNotifier()->NotifyContextRegained(); // Inform stage
 373 }
 374
 375 void Adaptor::FeedTouchPoint( TouchPoint& point, int timeStamp )
 376 {
 377   mEventHandler->FeedTouchPoint( point, timeStamp );
 378 }
 379
 380 void Adaptor::FeedWheelEvent( WheelEvent& wheelEvent )
 381 {
 382   mEventHandler->FeedWheelEvent( wheelEvent );
 383 }
 384
 385 void Adaptor::FeedKeyEvent( KeyEvent& keyEvent )
 386 {
 387   mEventHandler->FeedKeyEvent( keyEvent );
 388 }
 389
 390 bool Adaptor::MoveResize( const PositionSize& positionSize )
 391 {
 392   PositionSize old = mSurface->GetPositionSize();
 393
 394   // just resize the surface. The driver should automatically resize the egl Surface (untested)
 395   // EGL Spec says : EGL window surfaces need to be resized when their corresponding native window
 396   // is resized. Implementations typically use hooks into the OS and native window
 397   // system to perform this resizing on demand, transparently to the client.
 398   mSurface->MoveResize( positionSize );
 399
 400   if(old.width != positionSize.width || old.height != positionSize.height)
 401   {
 402     SurfaceSizeChanged(positionSize);
 403   }
 404
 405   return true;
 406 }
 407
 408 void Adaptor::SurfaceResized( const PositionSize& positionSize )
 409 {
 410   PositionSize old = mSurface->GetPositionSize();
 411
 412   // Called by an application, when it has resized a window outside of Dali.
 413   // The EGL driver automatically detects X Window resize calls, and resizes
 414   // the EGL surface for us.
 415   mSurface->MoveResize( positionSize );
 416
 417   if(old.width != positionSize.width || old.height != positionSize.height)
 418   {
 419     SurfaceSizeChanged(positionSize);
 420   }
 421 }
 422
 423 void Adaptor::ReplaceSurface( Any nativeWindow, RenderSurface& surface )
 424 {
 425   mNativeWindow = nativeWindow;
 426   mSurface = &surface;
 427
 428   SurfaceSizeChanged(mSurface->GetPositionSize());
 429
 430   // flush the event queue to give update and render threads chance
 431   // to start processing messages for new camera setup etc as soon as possible
 432   ProcessCoreEvents();
 433
 434   // this method blocks until the render thread has completed the replace.
 435   mThreadController->ReplaceSurface(mSurface);
 436 }
 437
 438 RenderSurface& Adaptor::GetSurface() const
 439 {
 440   return *mSurface;
 441 }
 442
 443 void Adaptor::ReleaseSurfaceLock()
 444 {
 445   mSurface->ReleaseLock();
 446 }
 447
 448 Dali::TtsPlayer Adaptor::GetTtsPlayer(Dali::TtsPlayer::Mode mode)
 449 {
 450   if(!mTtsPlayers[mode])
 451   {
 452     // Create the TTS player when it needed, because it can reduce launching time.
 453     mTtsPlayers[mode] = TtsPlayer::New(mode);
 454   }
 455
 456   return mTtsPlayers[mode];
 457 }
 458
 459 bool Adaptor::AddIdle( CallbackBase* callback )
 460 {
 461   bool idleAdded(false);
 462
 463   // Only add an idle if the Adaptor is actually running
 464   if( RUNNING == mState )
 465   {
 466     idleAdded = mCallbackManager->AddIdleCallback( callback );
 467   }
 468
 469   return idleAdded;
 470 }
 471
 472
 473 Dali::Adaptor& Adaptor::Get()
 474 {
 475   DALI_ASSERT_ALWAYS( IsAvailable() && "Adaptor not instantiated" );
 476   return gThreadLocalAdaptor->mAdaptor;
 477 }
 478
 479 bool Adaptor::IsAvailable()
 480 {
 481   return gThreadLocalAdaptor != NULL;
 482 }
 483
 484 void Adaptor::SceneCreated()
 485 {
 486   mCore->SceneCreated();
 487 }
 488
 489 Dali::Integration::Core& Adaptor::GetCore()
 490 {
 491   return *mCore;
 492 }
 493
 494 void Adaptor::SetRenderRefreshRate( unsigned int numberOfVSyncsPerRender )
 495 {
 496   mThreadController->SetRenderRefreshRate( numberOfVSyncsPerRender );
 497 }
 498
 499 void Adaptor::SetUseHardwareVSync( bool useHardware )
 500 {
 501   mVSyncMonitor->SetUseHardwareVSync( useHardware );
 502 }
 503
 504 EglFactory& Adaptor::GetEGLFactory() const
 505 {
 506   DALI_ASSERT_DEBUG( mEglFactory && "EGL Factory not created" );
 507   return *mEglFactory;
 508 }
 509
 510 EglFactoryInterface& Adaptor::GetEGLFactoryInterface() const
 511 {
 512   return *mEglFactory;
 513 }
 514
 515 Integration::GlAbstraction& Adaptor::GetGlAbstraction() const
 516 {
 517   DALI_ASSERT_DEBUG( mGLES && "GLImplementation not created" );
 518   return *mGLES;
 519 }
 520
 521 Dali::Integration::PlatformAbstraction& Adaptor::GetPlatformAbstractionInterface()
 522 {
 523   return *mPlatformAbstraction;
 524 }
 525
 526 Dali::Integration::GlAbstraction& Adaptor::GetGlesInterface()
 527 {
 528   return *mGLES;
 529 }
 530
 531 TriggerEventInterface& Adaptor::GetProcessCoreEventsTrigger()
 532 {
 533   return *mNotificationTrigger;
 534 }
 535
 536 TriggerEventFactoryInterface& Adaptor::GetTriggerEventFactoryInterface()
 537 {
 538   return mTriggerEventFactory;
 539 }
 540
 541 SocketFactoryInterface& Adaptor::GetSocketFactoryInterface()
 542 {
 543   return mSocketFactory;
 544 }
 545
 546 RenderSurface* Adaptor::GetRenderSurfaceInterface()
 547 {
 548   return mSurface;
 549 }
 550
 551 VSyncMonitorInterface* Adaptor::GetVSyncMonitorInterface()
 552 {
 553   return mVSyncMonitor;
 554 }
 555
 556 TraceInterface& Adaptor::GetKernelTraceInterface()
 557 {
 558   return mKernelTracer;
 559 }
 560
 561 TraceInterface& Adaptor::GetSystemTraceInterface()
 562 {
 563   return mSystemTracer;
 564 }
 565
 566 PerformanceInterface* Adaptor::GetPerformanceInterface()
 567 {
 568   return mPerformanceInterface;
 569 }
 570
 571 Integration::PlatformAbstraction& Adaptor::GetPlatformAbstraction() const
 572 {
 573   DALI_ASSERT_DEBUG( mPlatformAbstraction && "PlatformAbstraction not created" );
 574   return *mPlatformAbstraction;
 575 }
 576
 577 void Adaptor::SetDragAndDropDetector( DragAndDropDetectorPtr detector )
 578 {
 579   mDragAndDropDetector = detector;
 580
 581   if ( mEventHandler )
 582   {
 583     mEventHandler->SetDragAndDropDetector( detector );
 584   }
 585 }
 586
 587 void Adaptor::SetRotationObserver( RotationObserver* observer )
 588 {
 589   if( mEventHandler )
 590   {
 591     mEventHandler->SetRotationObserver( observer );
 592   }
 593   else if( mState == READY )
 594   {
 595     // Set once event handler exists
 596     mDeferredRotationObserver = observer;
 597   }
 598 }
 599
 600 void Adaptor::DestroyTtsPlayer(Dali::TtsPlayer::Mode mode)
 601 {
 602   if(mTtsPlayers[mode])
 603   {
 604     mTtsPlayers[mode].Reset();
 605   }
 606 }
 607
 608 void Adaptor::SetMinimumPinchDistance(float distance)
 609 {
 610   if( mGestureManager )
 611   {
 612     mGestureManager->SetMinimumPinchDistance(distance);
 613   }
 614 }
 615
 616 Any Adaptor::GetNativeWindowHandle()
 617 {
 618   return mNativeWindow;
 619 }
 620
 621 void Adaptor::AddObserver( LifeCycleObserver& observer )
 622 {
 623   ObserverContainer::iterator match ( find(mObservers.begin(), mObservers.end(), &observer) );
 624
 625   if ( match == mObservers.end() )
 626   {
 627     mObservers.push_back( &observer );
 628   }
 629 }
 630
 631 void Adaptor::RemoveObserver( LifeCycleObserver& observer )
 632 {
 633   ObserverContainer::iterator match ( find(mObservers.begin(), mObservers.end(), &observer) );
 634
 635   if ( match != mObservers.end() )
 636   {
 637     mObservers.erase( match );
 638   }
 639 }
 640
 641 void Adaptor::QueueCoreEvent(const Dali::Integration::Event& event)
 642 {
 643   if( mCore )
 644   {
 645     mCore->QueueEvent(event);
 646   }
 647 }
 648
 649 void Adaptor::ProcessCoreEvents()
 650 {
 651   if( mCore )
 652   {
 653     if( mPerformanceInterface )
 654     {
 655       mPerformanceInterface->AddMarker( PerformanceInterface::PROCESS_EVENTS_START );
 656     }
 657
 658     mCore->ProcessEvents();
 659
 660     if( mPerformanceInterface )
 661     {
 662       mPerformanceInterface->AddMarker( PerformanceInterface::PROCESS_EVENTS_END );
 663     }
 664   }
 665 }
 666
 667 void Adaptor::RequestUpdate()
 668 {
 669   // When Dali applications are partially visible behind the lock-screen,
 670   // the indicator must be updated (therefore allow updates in the PAUSED state)
 671   if ( PAUSED  == mState ||
 672        RUNNING == mState )
 673   {
 674     mThreadController->RequestUpdate();
 675   }
 676 }
 677
 678 void Adaptor::RequestProcessEventsOnIdle()
 679 {
 680   // Only request a notification if the Adaptor is actually running
 681   // and we haven't installed the idle notification
 682   if( ( ! mNotificationOnIdleInstalled ) && ( RUNNING == mState ) )
 683   {
 684     mNotificationOnIdleInstalled = AddIdle( MakeCallback( this, &Adaptor::ProcessCoreEventsFromIdle ) );
 685   }
 686 }
 687
 688 void Adaptor::OnWindowShown()
 689 {
 690   if ( PAUSED_WHILE_HIDDEN == mState )
 691   {
 692     // Adaptor can now be resumed
 693     mState = PAUSED;
 694
 695     Resume();
 696
 697     // Force a render task
 698     RequestUpdateOnce();
 699   }
 700 }
 701
 702 void Adaptor::OnWindowHidden()
 703 {
 704   if ( STOPPED != mState )
 705   {
 706     Pause();
 707
 708     // Adaptor cannot be resumed until the window is shown
 709     mState = PAUSED_WHILE_HIDDEN;
 710   }
 711 }
 712
 713 // Dali::Internal::Adaptor::Adaptor::OnDamaged
 714 void Adaptor::OnDamaged( const DamageArea& area )
 715 {
 716   // This is needed for the case where Dali window is partially obscured
 717   RequestUpdate();
 718 }
 719
 720 void Adaptor::SurfaceSizeChanged(const PositionSize& positionSize)
 721 {
 722   // let the core know the surface size has changed
 723   mCore->SurfaceResized(positionSize.width, positionSize.height);
 724
 725   mResizedSignal.Emit( mAdaptor );
 726 }
 727
 728 void Adaptor::NotifySceneCreated()
 729 {
 730   GetCore().SceneCreated();
 731
 732   // Start thread controller after the scene has been created
 733   mThreadController->Start();
 734 }
 735
 736 void Adaptor::NotifyLanguageChanged()
 737 {
 738   mLanguageChangedSignal.Emit( mAdaptor );
 739 }
 740
 741 void Adaptor::RequestUpdateOnce()
 742 {
 743   if( PAUSED_WHILE_HIDDEN != mState )
 744   {
 745     if( mThreadController )
 746     {
 747       mThreadController->RequestUpdateOnce();
 748     }
 749   }
 750 }
 751
 752 void Adaptor::ProcessCoreEventsFromIdle()
 753 {
 754   ProcessCoreEvents();
 755
 756   // the idle handle automatically un-installs itself
 757   mNotificationOnIdleInstalled = false;
 758 }
 759
 760 Adaptor::Adaptor(Any nativeWindow, Dali::Adaptor& adaptor, RenderSurface* surface, EnvironmentOptions* environmentOptions)
 761 : mResizedSignal(),
 762   mLanguageChangedSignal(),
 763   mAdaptor(adaptor),
 764   mState(READY),
 765   mCore(NULL),
 766   mThreadController(NULL),
 767   mVSyncMonitor(NULL),
 768   mGLES( NULL ),
 769   mEglFactory( NULL ),
 770   mNativeWindow( nativeWindow ),
 771   mSurface( surface ),
 772   mPlatformAbstraction( NULL ),
 773   mEventHandler( NULL ),
 774   mCallbackManager( NULL ),
 775   mNotificationOnIdleInstalled( false ),
 776   mNotificationTrigger(NULL),
 777   mGestureManager(NULL),
 778   mObservers(),
 779   mDragAndDropDetector(),
 780   mDeferredRotationObserver(NULL),
 781   mEnvironmentOptions( environmentOptions ? environmentOptions : new EnvironmentOptions /* Create the options if not provided */),
 782   mPerformanceInterface(NULL),
 783   mObjectProfiler(NULL),
 784   mEnvironmentOptionsOwned( environmentOptions ? false : true /* If not provided then we own the object */ )
 785 {
 786   DALI_ASSERT_ALWAYS( !IsAvailable() && "Cannot create more than one Adaptor per thread" );
 787   gThreadLocalAdaptor = this;
 788 }
 789
 790 // Stereoscopy
 791
 792 void Adaptor::SetViewMode( ViewMode viewMode )
 793 {
 794   mSurface->SetViewMode( viewMode );
 795   mCore->SetViewMode( viewMode );
 796 }
 797
 798 ViewMode Adaptor::GetViewMode() const
 799 {
 800   return mCore->GetViewMode();
 801 }
 802
 803 void Adaptor::SetStereoBase( float stereoBase )
 804 {
 805   mCore->SetStereoBase( stereoBase );
 806 }
 807
 808 float Adaptor::GetStereoBase() const
 809 {
 810   return mCore->GetStereoBase();
 811 }
 812
 813 } // namespace Adaptor
 814
 815 } // namespace Internal
 816
 817 } // namespace Dali