dali/internal/adaptor/common/adaptor-impl.h

   1 #ifndef DALI_INTERNAL_ADAPTOR_IMPL_H
   2 #define DALI_INTERNAL_ADAPTOR_IMPL_H
   3
   4 /*
   5  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/devel-api/threading/mutex.h>
  23 #include <dali/integration-api/render-controller.h>
  24 #include <dali/public-api/common/vector-wrapper.h>
  25 #include <dali/public-api/math/rect.h>
  26 #include <dali/public-api/math/uint-16-pair.h>
  27 #include <dali/public-api/signals/callback.h>
  28
  29 // INTERNAL INCLUDES
  30 #include <dali/devel-api/adaptor-framework/clipboard.h>
  31 #include <dali/integration-api/adaptor-framework/adaptor.h>
  32 #include <dali/integration-api/adaptor-framework/scene-holder-impl.h>
  33 #include <dali/integration-api/adaptor-framework/trigger-event-factory.h>
  34 #include <dali/integration-api/scene.h>
  35 #include <dali/internal/adaptor/common/adaptor-internal-services.h>
  36 #include <dali/internal/graphics/common/graphics-interface.h>
  37 #include <dali/internal/legacy/common/tizen-platform-abstraction.h>
  38 #include <dali/internal/network/common/socket-factory.h>
  39 #include <dali/internal/system/common/core-event-interface.h>
  40 #include <dali/internal/system/common/environment-options.h>
  41 #include <dali/internal/system/common/kernel-trace.h>
  42 #include <dali/internal/system/common/system-trace.h>
  43 #include <dali/internal/window-system/common/damage-observer.h>
  44 #include <dali/internal/window-system/common/window-visibility-observer.h>
  45 #include <dali/public-api/adaptor-framework/tts-player.h>
  46
  47 #include <string>
  48
  49 namespace Dali
  50 {
  51 class RenderSurfaceInterface;
  52
  53 namespace Accessibility
  54 {
  55 class Bridge;
  56 }
  57
  58 namespace Integration
  59 {
  60 class Core;
  61 class GlAbstraction;
  62 class Processor;
  63 class AddOnManager;
  64 } // namespace Integration
  65
  66 namespace Internal
  67 {
  68 namespace Adaptor
  69 {
  70 class DisplayConnection;
  71 class GraphicsFactory;
  72 class GlImplementation;
  73 class GlSyncImplementation;
  74 class ThreadController;
  75 class TriggerEvent;
  76 class CallbackManager;
  77 class FeedbackPluginProxy;
  78 class FeedbackController;
  79 class VSyncMonitor;
  80 class PerformanceInterface;
  81 class LifeCycleObserver;
  82 class ObjectProfiler;
  83 class SceneHolder;
  84 class ConfigurationManager;
  85 enum class ThreadMode;
  86
  87 /**
  88  * Implementation of the Adaptor class.
  89  */
  90 class Adaptor : public Integration::RenderController,
  91                 public AdaptorInternalServices,
  92                 public CoreEventInterface,
  93                 public DamageObserver,
  94                 public WindowVisibilityObserver
  95 {
  96 public:
  97   using AdaptorSignalType       = Dali::Adaptor::AdaptorSignalType;
  98   using WindowCreatedSignalType = Dali::Adaptor::WindowCreatedSignalType;
  99
 100   using SurfaceSize = Uint16Pair; ///< Surface size type
 101
 102   /**
 103    * Creates a New Adaptor
 104    * @param[in]  window              The window handle
 105    * @param[in]  surface             A render surface can be one of the following
 106    *                                  - Pixmap, adaptor will use existing Pixmap to draw on to
 107    *                                  - Window, adaptor will use existing Window to draw on to
 108    * @param[in]  environmentOptions  A pointer to the environment options. If NULL then one is created.
 109    * @param[in]  threadMode          The thread mode
 110    */
 111   static Dali::Adaptor* New(Dali::Integration::SceneHolder window,
 112                             Dali::RenderSurfaceInterface*  surface,
 113                             EnvironmentOptions*            environmentOptions,
 114                             ThreadMode                     threadMode);
 115
 116   /**
 117    * Creates a New Adaptor
 118    * @param[in]  window              The window handle
 119    * @param[in]  environmentOptions  A pointer to the environment options. If NULL then one is created.
 120    */
 121   static Dali::Adaptor* New(Dali::Integration::SceneHolder window,
 122                             EnvironmentOptions*            environmentOptions);
 123
 124   /**
 125    * Creates a New Adaptor
 126    * @param[in]  graphicsFactory     A factory that creates the graphics interface
 127    * @param[in]  window              The window handle
 128    * @param[in]  surface             A render surface can be one of the following
 129    *                                  - Pixmap, adaptor will use existing Pixmap to draw on to
 130    *                                  - Window, adaptor will use existing Window to draw on to
 131    * @param[in]  environmentOptions  A pointer to the environment options. If NULL then one is created.
 132    * @param[in]  threadMode          The thread mode
 133    */
 134   static Dali::Adaptor* New(GraphicsFactory&               graphicsFactory,
 135                             Dali::Integration::SceneHolder window,
 136                             Dali::RenderSurfaceInterface*  surface,
 137                             EnvironmentOptions*            environmentOptions,
 138                             ThreadMode                     threadMode);
 139
 140   /**
 141    * Creates a New Adaptor
 142    * @param[in]  graphicsFactory     A factory that creates the graphics interface
 143    * @param[in]  window              The window handle
 144    * @param[in]  environmentOptions  A pointer to the environment options. If NULL then one is created.
 145    */
 146   static Dali::Adaptor* New(GraphicsFactory&               graphicsFactory,
 147                             Dali::Integration::SceneHolder window,
 148                             EnvironmentOptions*            environmentOptions);
 149
 150   /**
 151    * 2-step initialisation, this should be called after creating an adaptor instance.
 152    * @param[in]  graphicsFactory     A factory that creates the graphics interface
 153    */
 154   void Initialize(GraphicsFactory& graphicsFactory);
 155
 156   /**
 157    * Virtual destructor.
 158    */
 159   ~Adaptor() override;
 160
 161   /**
 162    * @copydoc Dali::Adaptor::Get()
 163    */
 164   static Dali::Adaptor& Get();
 165
 166   /**
 167    * @copydoc Dali::Adaptor::IsAvailable()
 168    */
 169   static bool IsAvailable();
 170
 171   /**
 172    * @copydoc Dali::Core::SceneCreated();
 173    */
 174   void SceneCreated();
 175
 176   static std::string GetApplicationPackageName();
 177
 178 public: // AdaptorInternalServices implementation
 179   /**
 180    * @copydoc Dali::Adaptor::Start()
 181    */
 182   virtual void Start();
 183
 184   /**
 185    * @copydoc Dali::Adaptor::Pause()
 186    */
 187   virtual void Pause();
 188
 189   /**
 190    * @copydoc Dali::Adaptor::Resume()
 191    */
 192   virtual void Resume();
 193
 194   /**
 195    * @copydoc Dali::Adaptor::Stop()
 196    */
 197   virtual void Stop();
 198
 199   /**
 200    * @copydoc Dali::Adaptor::ContextLost()
 201    */
 202   virtual void ContextLost();
 203
 204   /**
 205    * @copydoc Dali::Adaptor::ContextRegained()
 206    */
 207   virtual void ContextRegained();
 208
 209   /**
 210    * @copydoc Dali::EventFeeder::FeedTouchPoint()
 211    */
 212   virtual void FeedTouchPoint(TouchPoint& point, int timeStamp);
 213
 214   /**
 215    * @copydoc Dali::EventFeeder::FeedWheelEvent()
 216    */
 217   virtual void FeedWheelEvent(Dali::WheelEvent& wheelEvent);
 218
 219   /**
 220    * @copydoc Dali::EventFeeder::FeedKeyEvent()
 221    */
 222   virtual void FeedKeyEvent(Dali::KeyEvent& keyEvent);
 223
 224   /**
 225    * @copydoc Dali::Adaptor::ReplaceSurface()
 226    */
 227   virtual void ReplaceSurface(Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface& surface);
 228
 229   /**
 230    * @copydoc Dali::Adaptor::GetSurface()
 231    */
 232   virtual Dali::RenderSurfaceInterface& GetSurface() const;
 233
 234   /**
 235    * @copydoc Dali::Adaptor::ReleaseSurfaceLock()
 236    */
 237   virtual void ReleaseSurfaceLock();
 238
 239   /**
 240    * Retrieve the TtsPlayer.
 241    * @param[in] mode The mode of TtsPlayer
 242    * @return A handle to the TtsPlayer.
 243    */
 244   virtual Dali::TtsPlayer GetTtsPlayer(Dali::TtsPlayer::Mode mode);
 245
 246   /**
 247    * @copydoc Dali::Adaptor::AddIdle()
 248    */
 249   virtual bool AddIdle(CallbackBase* callback, bool hasReturnValue, bool forceAdd);
 250
 251   /**
 252    * Adds a new Window instance to the Adaptor
 253    * @param[in]  childWindow The child window instance
 254    */
 255   virtual bool AddWindow(Dali::Integration::SceneHolder childWindow);
 256
 257   /**
 258    * Removes an existing Window instance from the Adaptor
 259    * @param[in]  window The Window instance
 260    */
 261   virtual bool RemoveWindow(Dali::Integration::SceneHolder* childWindow);
 262
 263   /**
 264    * Removes an existing Window instance from the Adaptor
 265    * @param[in]  windowName The Window name
 266    * @note If two Windows have the same name, the first one that matches will be removed
 267    */
 268   virtual bool RemoveWindow(std::string childWindowName);
 269
 270   /**
 271    * @copydoc Dali::Adaptor::RemoveIdle()
 272    */
 273   virtual void RemoveIdle(CallbackBase* callback);
 274
 275   /**
 276    * @copydoc Dali::Adaptor::ProcessIdle()
 277    */
 278   virtual void ProcessIdle();
 279
 280   /**
 281    * Sets a pre-render callback.
 282    */
 283   void SetPreRenderCallback(CallbackBase* callback);
 284
 285   /**
 286    * Removes an existing Window instance from the Adaptor
 287    * @param[in]  childWindow The Window instance
 288    */
 289   bool RemoveWindow(Dali::Internal::Adaptor::SceneHolder* childWindow);
 290
 291   /**
 292    * @brief Deletes the rendering surface
 293    * @param[in] surface to delete
 294    */
 295   void DeleteSurface(Dali::RenderSurfaceInterface& surface);
 296
 297   /**
 298    * @brief Retrieve the window that the given actor is added to.
 299    *
 300    * @param[in] actor The actor
 301    * @return The window the actor is added to or a null pointer if the actor is not added to any widnow.
 302    */
 303   Dali::Internal::Adaptor::SceneHolder* GetWindow(Dali::Actor& actor);
 304
 305   /**
 306    * @copydoc Dali::Adaptor::GetWindows()
 307    */
 308   Dali::WindowContainer GetWindows() const;
 309
 310   /**
 311    * @copydoc Dali::Adaptor::GetSceneHolders()
 312    */
 313   Dali::SceneHolderList GetSceneHolders() const;
 314
 315   /**
 316    * @copydoc Dali::Adaptor::GetObjectRegistry()
 317    */
 318   Dali::ObjectRegistry GetObjectRegistry() const;
 319
 320 public:
 321   /**
 322    * @return the Core instance
 323    */
 324   Dali::Integration::Core& GetCore() override;
 325
 326   /**
 327    * @copydoc Dali::Adaptor::SetRenderRefreshRate()
 328    */
 329   void SetRenderRefreshRate(unsigned int numberOfVSyncsPerRender);
 330
 331   /**
 332    * Return the PlatformAbstraction.
 333    * @return The PlatformAbstraction.
 334    */
 335   Integration::PlatformAbstraction& GetPlatformAbstraction() const;
 336
 337   /**
 338    * Destroy the TtsPlayer of specific mode.
 339    * @param[in] mode The mode of TtsPlayer to destroy
 340    */
 341   void DestroyTtsPlayer(Dali::TtsPlayer::Mode mode);
 342
 343   /**
 344    * Gets native window handle
 345    *
 346    * @return native window handle
 347    */
 348   Any GetNativeWindowHandle();
 349
 350   /**
 351    * @brief Retrieve native window handle that the given actor is added to.
 352    *
 353    * @param[in] actor The actor
 354    * @return native window handle
 355    */
 356   Any GetNativeWindowHandle(Dali::Actor actor);
 357
 358   /**
 359    * Get the native display associated with the graphics backend
 360    *
 361    * @return A handle to the native display
 362    */
 363   Any GetGraphicsDisplay();
 364
 365   /**
 366    * Sets use remote surface for Surface output
 367    * @param[in] useRemoteSurface True if the remote surface is used
 368    */
 369   void SetUseRemoteSurface(bool useRemoteSurface);
 370
 371 public:
 372   /**
 373    * Adds an adaptor observer so that we can observe the adaptor's lifetime events.
 374    * @param[in]  observer  The observer.
 375    * @note Observers should remove themselves when they are destroyed.
 376    */
 377   void AddObserver(LifeCycleObserver& observer);
 378
 379   /**
 380    * Removes the observer from the adaptor.
 381    * @param[in]  observer  The observer to remove.
 382    * @note Observers should remove themselves when they are destroyed.
 383    */
 384   void RemoveObserver(LifeCycleObserver& observer);
 385
 386   /**
 387    * Emits the Notification event to the Dali core.
 388    */
 389   void SendNotificationEvent();
 390
 391   /**
 392    * Request adaptor to update once
 393    */
 394   void RequestUpdateOnce();
 395
 396   /**
 397    * @copydoc Dali::Adaptor::NotifySceneCreated()
 398    */
 399   void NotifySceneCreated();
 400
 401   /**
 402    * @copydoc Dali::Adaptor::NotifyLanguageChanged()
 403    */
 404   void NotifyLanguageChanged();
 405
 406   /**
 407    * Gets AppId of current application
 408    */
 409   void GetAppId(std::string& appId);
 410
 411   /**
 412    * Gets path for resource storage.
 413    * @param[out] path Path for resource storage
 414    */
 415   void GetResourceStoragePath(std::string& path);
 416
 417   /**
 418    * @copydoc Dali::Adaptor::SurfaceResizePrepare
 419    */
 420   void SurfaceResizePrepare(Dali::RenderSurfaceInterface* surface, SurfaceSize surfaceSize);
 421
 422   /**
 423    * @copydoc Dali::Adaptor::SurfaceResizeComplete
 424    */
 425   void SurfaceResizeComplete(Dali::RenderSurfaceInterface* surface, SurfaceSize surfaceSize);
 426
 427   /**
 428    * Sets layout direction of root by system language
 429    * @param[in] locale System locale
 430    */
 431   void SetRootLayoutDirection(std::string locale);
 432
 433   /**
 434    * @copydoc Dali::Adaptor::RenderOnce
 435    */
 436   void RenderOnce();
 437
 438   /**
 439    * @copydoc Dali::Adaptor::GetLogFactory
 440    */
 441   const LogFactoryInterface& GetLogFactory();
 442
 443   /**
 444    * @copydoc Dali::Adaptor::RegisterProcessor
 445    */
 446   void RegisterProcessor(Integration::Processor& processor, bool postProcessor);
 447
 448   /**
 449    * @coydoc Dali::Adaptor::UnregisterProcessor
 450    */
 451   void UnregisterProcessor(Integration::Processor& processor, bool postProcessor);
 452
 453   /**
 454    * Check MultipleWindow is supported
 455    */
 456   bool IsMultipleWindowSupported() const;
 457
 458 public: //AdaptorInternalServices
 459   /**
 460    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetPlatformAbstractionInterface()
 461    */
 462   Dali::Integration::PlatformAbstraction& GetPlatformAbstractionInterface() override;
 463
 464   /**
 465    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetDisplayConnectionInterface()
 466    */
 467   Dali::DisplayConnection& GetDisplayConnectionInterface() override;
 468
 469   /**
 470    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetGraphicsInterface()
 471    */
 472   GraphicsInterface& GetGraphicsInterface() override;
 473
 474   /**
 475    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetTriggerEventInterface()
 476    */
 477   TriggerEventInterface& GetProcessCoreEventsTrigger() override;
 478
 479   /**
 480    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetSocketFactoryInterface()
 481    */
 482   SocketFactoryInterface& GetSocketFactoryInterface() override;
 483
 484   /**
 485    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetRenderSurfaceInterface()
 486    */
 487   Dali::RenderSurfaceInterface* GetRenderSurfaceInterface() override;
 488
 489   /**
 490    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetPerformanceInterface()
 491    */
 492   PerformanceInterface* GetPerformanceInterface() override;
 493
 494   /**
 495    * copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetKernelTraceInterface()
 496    */
 497   TraceInterface& GetKernelTraceInterface() override;
 498
 499   /**
 500    * copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetSystemTraceInterface()
 501    */
 502   TraceInterface& GetSystemTraceInterface() override;
 503
 504   /**
 505    * copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetWindowContainerInterface()
 506    */
 507   void GetWindowContainerInterface(WindowContainer& windows) override;
 508
 509 public: // Signals
 510   /**
 511    * @copydoc Dali::Adaptor::SignalResized
 512    */
 513   AdaptorSignalType& ResizedSignal()
 514   {
 515     return mResizedSignal;
 516   }
 517
 518   /**
 519    * @copydoc Dali::Adaptor::LanguageChangedSignal
 520    */
 521   AdaptorSignalType& LanguageChangedSignal()
 522   {
 523     return mLanguageChangedSignal;
 524   }
 525
 526   /**
 527    * @copydoc Dali::Adaptor::WindowCreatedSignal
 528    */
 529   WindowCreatedSignalType& WindowCreatedSignal()
 530   {
 531     return mWindowCreatedSignal;
 532   }
 533
 534 public: // From Dali::Internal::Adaptor::CoreEventInterface
 535   /**
 536    * @copydoc Dali::Internal::Adaptor:CoreEventInterface:::ProcessCoreEvents()
 537    */
 538   void ProcessCoreEvents() override;
 539
 540 private: // From Dali::Internal::Adaptor::CoreEventInterface
 541   /**
 542    * @copydoc Dali::Internal::Adaptor::CoreEventInterface::QueueCoreEvent()
 543    */
 544   void QueueCoreEvent(const Dali::Integration::Event& event) override;
 545
 546 private: // From Dali::Integration::RenderController
 547   /**
 548    * @copydoc Dali::Integration::RenderController::RequestUpdate()
 549    */
 550   void RequestUpdate(bool forceUpdate) override;
 551
 552   /**
 553    * @copydoc Dali::Integration::RenderController::RequestProcessEventsOnIdle()
 554    */
 555   void RequestProcessEventsOnIdle(bool forceProcess) override;
 556
 557 public: // From Dali::Internal::Adaptor::WindowVisibilityObserver
 558   /**
 559    * Called when the window becomes fully or partially visible.
 560    */
 561   void OnWindowShown() override;
 562
 563   /**
 564    * Called when the window is fully hidden.
 565    */
 566   void OnWindowHidden() override;
 567
 568 private: // From Dali::Internal::Adaptor::DamageObserver
 569   /**
 570    * @copydoc Dali::Internal::Adaptor::DamageObserver::OnDamaged()
 571    */
 572   void OnDamaged(const DamageArea& area) override;
 573
 574 private:
 575   // Undefined
 576   Adaptor(const Adaptor&) = delete;
 577   Adaptor& operator=(Adaptor&) = delete;
 578
 579 private:
 580   /**
 581    * Assigns the render surface to the adaptor
 582    *
 583    */
 584   void SetSurface(Dali::RenderSurfaceInterface* surface);
 585
 586   /**
 587    * called after surface is created
 588    */
 589   void SurfaceInitialized();
 590
 591   /**
 592    * Sends an notification message from main loop idle handler
 593    */
 594   bool ProcessCoreEventsFromIdle();
 595
 596   /**
 597    * Gets path for data/resource storage.
 598    * @param[out] path Path for data/resource storage
 599    */
 600   void GetDataStoragePath(std::string& path);
 601
 602   /**
 603    * Sets up system information if needs
 604    */
 605   void SetupSystemInformation();
 606
 607   /**
 608    * Adds a callback to be run when entering an idle state.
 609    *
 610    * A callback of the following type should be used:
 611    * @code
 612    *   bool MyFunction();
 613    * @endcode
 614    * This callback will be called repeatedly as long as it returns true. A return of 0 deletes this callback.
 615    */
 616   bool AddIdleEnterer(CallbackBase* callback, bool forceAdd);
 617
 618   /**
 619    * Removes a previously added the idle enterer callback.
 620    */
 621   void RemoveIdleEnterer(CallbackBase* callback);
 622
 623 private:
 624   /**
 625    * Constructor
 626    * @param[in]  window       window handle
 627    * @param[in]  adaptor      The public adaptor
 628    * @param[in]  surface      A render surface can be one of the following
 629    *                          - Pixmap, adaptor will use existing Pixmap to draw on to
 630    *                          - Window, adaptor will use existing Window to draw on to
 631    * @param[in]  environmentOptions  A pointer to the environment options. If NULL then one is created.
 632    * @param[in]  threadMode   The ThreadMode of the Adaptor
 633    */
 634   Adaptor(Dali::Integration::SceneHolder window, Dali::Adaptor& adaptor, Dali::RenderSurfaceInterface* surface, EnvironmentOptions* environmentOptions, ThreadMode threadMode);
 635
 636 private: // Types
 637   enum State
 638   {
 639     READY,                     ///< Initial state before Adaptor::Start is called.
 640     RUNNING,                   ///< Adaptor is running.
 641     PAUSED,                    ///< Adaptor has been paused.
 642     PAUSED_WHILE_HIDDEN,       ///< Adaptor is paused while window is hidden (& cannot be resumed until window is shown).
 643     PAUSED_WHILE_INITIALIZING, ///< Adaptor is paused while application is initializing.
 644     STOPPED,                   ///< Adaptor has been stopped.
 645   };
 646
 647   // There is no weak handle for BaseHandle in DALi, but we can't ref count the window here,
 648   // so we have to store the raw pointer.
 649   using WindowContainer   = std::vector<Dali::Internal::Adaptor::SceneHolder*>;
 650   using ObserverContainer = std::vector<LifeCycleObserver*>;
 651
 652 private:                                          // Data
 653   AdaptorSignalType       mResizedSignal;         ///< Resized signal.
 654   AdaptorSignalType       mLanguageChangedSignal; ///< Language changed signal.
 655   WindowCreatedSignalType mWindowCreatedSignal;   ///< Window created signal.
 656
 657   Dali::Adaptor&           mAdaptor;          ///< Reference to public adaptor instance.
 658   State                    mState;            ///< Current state of the adaptor
 659   Dali::Integration::Core* mCore;             ///< Dali Core
 660   ThreadController*        mThreadController; ///< Controls the threads
 661
 662   std::unique_ptr<GraphicsInterface> mGraphics;          ///< Graphics interface
 663   Dali::DisplayConnection*           mDisplayConnection; ///< Display connection
 664   WindowContainer                    mWindows;           ///< A container of all the Windows that are currently created
 665
 666   std::unique_ptr<ConfigurationManager> mConfigurationManager; ///< Configuration manager
 667
 668   TizenPlatform::TizenPlatformAbstraction* mPlatformAbstraction; ///< Platform abstraction
 669
 670   CallbackManager*            mCallbackManager;                       ///< Used to install callbacks
 671   bool                        mNotificationOnIdleInstalled;           ///< whether the idle handler is installed to send an notification event
 672   TriggerEventInterface*      mNotificationTrigger;                   ///< Notification event trigger
 673   FeedbackPluginProxy*        mDaliFeedbackPlugin;                    ///< Used to access feedback support
 674   FeedbackController*         mFeedbackController;                    ///< Plays feedback effects for Dali-Toolkit UI Controls.
 675   Dali::TtsPlayer             mTtsPlayers[Dali::TtsPlayer::MODE_NUM]; ///< Provides TTS support
 676   ObserverContainer           mObservers;                             ///< A list of adaptor observer pointers
 677   EnvironmentOptions*         mEnvironmentOptions;                    ///< environment options
 678   PerformanceInterface*       mPerformanceInterface;                  ///< Performance interface
 679   KernelTrace                 mKernelTracer;                          ///< Kernel tracer
 680   SystemTrace                 mSystemTracer;                          ///< System tracer
 681   ObjectProfiler*             mObjectProfiler;                        ///< Tracks object lifetime for profiling
 682   SocketFactory               mSocketFactory;                         ///< Socket factory
 683   Mutex                       mMutex;                                 ///< Mutex
 684   ThreadMode                  mThreadMode;                            ///< The thread mode
 685   const bool                  mEnvironmentOptionsOwned : 1;           ///< Whether we own the EnvironmentOptions (and thus, need to delete it)
 686   bool                        mUseRemoteSurface : 1;                  ///< whether the remoteSurface is used or not
 687   Dali::LayoutDirection::Type mRootLayoutDirection;                   ///< LayoutDirection of window
 688
 689   std::unique_ptr<Integration::AddOnManager> mAddOnManager; ///< Pointer to the addon manager
 690
 691   class AccessibilityObserver : public ConnectionTracker
 692   {
 693   public:
 694     void OnAccessibleKeyEvent(const Dali::KeyEvent& event);
 695   };
 696   AccessibilityObserver mAccessibilityObserver;
 697
 698 public:
 699   inline static Adaptor& GetImplementation(Dali::Adaptor& adaptor)
 700   {
 701     return *adaptor.mImpl;
 702   }
 703 };
 704
 705 } // namespace Adaptor
 706
 707 } // namespace Internal
 708
 709 } // namespace Dali
 710
 711 #endif // DALI_INTERNAL_ADAPTOR_IMPL_H