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   /**
 220    * Sets a pre-render callback.
 221    */
 222   void SetPreRenderCallback( CallbackBase* callback );
 223
 224 public:
 225
 226   /**
 227    * @return the Core instance
 228    */
 229   virtual Dali::Integration::Core& GetCore();
 230
 231   /**
 232    * @copydoc Dali::Adaptor::SetRenderRefreshRate()
 233    */
 234   void SetRenderRefreshRate( unsigned int numberOfVSyncsPerRender );
 235
 236   /**
 237    * @copydoc Dali::Adaptor::SetUseHardwareVSync()
 238    */
 239   void SetUseHardwareVSync(bool useHardware);
 240
 241   /**
 242    * @return reference to EglFactory class
 243    */
 244   EglFactory& GetEGLFactory() const;
 245
 246   /**
 247    * Return GlAbstraction.
 248    * @return the GlAbstraction.
 249    */
 250   Integration::GlAbstraction& GetGlAbstraction() const;
 251
 252   /**
 253    * Return the PlatformAbstraction.
 254    * @return The PlatformAbstraction.
 255    */
 256   Integration::PlatformAbstraction& GetPlatformAbstraction() const;
 257
 258   /**
 259    * Sets the Drag & Drop Listener.
 260    * @param[in] detector The detector to send Drag & Drop events to.
 261    */
 262   void SetDragAndDropDetector( DragAndDropDetectorPtr detector );
 263
 264   /**
 265    * Sets a rotation observer, or set to NULL to remove.
 266    * @pre Adaptor::Start() has been called ( to create EventHandler )
 267    * @param[in] observer The observer to listen for window rotation events
 268    */
 269   void SetRotationObserver( RotationObserver* observer );
 270
 271   /**
 272    * Destroy the TtsPlayer of sepcific mode.
 273    * @param[in] mode The mode of TtsPlayer to destroy
 274    */
 275   void DestroyTtsPlayer(Dali::TtsPlayer::Mode mode);
 276
 277   /**
 278    * @brief Sets minimum distance in pixels that the fingers must move towards/away from each other in order to
 279    * trigger a pinch gesture
 280    *
 281    * @param[in] distance The minimum pinch distance in pixels
 282    */
 283   void SetMinimumPinchDistance(float distance);
 284
 285   /**
 286    * Gets native window handle
 287    *
 288    * @return native window handle
 289    */
 290   Any GetNativeWindowHandle();
 291
 292   /**
 293    * Sets use remote surface for eglSurface output
 294    * @param[in] useRemoteSurface True if the remote surface is used
 295    */
 296   void SetUseRemoteSurface(bool useRemoteSurface);
 297
 298 public:
 299
 300   /**
 301    * Adds an adaptor observer so that we can observe the adaptor's lifetime events.
 302    * @param[in]  observer  The observer.
 303    * @note Observers should remove themselves when they are destroyed.
 304    */
 305   void AddObserver( LifeCycleObserver& observer );
 306
 307   /**
 308    * Removes the observer from the adaptor.
 309    * @param[in]  observer  The observer to remove.
 310    * @note Observers should remove themselves when they are destroyed.
 311    */
 312   void RemoveObserver( LifeCycleObserver& observer );
 313
 314   /**
 315    * Emits the Notification event to the Dali core.
 316    */
 317   void SendNotificationEvent();
 318
 319   /**
 320    * Request adaptor to update once
 321    */
 322   void RequestUpdateOnce();
 323
 324   /**
 325    * Request adaptor to update indicator's height
 326    */
 327   void IndicatorSizeChanged(int height);
 328
 329   /**
 330    * @copydoc Dali::Adaptor::NotifySceneCreated()
 331    */
 332   void NotifySceneCreated();
 333
 334   /**
 335    * @copydoc Dali::Adaptor::NotifyLanguageChanged()
 336    */
 337   void NotifyLanguageChanged();
 338
 339   /**
 340    * Gets AppId of current application
 341    */
 342   void GetAppId( std::string& appId );
 343
 344   /**
 345    * Informs core the surface size has changed
 346    */
 347   void SurfaceResizePrepare( SurfaceSize surfaceSize );
 348
 349   /**
 350    * Informs ThreadController the surface size has changed
 351    */
 352   void SurfaceResizeComplete( SurfaceSize surfaceSize );
 353
 354   /**
 355    * Sets layout direction of root by system language
 356    * @param[in] locale System locale
 357    */
 358   void SetRootLayoutDirection( std::string locale );
 359
 360   /**
 361    * @copydoc Dali::Adaptor::RenderOnce
 362    */
 363   void RenderOnce();
 364
 365   /**
 366    * @copydoc Dali::Adaptor::GetLogFactory
 367    */
 368   const LogFactoryInterface& GetLogFactory();
 369
 370 public:  //AdaptorInternalServices
 371
 372   /**
 373    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetPlatformAbstractionInterface()
 374    */
 375   virtual Dali::Integration::PlatformAbstraction& GetPlatformAbstractionInterface();
 376
 377   /**
 378    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetGlesInterface()
 379    */
 380   virtual Dali::Integration::GlAbstraction& GetGlesInterface();
 381
 382   /**
 383   * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetEGLFactoryInterface()
 384   */
 385   virtual EglFactoryInterface& GetEGLFactoryInterface() const;
 386
 387   /**
 388    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetTriggerEventInterface()
 389    */
 390   virtual TriggerEventInterface& GetProcessCoreEventsTrigger();
 391
 392   /**
 393    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetTriggerEventFactoryInterface()
 394    */
 395   virtual TriggerEventFactoryInterface& GetTriggerEventFactoryInterface();
 396
 397   /**
 398    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetSocketFactoryInterface()
 399    */
 400   virtual SocketFactoryInterface& GetSocketFactoryInterface();
 401
 402   /**
 403    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetRenderSurfaceInterface()
 404    */
 405   virtual RenderSurface* GetRenderSurfaceInterface();
 406
 407   /**
 408    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetVSyncMonitorInterface()
 409    */
 410   virtual VSyncMonitorInterface* GetVSyncMonitorInterface();
 411
 412   /**
 413    * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetPerformanceInterface()
 414    */
 415   virtual PerformanceInterface* GetPerformanceInterface();
 416
 417   /**
 418    * copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetKernelTraceInterface()
 419    */
 420   virtual TraceInterface& GetKernelTraceInterface();
 421
 422   /**
 423    * copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetSystemTraceInterface()
 424    */
 425   virtual TraceInterface& GetSystemTraceInterface();
 426
 427 public: // Stereoscopy
 428
 429   /**
 430    * @copydoc Dali::Integration::Core::SetViewMode()
 431    */
 432   void SetViewMode( ViewMode viewMode );
 433
 434   /**
 435    * @copydoc Dali::Integration::Core::GetViewMode()
 436    */
 437   ViewMode GetViewMode() const;
 438
 439   /**
 440    * @copydoc Dali::Integration::Core::SetStereoBase()
 441    */
 442   void SetStereoBase( float stereoBase );
 443
 444   /**
 445    * @copydoc Dali::Integration::Core::GetStereoBase()
 446    */
 447   float GetStereoBase() const;
 448
 449 public: // Signals
 450
 451   /**
 452    * @copydoc Dali::Adaptor::SignalResized
 453    */
 454   AdaptorSignalType& ResizedSignal()
 455   {
 456     return mResizedSignal;
 457   }
 458
 459   /**
 460    * @copydoc Dali::Adaptor::LanguageChangedSignal
 461    */
 462   AdaptorSignalType& LanguageChangedSignal()
 463   {
 464     return mLanguageChangedSignal;
 465   }
 466
 467 private: // From Dali::Internal::Adaptor::CoreEventInterface
 468
 469   /**
 470    * @copydoc Dali::Internal::Adaptor::CoreEventInterface::QueueCoreEvent()
 471    */
 472   virtual void QueueCoreEvent(const Dali::Integration::Event& event);
 473
 474   /**
 475    * @copydoc Dali::Internal::Adaptor:CoreEventInterface:::ProcessCoreEvents()
 476    */
 477   virtual void ProcessCoreEvents();
 478
 479 private: // From Dali::Integration::RenderController
 480
 481   /**
 482    * @copydoc Dali::Integration::RenderController::RequestUpdate()
 483    */
 484   virtual void RequestUpdate( bool forceUpdate );
 485
 486   /**
 487    * @copydoc Dali::Integration::RenderController::RequestProcessEventsOnIdle()
 488    */
 489   virtual void RequestProcessEventsOnIdle( bool forceProcess );
 490
 491 private: // From Dali::Internal::Adaptor::WindowVisibilityObserver
 492
 493   /**
 494    * Called when the window becomes fully or partially visible.
 495    */
 496   virtual void OnWindowShown();
 497
 498   /**
 499    * Called when the window is fully hidden.
 500    */
 501   virtual void OnWindowHidden();
 502
 503 private: // From Dali::Internal::Adaptor::DamageObserver
 504
 505   /**
 506    * @copydoc Dali::Internal::Adaptor::DamageObserver::OnDamaged()
 507    */
 508   void OnDamaged( const DamageArea& area );
 509
 510 private:
 511
 512   // Undefined
 513   Adaptor(const Adaptor&);
 514   Adaptor& operator=(Adaptor&);
 515
 516 private:
 517
 518   /**
 519    * Assigns the render surface to the adaptor
 520    *
 521    */
 522   void SetSurface(RenderSurface *surface);
 523
 524   /**
 525    * called after surface is created
 526    */
 527   void SurfaceInitialized();
 528
 529   /**
 530    * Sends an notification message from main loop idle handler
 531    */
 532   bool ProcessCoreEventsFromIdle();
 533
 534   /**
 535    * Gets path for data/resource storage.
 536    * @param[out] path Path for data/resource storage
 537    */
 538   void GetDataStoragePath(std::string& path);
 539
 540   /**
 541    * Sets up system information if needs
 542    */
 543   void SetupSystemInformation();
 544
 545   /**
 546    * Adds a callback to be run when entering an idle state.
 547    *
 548    * A callback of the following type should be used:
 549    * @code
 550    *   bool MyFunction();
 551    * @endcode
 552    * This callback will be called repeatedly as long as it returns true. A return of 0 deletes this callback.
 553    */
 554   bool AddIdleEnterer( CallbackBase* callback, bool forceAdd );
 555
 556   /**
 557    * Removes a previously added the idle enterer callback.
 558    */
 559   void RemoveIdleEnterer( CallbackBase* callback );
 560
 561 private:
 562
 563   /**
 564    * Constructor
 565    * @param[in]  nativeWindow native window handle
 566    * @param[in]  adaptor      The public adaptor
 567    * @param[in]  surface      A render surface can be one of the following
 568    *                          - Pixmap, adaptor will use existing Pixmap to draw on to
 569    *                          - Window, adaptor will use existing Window to draw on to
 570    * @param[in]  environmentOptions  A pointer to the environment options. If NULL then one is created.
 571    */
 572   Adaptor( Any nativeWindow, Dali::Adaptor& adaptor, RenderSurface* surface, EnvironmentOptions* environmentOptions );
 573
 574 private: // Types
 575
 576   enum State
 577   {
 578     READY,               ///< Initial state before Adaptor::Start is called.
 579     RUNNING,             ///< Adaptor is running.
 580     PAUSED,              ///< Adaptor has been paused.
 581     PAUSED_WHILE_HIDDEN, ///< Adaptor is paused while window is hidden (& cannot be resumed until window is shown).
 582     STOPPED,             ///< Adaptor has been stopped.
 583   };
 584
 585   typedef std::vector<LifeCycleObserver*>  ObserverContainer;
 586
 587 private: // Data
 588
 589   AdaptorSignalType                     mResizedSignal;               ///< Resized signal.
 590   AdaptorSignalType                     mLanguageChangedSignal;       ///< Language changed signal.
 591
 592   Dali::Adaptor&                        mAdaptor;                     ///< Reference to public adaptor instance.
 593   State                                 mState;                       ///< Current state of the adaptor
 594   Dali::Integration::Core*              mCore;                        ///< Dali Core
 595   ThreadController*                     mThreadController;            ///< Controls the threads
 596   VSyncMonitor*                         mVSyncMonitor;                ///< Monitors VSync events
 597   GlImplementation*                     mGLES;                        ///< GL implementation
 598   GlSyncImplementation*                 mGlSync;                      ///< GL Sync implementation
 599   EglFactory*                           mEglFactory;                  ///< EGL Factory
 600
 601   Any                                   mNativeWindow;                ///< window identifier
 602   RenderSurface*                        mSurface;                     ///< Current surface
 603   TizenPlatform::TizenPlatformAbstraction* mPlatformAbstraction;      ///< Platform abstraction
 604
 605   EventHandler*                         mEventHandler;                ///< event handler
 606   CallbackManager*                      mCallbackManager;             ///< Used to install callbacks
 607   bool                                  mNotificationOnIdleInstalled; ///< whether the idle handler is installed to send an notification event
 608   TriggerEventInterface*                mNotificationTrigger;         ///< Notification event trigger
 609   GestureManager*                       mGestureManager;              ///< Gesture manager
 610   FeedbackPluginProxy*                  mDaliFeedbackPlugin;          ///< Used to access feedback support
 611   FeedbackController*                   mFeedbackController;          ///< Plays feedback effects for Dali-Toolkit UI Controls.
 612   Dali::TtsPlayer                       mTtsPlayers[Dali::TtsPlayer::MODE_NUM];                   ///< Provides TTS support
 613   ObserverContainer                     mObservers;                   ///< A list of adaptor observer pointers
 614   DragAndDropDetectorPtr                mDragAndDropDetector;         ///< The Drag & Drop detector
 615   RotationObserver*                     mDeferredRotationObserver;    ///< deferred Rotation observer needs event handler
 616   EnvironmentOptions*                   mEnvironmentOptions;          ///< environment options
 617   PerformanceInterface*                 mPerformanceInterface;        ///< Performance interface
 618   KernelTrace                           mKernelTracer;                ///< Kernel tracer
 619   SystemTrace                           mSystemTracer;                ///< System tracer
 620   TriggerEventFactory                   mTriggerEventFactory;         ///< Trigger event factory
 621   ObjectProfiler*                       mObjectProfiler;              ///< Tracks object lifetime for profiling
 622   SocketFactory                         mSocketFactory;               ///< Socket factory
 623   const bool                            mEnvironmentOptionsOwned:1;   ///< Whether we own the EnvironmentOptions (and thus, need to delete it)
 624   bool                                  mUseRemoteSurface;            ///< whether the remoteSurface is used or not
 625 public:
 626   inline static Adaptor& GetImplementation(Dali::Adaptor& adaptor) {return *adaptor.mImpl;}
 627 };
 628
 629 } // namespace Internal
 630
 631 } // namespace Adaptor
 632
 633 } // namespace Dali
 634
 635 #endif // __DALI_INTERNAL_ADAPTOR_IMPL_H__