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