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) 2023 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/adaptor-framework/timer.h>
  25 #include <dali/public-api/common/vector-wrapper.h>
  26 #include <dali/public-api/math/rect.h>
  27 #include <dali/public-api/math/uint-16-pair.h>
  28 #include <dali/public-api/signals/callback.h>
  29
  30 // INTERNAL INCLUDES
  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   /**
 177    * Get the application package name
 178    */
 179   static std::string GetApplicationPackageName();
 180
 181 public: // AdaptorInternalServices implementation
 182   /**
 183    * @copydoc Dali::Adaptor::Start()
 184    */
 185   virtual void Start();
 186
 187   /**
 188    * @copydoc Dali::Adaptor::Pause()
 189    */
 190   virtual void Pause();
 191
 192   /**
 193    * @copydoc Dali::Adaptor::Resume()
 194    */
 195   virtual void Resume();
 196
 197   /**
 198    * @copydoc Dali::Adaptor::Stop()
 199    */
 200   virtual void Stop();
 201
 202   /**
 203    * @copydoc Dali::Adaptor::ContextLost()
 204    */
 205   virtual void ContextLost();
 206
 207   /**
 208    * @copydoc Dali::Adaptor::ContextRegained()
 209    */
 210   virtual void ContextRegained();
 211
 212   /**
 213    * @copydoc Dali::EventFeeder::FeedTouchPoint()
 214    */
 215   virtual void FeedTouchPoint(TouchPoint& point, int timeStamp);
 216
 217   /**
 218    * @copydoc Dali::EventFeeder::FeedWheelEvent()
 219    */
 220   virtual void FeedWheelEvent(Dali::WheelEvent& wheelEvent);
 221
 222   /**
 223    * @copydoc Dali::EventFeeder::FeedKeyEvent()
 224    */
 225   virtual void FeedKeyEvent(Dali::KeyEvent& keyEvent);
 226
 227   /**
 228    * @copydoc Dali::Adaptor::ReplaceSurface()
 229    */
 230   virtual void ReplaceSurface(Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface& surface);
 231
 232   /**
 233    * @copydoc Dali::Adaptor::GetSurface()
 234    */
 235   virtual Dali::RenderSurfaceInterface& GetSurface() const;
 236
 237   /**
 238    * @copydoc Dali::Adaptor::ReleaseSurfaceLock()
 239    */
 240   virtual void ReleaseSurfaceLock();
 241
 242   /**
 243    * Retrieve the TtsPlayer.
 244    * @param[in] mode The mode of TtsPlayer
 245    * @return A handle to the TtsPlayer.
 246    */
 247   virtual Dali::TtsPlayer GetTtsPlayer(Dali::TtsPlayer::Mode mode);
 248
 249   /**
 250    * @copydoc Dali::Adaptor::AddIdle()
 251    */
 252   virtual bool AddIdle(CallbackBase* callback, bool hasReturnValue, bool forceAdd);
 253
 254   /**
 255    * Adds a new Window instance to the Adaptor
 256    * @param[in]  childWindow The child window instance
 257    */
 258   virtual bool AddWindow(Dali::Integration::SceneHolder childWindow);
 259
 260   /**
 261    * Removes an existing Window instance from the Adaptor
 262    * @param[in]  window The Window instance
 263    */
 264   virtual bool RemoveWindow(Dali::Integration::SceneHolder* childWindow);
 265
 266   /**
 267    * Removes an existing Window instance from the Adaptor
 268    * @param[in]  windowName The Window name
 269    * @note If two Windows have the same name, the first one that matches will be removed
 270    */
 271   virtual bool RemoveWindow(std::string childWindowName);
 272
 273   /**
 274    * @copydoc Dali::Adaptor::RemoveIdle()
 275    */
 276   virtual void RemoveIdle(CallbackBase* callback);
 277
 278   /**
 279    * @copydoc Dali::Adaptor::ProcessIdle()
 280    */
 281   virtual void ProcessIdle();
 282
 283   /**
 284    * Sets a pre-render callback.
 285    */
 286   void SetPreRenderCallback(CallbackBase* callback);
 287
 288   /**
 289    * Removes an existing Window instance from the Adaptor
 290    * @param[in]  childWindow The Window instance
 291    */
 292   bool RemoveWindow(Dali::Internal::Adaptor::SceneHolder* childWindow);
 293
 294   /**
 295    * @brief Deletes the rendering surface
 296    * @param[in] surface to delete
 297    */
 298   void DeleteSurface(Dali::RenderSurfaceInterface& surface);
 299
 300   /**
 301    * @brief Retrieve the window that the given actor is added to.
 302    *
 303    * @param[in] actor The actor
 304    * @return The window the actor is added to or a null pointer if the actor is not added to any widnow.
 305    */
 306   Dali::Internal::Adaptor::SceneHolder* GetWindow(Dali::Actor& actor);
 307
 308   /**
 309    * @copydoc Dali::Adaptor::GetWindows()
 310    */
 311   Dali::WindowContainer GetWindows() const;
 312
 313   /**
 314    * @copydoc Dali::Adaptor::GetSceneHolders()
 315    */
 316   Dali::SceneHolderList GetSceneHolders() const;
 317
 318   /**
 319    * @copydoc Dali::Adaptor::GetObjectRegistry()
 320    */
 321   Dali::ObjectRegistry GetObjectRegistry() const;
 322
 323 public:
 324   /**
 325    * @return the Core instance
 326    */
 327   Dali::Integration::Core& GetCore() override;
 328
 329   /**
 330    * @copydoc Dali::Adaptor::SetRenderRefreshRate()
 331    */
 332   void SetRenderRefreshRate(unsigned int numberOfVSyncsPerRender);
 333
 334   /**
 335    * Return the PlatformAbstraction.
 336    * @return The PlatformAbstraction.
 337    */
 338   Integration::PlatformAbstraction& GetPlatformAbstraction() const;
 339
 340   /**
 341    * Destroy the TtsPlayer of specific mode.
 342    * @param[in] mode The mode of TtsPlayer to destroy
 343    */
 344   void DestroyTtsPlayer(Dali::TtsPlayer::Mode mode);
 345
 346   /**
 347    * Gets native window handle
 348    *
 349    * @return native window handle
 350    */
 351   Any GetNativeWindowHandle();
 352
 353   /**
 354    * @brief Retrieve native window handle that the given actor is added to.
 355    *
 356    * @param[in] actor The actor
 357    * @return native window handle
 358    */
 359   Any GetNativeWindowHandle(Dali::Actor actor);
 360
 361   /**
 362    * Get the native display associated with the graphics backend
 363    *
 364    * @return A handle to the native display
 365    */
 366   Any GetGraphicsDisplay();
 367
 368   /**
 369    * Sets use remote surface for Surface output
 370    * @param[in] useRemoteSurface True if the remote surface is used
 371    */
 372   void SetUseRemoteSurface(bool useRemoteSurface);
 373
 374 public:
 375   /**
 376    * Adds an adaptor observer so that we can observe the adaptor's lifetime events.
 377    * @param[in]  observer  The observer.
 378    * @note Observers should remove themselves when they are destroyed.
 379    */
 380   void AddObserver(LifeCycleObserver& observer);
 381
 382   /**
 383    * Removes the observer from the adaptor.
 384    * @param[in]  observer  The observer to remove.
 385    * @note Observers should remove themselves when they are destroyed.
 386    */
 387   void RemoveObserver(LifeCycleObserver& observer);
 388
 389   /**
 390    * Emits the Notification event to the Dali core.
 391    */
 392   void SendNotificationEvent();
 393
 394   /**
 395    * Request adaptor to update once
 396    */
 397   void RequestUpdateOnce();
 398
 399   /**
 400    * @copydoc Dali::Adaptor::NotifySceneCreated()
 401    */
 402   void NotifySceneCreated();
 403
 404   /**
 405    * @copydoc Dali::Adaptor::NotifyLanguageChanged()
 406    */
 407   void NotifyLanguageChanged();
 408
 409   /**
 410    * Gets AppId of current application
 411    */
 412   void GetAppId(std::string& appId);
 413
 414   /**
 415    * Gets path for resource storage.
 416    * @param[out] path Path for resource storage
 417    */
 418   void GetResourceStoragePath(std::string& path);
 419
 420   /**
 421    * @copydoc Dali::Adaptor::SurfaceResizePrepare
 422    */
 423   void SurfaceResizePrepare(Dali::RenderSurfaceInterface* surface, SurfaceSize surfaceSize);
 424
 425   /**
 426    * @copydoc Dali::Adaptor::SurfaceResizeComplete
 427    */
 428   void SurfaceResizeComplete(Dali::RenderSurfaceInterface* surface, SurfaceSize surfaceSize);
 429
 430   /**
 431    * Sets layout direction of root by system language
 432    * @param[in] locale System locale
 433    */
 434   void SetRootLayoutDirection(std::string locale);
 435
 436   /**
 437    * @copydoc Dali::Adaptor::RenderOnce
 438    */
 439   void RenderOnce();
 440
 441   /**
 442    * @copydoc Dali::Adaptor::GetLogFactory
 443    */
 444   const LogFactoryInterface& GetLogFactory();
 445
 446   /**
 447    * @copydoc Dali::Adaptor::GetTraceFactory
 448    */
 449   const TraceFactoryInterface& GetTraceFactory();
 450
 451   /**
 452    * @copydoc Dali::Adaptor::RegisterProcessor
 453    */
 454   void RegisterProcessor(Integration::Processor& processor, bool postProcessor);
 455
 456   /**
 457    * @coydoc Dali::Adaptor::UnregisterProcessor
 458    */
 459   void UnregisterProcessor(Integration::Processor& processor, bool postProcessor);
 460
 461   /**
 462    * Check MultipleWindow is supported
 463    */
 464   bool IsMultipleWindowSupported() const;
 465
 466   /**
 467    * @brief Gets the render thread id of DALi.
 468    * @note If render thread id getter doesn't supported, it will return 0 as default.
 469    * @return The render thread id.
 470    */
 471   int32_t GetRenderThreadId() const;
 472
 473 public: //AdaptorInternalServices
 474   /**
 475    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetPlatformAbstractionInterface()
 476    */
 477   Dali::Integration::PlatformAbstraction& GetPlatformAbstractionInterface() override;
 478
 479   /**
 480    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetDisplayConnectionInterface()
 481    */
 482   Dali::DisplayConnection& GetDisplayConnectionInterface() override;
 483
 484   /**
 485    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetGraphicsInterface()
 486    */
 487   GraphicsInterface& GetGraphicsInterface() override;
 488
 489   /**
 490    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetTriggerEventInterface()
 491    */
 492   TriggerEventInterface& GetProcessCoreEventsTrigger() override;
 493
 494   /**
 495    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetSocketFactoryInterface()
 496    */
 497   SocketFactoryInterface& GetSocketFactoryInterface() override;
 498
 499   /**
 500    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetRenderSurfaceInterface()
 501    */
 502   Dali::RenderSurfaceInterface* GetRenderSurfaceInterface() override;
 503
 504   /**
 505    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetPerformanceInterface()
 506    */
 507   PerformanceInterface* GetPerformanceInterface() override;
 508
 509   /**
 510    * copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetKernelTraceInterface()
 511    */
 512   TraceInterface& GetKernelTraceInterface() override;
 513
 514   /**
 515    * copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetSystemTraceInterface()
 516    */
 517   TraceInterface& GetSystemTraceInterface() override;
 518
 519   /**
 520    * copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetWindowContainerInterface()
 521    */
 522   void GetWindowContainerInterface(WindowContainer& windows) override;
 523
 524   /**
 525    * copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetTextureUploadManager()
 526    */
 527   Devel::TextureUploadManager& GetTextureUploadManager() override;
 528
 529   /**
 530    * @brief Get the configuration manager
 531    * @return The configuration manager, or null if it hasn't been created yet
 532    */
 533   const ConfigurationManager* GetConfigurationManager() const
 534   {
 535     return mConfigurationManager.get();
 536   }
 537
 538 public: // Signals
 539   /**
 540    * @copydoc Dali::Adaptor::SignalResized
 541    */
 542   AdaptorSignalType& ResizedSignal()
 543   {
 544     return mResizedSignal;
 545   }
 546
 547   /**
 548    * @copydoc Dali::Adaptor::LanguageChangedSignal
 549    */
 550   AdaptorSignalType& LanguageChangedSignal()
 551   {
 552     return mLanguageChangedSignal;
 553   }
 554
 555   /**
 556    * @copydoc Dali::Adaptor::WindowCreatedSignal
 557    */
 558   WindowCreatedSignalType& WindowCreatedSignal()
 559   {
 560     return mWindowCreatedSignal;
 561   }
 562
 563 public: // From Dali::Internal::Adaptor::CoreEventInterface
 564   /**
 565    * @copydoc Dali::Internal::Adaptor::CoreEventInterface:::FlushUpdateMessages()
 566    */
 567   void FlushUpdateMessages() override;
 568
 569   /**
 570    * @copydoc Dali::Internal::Adaptor::CoreEventInterface:::ProcessCoreEvents()
 571    */
 572   void ProcessCoreEvents() override;
 573
 574 private: // From Dali::Internal::Adaptor::CoreEventInterface
 575   /**
 576    * @copydoc Dali::Internal::Adaptor::CoreEventInterface::QueueCoreEvent()
 577    */
 578   void QueueCoreEvent(const Dali::Integration::Event& event) override;
 579
 580 private: // From Dali::Integration::RenderController
 581   /**
 582    * @copydoc Dali::Integration::RenderController::RequestUpdate()
 583    */
 584   void RequestUpdate() override;
 585
 586   /**
 587    * @copydoc Dali::Integration::RenderController::RequestProcessEventsOnIdle()
 588    */
 589   void RequestProcessEventsOnIdle() override;
 590
 591 public: // From Dali::Internal::Adaptor::WindowVisibilityObserver
 592   /**
 593    * Called when the window becomes fully or partially visible.
 594    */
 595   void OnWindowShown() override;
 596
 597   /**
 598    * Called when the window is fully hidden.
 599    */
 600   void OnWindowHidden() override;
 601
 602 private: // From Dali::Internal::Adaptor::DamageObserver
 603   /**
 604    * @copydoc Dali::Internal::Adaptor::DamageObserver::OnDamaged()
 605    */
 606   void OnDamaged(const DamageArea& area) override;
 607
 608 private:
 609   // Undefined
 610   Adaptor(const Adaptor&) = delete;
 611   Adaptor& operator=(Adaptor&) = delete;
 612
 613 private:
 614   /**
 615    * Assigns the render surface to the adaptor
 616    *
 617    */
 618   void SetSurface(Dali::RenderSurfaceInterface* surface);
 619
 620   /**
 621    * called after surface is created
 622    */
 623   void SurfaceInitialized();
 624
 625   /**
 626    * Sends an notification message from main loop idle handler
 627    */
 628   bool ProcessCoreEventsFromIdle();
 629
 630   /**
 631    * Gets path for data/resource storage.
 632    * @param[out] path Path for data/resource storage
 633    */
 634   void GetDataStoragePath(std::string& path);
 635
 636   /**
 637    * Sets up system information if needs
 638    */
 639   void SetupSystemInformation();
 640
 641   /**
 642    * Adds a callback to be run when entering an idle state.
 643    *
 644    * A callback of the following type should be used:
 645    * @code
 646    *   bool MyFunction();
 647    * @endcode
 648    * This callback will be called repeatedly as long as it returns true. A return of 0 deletes this callback.
 649    */
 650   bool AddIdleEnterer(CallbackBase* callback, bool forceAdd);
 651
 652   /**
 653    * Removes a previously added the idle enterer callback.
 654    */
 655   void RemoveIdleEnterer(CallbackBase* callback);
 656
 657   /**
 658    * Trigger to log the memory pools from Core and Adaptor
 659    */
 660   bool MemoryPoolTimeout();
 661
 662 private:
 663   /**
 664    * Constructor
 665    * @param[in]  window       window handle
 666    * @param[in]  adaptor      The public adaptor
 667    * @param[in]  surface      A render surface can be one of the following
 668    *                          - Pixmap, adaptor will use existing Pixmap to draw on to
 669    *                          - Window, adaptor will use existing Window to draw on to
 670    * @param[in]  environmentOptions  A pointer to the environment options. If NULL then one is created.
 671    * @param[in]  threadMode   The ThreadMode of the Adaptor
 672    */
 673   Adaptor(Dali::Integration::SceneHolder window, Dali::Adaptor& adaptor, Dali::RenderSurfaceInterface* surface, EnvironmentOptions* environmentOptions, ThreadMode threadMode);
 674
 675 private: // Types
 676   enum State
 677   {
 678     READY,                     ///< Initial state before Adaptor::Start is called.
 679     RUNNING,                   ///< Adaptor is running.
 680     PAUSED,                    ///< Adaptor has been paused.
 681     PAUSED_WHILE_HIDDEN,       ///< Adaptor is paused while window is hidden (& cannot be resumed until window is shown).
 682     PAUSED_WHILE_INITIALIZING, ///< Adaptor is paused while application is initializing.
 683     STOPPED,                   ///< Adaptor has been stopped.
 684   };
 685
 686   // There is no weak handle for BaseHandle in DALi, but we can't ref count the window here,
 687   // so we have to store the raw pointer.
 688   using WindowContainer   = std::vector<Dali::Internal::Adaptor::SceneHolder*>;
 689   using ObserverContainer = std::vector<LifeCycleObserver*>;
 690
 691 private:                                          // Data
 692   AdaptorSignalType       mResizedSignal;         ///< Resized signal.
 693   AdaptorSignalType       mLanguageChangedSignal; ///< Language changed signal.
 694   WindowCreatedSignalType mWindowCreatedSignal;   ///< Window created signal.
 695
 696   Dali::Adaptor&           mAdaptor;          ///< Reference to public adaptor instance.
 697   State                    mState;            ///< Current state of the adaptor
 698   Dali::Integration::Core* mCore;             ///< Dali Core
 699   ThreadController*        mThreadController; ///< Controls the threads
 700
 701   std::unique_ptr<GraphicsInterface> mGraphics;          ///< Graphics interface
 702   Dali::DisplayConnection*           mDisplayConnection; ///< Display connection
 703   WindowContainer                    mWindows;           ///< A container of all the Windows that are currently created
 704
 705   std::unique_ptr<ConfigurationManager> mConfigurationManager; ///< Configuration manager
 706
 707   TizenPlatform::TizenPlatformAbstraction* mPlatformAbstraction; ///< Platform abstraction
 708
 709   std::unique_ptr<CallbackManager> mCallbackManager;                       ///< Used to install callbacks
 710   bool                             mNotificationOnIdleInstalled;           ///< whether the idle handler is installed to send an notification event
 711   bool                             mRequiredIdleRepeat;                    ///< whether we need to repeat installed notification event in idle handler
 712   TriggerEventInterface*           mNotificationTrigger;                   ///< Notification event trigger
 713   FeedbackPluginProxy*             mDaliFeedbackPlugin;                    ///< Used to access feedback support
 714   FeedbackController*              mFeedbackController;                    ///< Plays feedback effects for Dali-Toolkit UI Controls.
 715   Dali::TtsPlayer                  mTtsPlayers[Dali::TtsPlayer::MODE_NUM]; ///< Provides TTS support
 716   ObserverContainer                mObservers;                             ///< A list of adaptor observer pointers
 717   EnvironmentOptions*              mEnvironmentOptions;                    ///< environment options
 718   PerformanceInterface*            mPerformanceInterface;                  ///< Performance interface
 719   KernelTrace                      mKernelTracer;                          ///< Kernel tracer
 720   SystemTrace                      mSystemTracer;                          ///< System tracer
 721   Devel::TextureUploadManager      mTextureUploadManager;                  ///< TextureUploadManager
 722   ObjectProfiler*                  mObjectProfiler;                        ///< Tracks object lifetime for profiling
 723   Dali::Timer                      mMemoryPoolTimer;                       ///< Logs memory pool capacity
 724   SlotDelegate<Adaptor>            mMemoryPoolTimerSlotDelegate;
 725   SocketFactory                    mSocketFactory;               ///< Socket factory
 726   Mutex                            mMutex;                       ///< Mutex
 727   ThreadMode                       mThreadMode;                  ///< The thread mode
 728   const bool                       mEnvironmentOptionsOwned : 1; ///< Whether we own the EnvironmentOptions (and thus, need to delete it)
 729   bool                             mUseRemoteSurface : 1;        ///< whether the remoteSurface is used or not
 730   Dali::LayoutDirection::Type      mRootLayoutDirection;         ///< LayoutDirection of window
 731
 732   std::unique_ptr<Integration::AddOnManager> mAddOnManager; ///< Pointer to the addon manager
 733
 734   class AccessibilityObserver : public ConnectionTracker
 735   {
 736   public:
 737     void OnAccessibleKeyEvent(const Dali::KeyEvent& event);
 738   };
 739   AccessibilityObserver mAccessibilityObserver;
 740
 741 public:
 742   inline static Adaptor& GetImplementation(Dali::Adaptor& adaptor)
 743   {
 744     return *adaptor.mImpl;
 745   }
 746 };
 747
 748 } // namespace Adaptor
 749
 750 } // namespace Internal
 751
 752 } // namespace Dali
 753
 754 #endif // DALI_INTERNAL_ADAPTOR_IMPL_H