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   using LocaleChangedSignalType = Dali::Adaptor::LocaleChangedSignalType;
 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);
 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    * @brief Increase surface resize completed counter.
 433    * This API will be ignored if thread controller is not exist.
 434    */
 435   void IncreaseSurfaceResizeCounter();
 436
 437   /**
 438    * Sets layout direction of root by system language
 439    * @param[in] locale System locale
 440    */
 441   void SetRootLayoutDirection(std::string locale);
 442
 443   /**
 444    * @copydoc Dali::Adaptor::RenderOnce
 445    */
 446   void RenderOnce();
 447
 448   /**
 449    * @copydoc Dali::Adaptor::GetLogFactory
 450    */
 451   const LogFactoryInterface& GetLogFactory();
 452
 453   /**
 454    * @copydoc Dali::Adaptor::GetTraceFactory
 455    */
 456   const TraceFactoryInterface& GetTraceFactory();
 457
 458   /**
 459    * @copydoc Dali::Adaptor::RegisterProcessor
 460    */
 461   void RegisterProcessor(Integration::Processor& processor, bool postProcessor);
 462
 463   /**
 464    * @coydoc Dali::Adaptor::UnregisterProcessor
 465    */
 466   void UnregisterProcessor(Integration::Processor& processor, bool postProcessor);
 467
 468   /**
 469    * Check MultipleWindow is supported
 470    */
 471   bool IsMultipleWindowSupported() const;
 472
 473   /**
 474    * @brief Gets the render thread id of DALi.
 475    * @note If render thread id getter doesn't supported, it will return 0 as default.
 476    * @return The render thread id.
 477    */
 478   int32_t GetRenderThreadId() const;
 479
 480 public: //AdaptorInternalServices
 481   /**
 482    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetPlatformAbstractionInterface()
 483    */
 484   Dali::Integration::PlatformAbstraction& GetPlatformAbstractionInterface() override;
 485
 486   /**
 487    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetDisplayConnectionInterface()
 488    */
 489   Dali::DisplayConnection& GetDisplayConnectionInterface() override;
 490
 491   /**
 492    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetGraphicsInterface()
 493    */
 494   GraphicsInterface& GetGraphicsInterface() override;
 495
 496   /**
 497    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetTriggerEventInterface()
 498    */
 499   TriggerEventInterface& GetProcessCoreEventsTrigger() override;
 500
 501   /**
 502    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetSocketFactoryInterface()
 503    */
 504   SocketFactoryInterface& GetSocketFactoryInterface() override;
 505
 506   /**
 507    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetRenderSurfaceInterface()
 508    */
 509   Dali::RenderSurfaceInterface* GetRenderSurfaceInterface() override;
 510
 511   /**
 512    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetPerformanceInterface()
 513    */
 514   PerformanceInterface* GetPerformanceInterface() override;
 515
 516   /**
 517    * copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetKernelTraceInterface()
 518    */
 519   TraceInterface& GetKernelTraceInterface() override;
 520
 521   /**
 522    * copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetSystemTraceInterface()
 523    */
 524   TraceInterface& GetSystemTraceInterface() override;
 525
 526   /**
 527    * copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetWindowContainerInterface()
 528    */
 529   void GetWindowContainerInterface(WindowContainer& windows) override;
 530
 531   /**
 532    * copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetTextureUploadManager()
 533    */
 534   Devel::TextureUploadManager& GetTextureUploadManager() override;
 535
 536   /**
 537    * @brief Get the configuration manager
 538    * @return The configuration manager, or null if it hasn't been created yet
 539    */
 540   const ConfigurationManager* GetConfigurationManager() const
 541   {
 542     return mConfigurationManager.get();
 543   }
 544
 545 public: // Signals
 546   /**
 547    * @copydoc Dali::Adaptor::SignalResized
 548    */
 549   AdaptorSignalType& ResizedSignal()
 550   {
 551     return mResizedSignal;
 552   }
 553
 554   /**
 555    * @copydoc Dali::Adaptor::LanguageChangedSignal
 556    */
 557   AdaptorSignalType& LanguageChangedSignal()
 558   {
 559     return mLanguageChangedSignal;
 560   }
 561
 562   /**
 563    * @copydoc Dali::Adaptor::WindowCreatedSignal
 564    */
 565   WindowCreatedSignalType& WindowCreatedSignal()
 566   {
 567     return mWindowCreatedSignal;
 568   }
 569
 570   /**
 571    * @copydoc Dali::Adaptor::LocaleChangedSignal
 572    */
 573   LocaleChangedSignalType& LocaleChangedSignal()
 574   {
 575     return mLocaleChangedSignal;
 576   }
 577
 578 public: // From Dali::Internal::Adaptor::CoreEventInterface
 579   /**
 580    * @copydoc Dali::Internal::Adaptor::CoreEventInterface:::FlushUpdateMessages()
 581    */
 582   void FlushUpdateMessages() override;
 583
 584   /**
 585    * @copydoc Dali::Internal::Adaptor::CoreEventInterface:::ProcessCoreEvents()
 586    */
 587   void ProcessCoreEvents() override;
 588
 589 private: // From Dali::Internal::Adaptor::CoreEventInterface
 590   /**
 591    * @copydoc Dali::Internal::Adaptor::CoreEventInterface::QueueCoreEvent()
 592    */
 593   void QueueCoreEvent(const Dali::Integration::Event& event) override;
 594
 595 public: // From Dali::Integration::RenderController
 596   /**
 597    * @copydoc Dali::Integration::RenderController::RequestUpdate()
 598    */
 599   void RequestUpdate() override;
 600
 601   /**
 602    * @copydoc Dali::Integration::RenderController::RequestProcessEventsOnIdle()
 603    */
 604   void RequestProcessEventsOnIdle() override;
 605
 606 public: // From Dali::Internal::Adaptor::WindowVisibilityObserver
 607   /**
 608    * Called when the window becomes fully or partially visible.
 609    */
 610   void OnWindowShown() override;
 611
 612   /**
 613    * Called when the window is fully hidden.
 614    */
 615   void OnWindowHidden() override;
 616
 617 private: // From Dali::Internal::Adaptor::DamageObserver
 618   /**
 619    * @copydoc Dali::Internal::Adaptor::DamageObserver::OnDamaged()
 620    */
 621   void OnDamaged(const DamageArea& area) override;
 622
 623 private:
 624   // Undefined
 625   Adaptor(const Adaptor&) = delete;
 626   Adaptor& operator=(Adaptor&) = delete;
 627
 628 private:
 629   /**
 630    * Assigns the render surface to the adaptor
 631    *
 632    */
 633   void SetSurface(Dali::RenderSurfaceInterface* surface);
 634
 635   /**
 636    * called after surface is created
 637    */
 638   void SurfaceInitialized();
 639
 640   /**
 641    * Sends an notification message from main loop idle handler
 642    */
 643   bool ProcessCoreEventsFromIdle();
 644
 645   /**
 646    * Gets path for data/resource storage.
 647    * @param[out] path Path for data/resource storage
 648    */
 649   void GetDataStoragePath(std::string& path);
 650
 651   /**
 652    * Sets up system information if needs
 653    */
 654   void SetupSystemInformation();
 655
 656   /**
 657    * Remove system information if needs
 658    */
 659   void RemoveSystemInformation();
 660
 661   /**
 662    * Adds a callback to be run when entering an idle state.
 663    *
 664    * A callback of the following type should be used:
 665    * @code
 666    *   bool MyFunction();
 667    * @endcode
 668    * This callback will be called repeatedly as long as it returns true. A return of 0 deletes this callback.
 669    */
 670   bool AddIdleEnterer(CallbackBase* callback);
 671
 672   /**
 673    * Removes a previously added the idle enterer callback.
 674    */
 675   void RemoveIdleEnterer(CallbackBase* callback);
 676
 677   /**
 678    * Trigger to log the memory pools from Core and Adaptor
 679    */
 680   bool MemoryPoolTimeout();
 681
 682 private:
 683   /**
 684    * Constructor
 685    * @param[in]  window       window handle
 686    * @param[in]  adaptor      The public adaptor
 687    * @param[in]  surface      A render surface can be one of the following
 688    *                          - Pixmap, adaptor will use existing Pixmap to draw on to
 689    *                          - Window, adaptor will use existing Window to draw on to
 690    * @param[in]  environmentOptions  A pointer to the environment options. If NULL then one is created.
 691    * @param[in]  threadMode   The ThreadMode of the Adaptor
 692    */
 693   Adaptor(Dali::Integration::SceneHolder window, Dali::Adaptor& adaptor, Dali::RenderSurfaceInterface* surface, EnvironmentOptions* environmentOptions, ThreadMode threadMode);
 694
 695 private: // Types
 696   enum State
 697   {
 698     READY,                     ///< Initial state before Adaptor::Start is called.
 699     RUNNING,                   ///< Adaptor is running.
 700     PAUSED,                    ///< Adaptor has been paused.
 701     PAUSED_WHILE_HIDDEN,       ///< Adaptor is paused while window is hidden (& cannot be resumed until window is shown).
 702     PAUSED_WHILE_INITIALIZING, ///< Adaptor is paused while application is initializing.
 703     STOPPED,                   ///< Adaptor has been stopped.
 704   };
 705
 706   // There is no weak handle for BaseHandle in DALi, but we can't ref count the window here,
 707   // so we have to store the raw pointer.
 708   using WindowContainer   = std::vector<Dali::Internal::Adaptor::SceneHolder*>;
 709   using ObserverContainer = std::vector<LifeCycleObserver*>;
 710
 711 private:                                          // Data
 712   AdaptorSignalType       mResizedSignal;         ///< Resized signal.
 713   AdaptorSignalType       mLanguageChangedSignal; ///< Language changed signal.
 714   WindowCreatedSignalType mWindowCreatedSignal;   ///< Window created signal.
 715   LocaleChangedSignalType mLocaleChangedSignal;   ///< Locale changed signal.
 716
 717   Dali::Adaptor&           mAdaptor;          ///< Reference to public adaptor instance.
 718   State                    mState;            ///< Current state of the adaptor
 719   Dali::Integration::Core* mCore;             ///< Dali Core
 720   ThreadController*        mThreadController; ///< Controls the threads
 721
 722   std::unique_ptr<GraphicsInterface> mGraphics;          ///< Graphics interface
 723   Dali::DisplayConnection*           mDisplayConnection; ///< Display connection
 724   WindowContainer                    mWindows;           ///< A container of all the Windows that are currently created
 725
 726   std::unique_ptr<ConfigurationManager> mConfigurationManager; ///< Configuration manager
 727
 728   TizenPlatform::TizenPlatformAbstraction* mPlatformAbstraction; ///< Platform abstraction
 729
 730   std::unique_ptr<CallbackManager> mCallbackManager;                       ///< Used to install callbacks
 731   bool                             mNotificationOnIdleInstalled;           ///< whether the idle handler is installed to send an notification event
 732   bool                             mRequiredIdleRepeat;                    ///< whether we need to repeat installed notification event in idle handler
 733   TriggerEventInterface*           mNotificationTrigger;                   ///< Notification event trigger
 734   FeedbackPluginProxy*             mDaliFeedbackPlugin;                    ///< Used to access feedback support
 735   FeedbackController*              mFeedbackController;                    ///< Plays feedback effects for Dali-Toolkit UI Controls.
 736   Dali::TtsPlayer                  mTtsPlayers[Dali::TtsPlayer::MODE_NUM]; ///< Provides TTS support
 737   ObserverContainer                mObservers;                             ///< A list of adaptor observer pointers
 738   EnvironmentOptions*              mEnvironmentOptions;                    ///< environment options
 739   PerformanceInterface*            mPerformanceInterface;                  ///< Performance interface
 740   KernelTrace                      mKernelTracer;                          ///< Kernel tracer
 741   SystemTrace                      mSystemTracer;                          ///< System tracer
 742   Devel::TextureUploadManager      mTextureUploadManager;                  ///< TextureUploadManager
 743   ObjectProfiler*                  mObjectProfiler;                        ///< Tracks object lifetime for profiling
 744   Dali::Timer                      mMemoryPoolTimer;                       ///< Logs memory pool capacity
 745   SlotDelegate<Adaptor>            mMemoryPoolTimerSlotDelegate;
 746   SocketFactory                    mSocketFactory;               ///< Socket factory
 747   Mutex                            mMutex;                       ///< Mutex
 748   ThreadMode                       mThreadMode;                  ///< The thread mode
 749   const bool                       mEnvironmentOptionsOwned : 1; ///< Whether we own the EnvironmentOptions (and thus, need to delete it)
 750   bool                             mUseRemoteSurface : 1;        ///< whether the remoteSurface is used or not
 751   Dali::LayoutDirection::Type      mRootLayoutDirection;         ///< LayoutDirection of window
 752
 753   std::unique_ptr<Integration::AddOnManager> mAddOnManager; ///< Pointer to the addon manager
 754
 755   class AccessibilityObserver : public ConnectionTracker
 756   {
 757   public:
 758     void OnAccessibleKeyEvent(const Dali::KeyEvent& event);
 759   };
 760   AccessibilityObserver mAccessibilityObserver;
 761
 762 public:
 763   inline static Adaptor& GetImplementation(Dali::Adaptor& adaptor)
 764   {
 765     return *adaptor.mImpl;
 766   }
 767 };
 768
 769 } // namespace Adaptor
 770
 771 } // namespace Internal
 772
 773 } // namespace Dali
 774
 775 #endif // DALI_INTERNAL_ADAPTOR_IMPL_H