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