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) 2018 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/public-api/common/vector-wrapper.h>
  23 #include <dali/public-api/common/view-mode.h>
  24 #include <dali/public-api/math/rect.h>
  25 #include <dali/public-api/signals/callback.h>
  26 #include <dali/public-api/math/uint-16-pair.h>
  27 #include <dali/integration-api/render-controller.h>
  28
  29 // INTERNAL INCLUDES
  30 #include <dali/integration-api/adaptor.h>
  31 #include <dali/public-api/adaptor-framework/tts-player.h>
  32 #include <dali/devel-api/adaptor-framework/clipboard.h>
  33
  34 #include <dali/internal/legacy/common/tizen-platform-abstraction.h>
  35 #include <dali/internal/adaptor/common/adaptor-internal-services.h>
  36 #include <dali/internal/system/common/environment-options.h>
  37 #include <dali/internal/system/common/core-event-interface.h>
  38 #include <dali/internal/input/common/drag-and-drop-detector-impl.h>
  39 #include <dali/internal/window-system/common/damage-observer.h>
  40 #include <dali/internal/window-system/common/window-visibility-observer.h>
  41 #include <dali/internal/system/common/kernel-trace.h>
  42 #include <dali/internal/system/common/system-trace.h>
  43 #include <dali/integration-api/trigger-event-factory.h>
  44 #include <dali/internal/network/common/socket-factory.h>
  45
  46 namespace Dali
  47 {
  48
  49 class RenderSurface;
  50 class Window;
  51
  52 namespace Integration
  53 {
  54 class Core;
  55 class GlAbstraction;
  56 }
  57
  58 namespace Internal
  59 {
  60
  61 namespace Adaptor
  62 {
  63 class EventHandler;
  64 class EglFactory;
  65 class GestureManager;
  66 class GlImplementation;
  67 class GlSyncImplementation;
  68 class ThreadController;
  69 class TriggerEvent;
  70 class CallbackManager;
  71 class FeedbackPluginProxy;
  72 class FeedbackController;
  73 class RotationObserver;
  74 class VSyncMonitor;
  75 class PerformanceInterface;
  76 class LifeCycleObserver;
  77 class ObjectProfiler;
  78
  79 /**
  80  * Implementation of the Adaptor class.
  81  */
  82 class Adaptor : public Integration::RenderController,
  83                 public AdaptorInternalServices,
  84                 public CoreEventInterface,
  85                 public DamageObserver,
  86                 public WindowVisibilityObserver
  87 {
  88 public:
  89
  90   typedef Dali::Adaptor::AdaptorSignalType AdaptorSignalType;
  91
  92   typedef Uint16Pair SurfaceSize;          ///< Surface size type
  93
  94   /**
  95    * Creates a New Adaptor
  96    * @param[in]  nativeWindow        Native window handle
  97    * @param[in]  surface             A render surface can be one of the following
  98    *                                  - Pixmap, adaptor will use existing Pixmap to draw on to
  99    *                                  - Window, adaptor will use existing Window to draw on to
 100    * @param[in]  configuration       The context loss configuration ( to choose resource discard policy )
 101    * @param[in]  environmentOptions  A pointer to the environment options. If NULL then one is created.
 102    */
 103   static Dali::Adaptor* New( Any nativeWindow,
 104                              RenderSurface* surface,
 105                              Dali::Configuration::ContextLoss configuration,
 106                              EnvironmentOptions* environmentOptions );
 107
 108   /**
 109    * Creates a New Adaptor
 110    * @param[in]  nativeWindow        native window handle
 111    * @param[in]  configuration       The context loss configuration ( to choose resource discard policy )
 112    * @param[in]  environmentOptions  A pointer to the environment options. If NULL then one is created.
 113    */
 114   static Dali::Adaptor* New( Dali::Window window, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions );
 115
 116   /**
 117    * 2-step initialisation, this should be called after creating an adaptor instance.
 118    */
 119   void Initialize(Dali::Configuration::ContextLoss configuration);
 120
 121   /**
 122    * Virtual destructor.
 123    */
 124   virtual ~Adaptor();
 125
 126   /**
 127    * @copydoc Dali::Adaptor::Get()
 128    */
 129   static Dali::Adaptor& Get();
 130
 131   /**
 132    * @copydoc Dali::Adaptor::IsAvailable()
 133    */
 134   static bool IsAvailable();
 135
 136   /**
 137    * @copydoc Dali::Core::SceneCreated();
 138    */
 139   void SceneCreated();
 140
 141 public: // AdaptorInternalServices implementation
 142   /**
 143    * @copydoc Dali::Adaptor::Start()
 144    */
 145   virtual void Start();
 146
 147   /**
 148    * @copydoc Dali::Adaptor::Pause()
 149    */
 150   virtual void Pause();
 151
 152   /**
 153    * @copydoc Dali::Adaptor::Resume()
 154    */
 155   virtual void Resume();
 156
 157   /**
 158    * @copydoc Dali::Adaptor::Stop()
 159    */
 160   virtual void Stop();
 161
 162   /**
 163    * @copydoc Dali::Adaptor::ContextLost()
 164    */
 165   virtual void ContextLost();
 166
 167   /**
 168    * @copydoc Dali::Adaptor::ContextRegained()
 169    */
 170   virtual void ContextRegained();
 171
 172   /**
 173    * @copydoc Dali::EventFeeder::FeedTouchPoint()
 174    */
 175   virtual void FeedTouchPoint( TouchPoint& point, int timeStamp );
 176
 177   /**
 178    * @copydoc Dali::EventFeeder::FeedWheelEvent()
 179    */
 180   virtual void FeedWheelEvent( WheelEvent& wheelEvent );
 181
 182   /**
 183    * @copydoc Dali::EventFeeder::FeedKeyEvent()
 184    */
 185   virtual void FeedKeyEvent( KeyEvent& keyEvent );
 186
 187   /**
 188    * @copydoc AdaptorInterface::ReplaceSurface()
 189    */
 190   virtual void ReplaceSurface( Any nativeWindow, RenderSurface& surface );
 191
 192   /**
 193    * @copydoc Dali::Adaptor::GetSurface()
 194    */
 195   virtual RenderSurface& GetSurface() const;
 196
 197   /**
 198    * @copydoc Dali::Adaptor::ReleaseSurfaceLock()
 199    */
 200   virtual void ReleaseSurfaceLock();
 201
 202   /**
 203    * Retrieve the TtsPlayer.
 204    * @param[in] mode The mode of TtsPlayer
 205    * @return A handle to the TtsPlayer.
 206    */
 207   virtual Dali::TtsPlayer GetTtsPlayer(Dali::TtsPlayer::Mode mode);
 208
 209   /**
 210    * @copydoc Dali::Adaptor::AddIdle()
 211    */
 212   virtual bool AddIdle( CallbackBase* callback, bool hasReturnValue, bool forceAdd );
 213
 214   /**
 215    * @copydoc Dali::Adaptor::RemoveIdle()
 216    */
 217   virtual void RemoveIdle( CallbackBase* callback );
 218
 219 public:
 220
 221   /**
 222    * @return the Core instance
 223    */
 224   virtual Dali::Integration::Core& GetCore();
 225
 226   /**
 227    * @copydoc Dali::Adaptor::SetRenderRefreshRate()
 228    */
 229   void SetRenderRefreshRate( unsigned int numberOfVSyncsPerRender );
 230
 231   /**
 232    * @copydoc Dali::Adaptor::SetUseHardwareVSync()
 233    */
 234   void SetUseHardwareVSync(bool useHardware);
 235
 236   /**
 237    * @return reference to EglFactory class
 238    */
 239   EglFactory& GetEGLFactory() const;
 240
 241   /**
 242    * Return GlAbstraction.
 243    * @return the GlAbstraction.
 244    */
 245   Integration::GlAbstraction& GetGlAbstraction() const;
 246
 247   /**
 248    * Return the PlatformAbstraction.
 249    * @return The PlatformAbstraction.
 250    */
 251   Integration::PlatformAbstraction& GetPlatformAbstraction() const;
 252
 253   /**
 254    * Sets the Drag & Drop Listener.
 255    * @param[in] detector The detector to send Drag & Drop events to.
 256    */
 257   void SetDragAndDropDetector( DragAndDropDetectorPtr detector );
 258
 259   /**
 260    * Sets a rotation observer, or set to NULL to remove.
 261    * @pre Adaptor::Start() has been called ( to create EventHandler )
 262    * @param[in] observer The observer to listen for window rotation events
 263    */
 264   void SetRotationObserver( RotationObserver* observer );
 265
 266   /**
 267    * Destroy the TtsPlayer of sepcific mode.
 268    * @param[in] mode The mode of TtsPlayer to destroy
 269    */
 270   void DestroyTtsPlayer(Dali::TtsPlayer::Mode mode);
 271
 272   /**
 273    * @brief Sets minimum distance in pixels that the fingers must move towards/away from each other in order to
 274    * trigger a pinch gesture
 275    *
 276    * @param[in] distance The minimum pinch distance in pixels
 277    */
 278   void SetMinimumPinchDistance(float distance);
 279
 280   /**
 281    * Gets native window handle
 282    *
 283    * @return native window handle
 284    */
 285   Any GetNativeWindowHandle();
 286
 287   /**
 288    * Sets use remote surface for eglSurface output
 289    * @param[in] useRemoteSurface True if the remote surface is used
 290    */
 291   void SetUseRemoteSurface(bool useRemoteSurface);
 292
 293 public:
 294
 295   /**
 296    * Adds an adaptor observer so that we can observe the adaptor's lifetime events.
 297    * @param[in]  observer  The observer.
 298    * @note Observers should remove themselves when they are destroyed.
 299    */
 300   void AddObserver( LifeCycleObserver& observer );
 301
 302   /**
 303    * Removes the observer from the adaptor.
 304    * @param[in]  observer  The observer to remove.
 305    * @note Observers should remove themselves when they are destroyed.
 306    */
 307   void RemoveObserver( LifeCycleObserver& observer );
 308
 309   /**
 310    * Emits the Notification event to the Dali core.
 311    */
 312   void SendNotificationEvent();
 313
 314   /**
 315    * Request adaptor to update once
 316    */
 317   void RequestUpdateOnce();
 318
 319   /**
 320    * Request adaptor to update indicator's height
 321    */
 322   void IndicatorSizeChanged(int height);
 323
 324   /**
 325    * @copydoc Dali::Adaptor::NotifySceneCreated()
 326    */
 327   void NotifySceneCreated();
 328
 329   /**
 330    * @copydoc Dali::Adaptor::NotifyLanguageChanged()
 331    */
 332   void NotifyLanguageChanged();
 333
 334   /**
 335    * Gets AppId of current application
 336    */
 337   void GetAppId( std::string& appId );
 338
 339   /**
 340    * Informs core the surface size has changed
 341    */
 342   void SurfaceResizePrepare( SurfaceSize surfaceSize );
 343
 344   /**
 345    * Informs ThreadController the surface size has changed
 346    */
 347   void SurfaceResizeComplete( SurfaceSize surfaceSize );
 348
 349   /**
 350    * Sets layout direction of root by system language
 351    * @param[in] locale System locale
 352    */
 353   void SetRootLayoutDirection( std::string locale );
 354
 355   /**
 356    * @copydoc Dali::Adaptor::RenderOnce
 357    */
 358   void RenderOnce();
 359
 360   /**
 361    * @copydoc Dali::Adaptor::GetLogFactory
 362    */
 363   const LogFactoryInterface& GetLogFactory();
 364
 365 public:  //AdaptorInternalServices
 366
 367   /**
 368    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetPlatformAbstractionInterface()
 369    */
 370   virtual Dali::Integration::PlatformAbstraction& GetPlatformAbstractionInterface();
 371
 372   /**
 373    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetGlesInterface()
 374    */
 375   virtual Dali::Integration::GlAbstraction& GetGlesInterface();
 376
 377   /**
 378   * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetEGLFactoryInterface()
 379   */
 380   virtual EglFactoryInterface& GetEGLFactoryInterface() const;
 381
 382   /**
 383    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetTriggerEventInterface()
 384    */
 385   virtual TriggerEventInterface& GetProcessCoreEventsTrigger();
 386
 387   /**
 388    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetTriggerEventFactoryInterface()
 389    */
 390   virtual TriggerEventFactoryInterface& GetTriggerEventFactoryInterface();
 391
 392   /**
 393    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetSocketFactoryInterface()
 394    */
 395   virtual SocketFactoryInterface& GetSocketFactoryInterface();
 396
 397   /**
 398    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetRenderSurfaceInterface()
 399    */
 400   virtual RenderSurface* GetRenderSurfaceInterface();
 401
 402   /**
 403    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetVSyncMonitorInterface()
 404    */
 405   virtual VSyncMonitorInterface* GetVSyncMonitorInterface();
 406
 407   /**
 408    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetPerformanceInterface()
 409    */
 410   virtual PerformanceInterface* GetPerformanceInterface();
 411
 412   /**
 413    * copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetKernelTraceInterface()
 414    */
 415   virtual TraceInterface& GetKernelTraceInterface();
 416
 417   /**
 418    * copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetSystemTraceInterface()
 419    */
 420   virtual TraceInterface& GetSystemTraceInterface();
 421
 422 public: // Stereoscopy
 423
 424   /**
 425    * @copydoc Dali::Integration::Core::SetViewMode()
 426    */
 427   void SetViewMode( ViewMode viewMode );
 428
 429   /**
 430    * @copydoc Dali::Integration::Core::GetViewMode()
 431    */
 432   ViewMode GetViewMode() const;
 433
 434   /**
 435    * @copydoc Dali::Integration::Core::SetStereoBase()
 436    */
 437   void SetStereoBase( float stereoBase );
 438
 439   /**
 440    * @copydoc Dali::Integration::Core::GetStereoBase()
 441    */
 442   float GetStereoBase() const;
 443
 444 public: // Signals
 445
 446   /**
 447    * @copydoc Dali::Adaptor::SignalResized
 448    */
 449   AdaptorSignalType& ResizedSignal()
 450   {
 451     return mResizedSignal;
 452   }
 453
 454   /**
 455    * @copydoc Dali::Adaptor::LanguageChangedSignal
 456    */
 457   AdaptorSignalType& LanguageChangedSignal()
 458   {
 459     return mLanguageChangedSignal;
 460   }
 461
 462 private: // From Dali::Internal::Adaptor::CoreEventInterface
 463
 464   /**
 465    * @copydoc Dali::Internal::Adaptor::CoreEventInterface::QueueCoreEvent()
 466    */
 467   virtual void QueueCoreEvent(const Dali::Integration::Event& event);
 468
 469   /**
 470    * @copydoc Dali::Internal::Adaptor:CoreEventInterface:::ProcessCoreEvents()
 471    */
 472   virtual void ProcessCoreEvents();
 473
 474 private: // From Dali::Integration::RenderController
 475
 476   /**
 477    * @copydoc Dali::Integration::RenderController::RequestUpdate()
 478    */
 479   virtual void RequestUpdate( bool forceUpdate );
 480
 481   /**
 482    * @copydoc Dali::Integration::RenderController::RequestProcessEventsOnIdle()
 483    */
 484   virtual void RequestProcessEventsOnIdle( bool forceProcess );
 485
 486 private: // From Dali::Internal::Adaptor::WindowVisibilityObserver
 487
 488   /**
 489    * Called when the window becomes fully or partially visible.
 490    */
 491   virtual void OnWindowShown();
 492
 493   /**
 494    * Called when the window is fully hidden.
 495    */
 496   virtual void OnWindowHidden();
 497
 498 private: // From Dali::Internal::Adaptor::DamageObserver
 499
 500   /**
 501    * @copydoc Dali::Internal::Adaptor::DamageObserver::OnDamaged()
 502    */
 503   void OnDamaged( const DamageArea& area );
 504
 505 private:
 506
 507   // Undefined
 508   Adaptor(const Adaptor&);
 509   Adaptor& operator=(Adaptor&);
 510
 511 private:
 512
 513   /**
 514    * Assigns the render surface to the adaptor
 515    *
 516    */
 517   void SetSurface(RenderSurface *surface);
 518
 519   /**
 520    * called after surface is created
 521    */
 522   void SurfaceInitialized();
 523
 524   /**
 525    * Sends an notification message from main loop idle handler
 526    */
 527   bool ProcessCoreEventsFromIdle();
 528
 529   /**
 530    * Gets path for data/resource storage.
 531    * @param[out] path Path for data/resource storage
 532    */
 533   void GetDataStoragePath(std::string& path);
 534
 535   /**
 536    * Sets up system information if needs
 537    */
 538   void SetupSystemInformation();
 539
 540   /**
 541    * Adds a callback to be run when entering an idle state.
 542    *
 543    * A callback of the following type should be used:
 544    * @code
 545    *   bool MyFunction();
 546    * @endcode
 547    * This callback will be called repeatedly as long as it returns true. A return of 0 deletes this callback.
 548    */
 549   bool AddIdleEnterer( CallbackBase* callback, bool forceAdd );
 550
 551   /**
 552    * Removes a previously added the idle enterer callback.
 553    */
 554   void RemoveIdleEnterer( CallbackBase* callback );
 555
 556 private:
 557
 558   /**
 559    * Constructor
 560    * @param[in]  nativeWindow native window handle
 561    * @param[in]  adaptor      The public adaptor
 562    * @param[in]  surface      A render surface can be one of the following
 563    *                          - Pixmap, adaptor will use existing Pixmap to draw on to
 564    *                          - Window, adaptor will use existing Window to draw on to
 565    * @param[in]  environmentOptions  A pointer to the environment options. If NULL then one is created.
 566    */
 567   Adaptor( Any nativeWindow, Dali::Adaptor& adaptor, RenderSurface* surface, EnvironmentOptions* environmentOptions );
 568
 569 private: // Types
 570
 571   enum State
 572   {
 573     READY,               ///< Initial state before Adaptor::Start is called.
 574     RUNNING,             ///< Adaptor is running.
 575     PAUSED,              ///< Adaptor has been paused.
 576     PAUSED_WHILE_HIDDEN, ///< Adaptor is paused while window is hidden (& cannot be resumed until window is shown).
 577     STOPPED,             ///< Adaptor has been stopped.
 578   };
 579
 580   typedef std::vector<LifeCycleObserver*>  ObserverContainer;
 581
 582 private: // Data
 583
 584   AdaptorSignalType                     mResizedSignal;               ///< Resized signal.
 585   AdaptorSignalType                     mLanguageChangedSignal;       ///< Language changed signal.
 586
 587   Dali::Adaptor&                        mAdaptor;                     ///< Reference to public adaptor instance.
 588   State                                 mState;                       ///< Current state of the adaptor
 589   Dali::Integration::Core*              mCore;                        ///< Dali Core
 590   ThreadController*                     mThreadController;            ///< Controls the threads
 591   VSyncMonitor*                         mVSyncMonitor;                ///< Monitors VSync events
 592   GlImplementation*                     mGLES;                        ///< GL implementation
 593   GlSyncImplementation*                 mGlSync;                      ///< GL Sync implementation
 594   EglFactory*                           mEglFactory;                  ///< EGL Factory
 595
 596   Any                                   mNativeWindow;                ///< window identifier
 597   RenderSurface*                        mSurface;                     ///< Current surface
 598   TizenPlatform::TizenPlatformAbstraction* mPlatformAbstraction;      ///< Platform abstraction
 599
 600   EventHandler*                         mEventHandler;                ///< event handler
 601   CallbackManager*                      mCallbackManager;             ///< Used to install callbacks
 602   bool                                  mNotificationOnIdleInstalled; ///< whether the idle handler is installed to send an notification event
 603   TriggerEventInterface*                mNotificationTrigger;         ///< Notification event trigger
 604   GestureManager*                       mGestureManager;              ///< Gesture manager
 605   FeedbackPluginProxy*                  mDaliFeedbackPlugin;          ///< Used to access feedback support
 606   FeedbackController*                   mFeedbackController;          ///< Plays feedback effects for Dali-Toolkit UI Controls.
 607   Dali::TtsPlayer                       mTtsPlayers[Dali::TtsPlayer::MODE_NUM];                   ///< Provides TTS support
 608   ObserverContainer                     mObservers;                   ///< A list of adaptor observer pointers
 609   DragAndDropDetectorPtr                mDragAndDropDetector;         ///< The Drag & Drop detector
 610   RotationObserver*                     mDeferredRotationObserver;    ///< deferred Rotation observer needs event handler
 611   EnvironmentOptions*                   mEnvironmentOptions;          ///< environment options
 612   PerformanceInterface*                 mPerformanceInterface;        ///< Performance interface
 613   KernelTrace                           mKernelTracer;                ///< Kernel tracer
 614   SystemTrace                           mSystemTracer;                ///< System tracer
 615   TriggerEventFactory                   mTriggerEventFactory;         ///< Trigger event factory
 616   ObjectProfiler*                       mObjectProfiler;              ///< Tracks object lifetime for profiling
 617   SocketFactory                         mSocketFactory;               ///< Socket factory
 618   const bool                            mEnvironmentOptionsOwned:1;   ///< Whether we own the EnvironmentOptions (and thus, need to delete it)
 619   bool                                  mUseRemoteSurface;            ///< whether the remoteSurface is used or not
 620 public:
 621   inline static Adaptor& GetImplementation(Dali::Adaptor& adaptor) {return *adaptor.mImpl;}
 622 };
 623
 624 } // namespace Internal
 625
 626 } // namespace Adaptor
 627
 628 } // namespace Dali
 629
 630 #endif // __DALI_INTERNAL_ADAPTOR_IMPL_H__