dali/internal/adaptor/common/application-impl.h

   1 #ifndef DALI_INTERNAL_APPLICATION_H
   2 #define DALI_INTERNAL_APPLICATION_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/public-api/math/rect.h>
  23 #include <dali/public-api/object/base-object.h>
  24
  25 // INTERNAL INCLUDES
  26 #include <dali/devel-api/common/singleton-service.h>
  27 #include <dali/public-api/adaptor-framework/application.h>
  28
  29 #include <dali/internal/adaptor/common/adaptor-builder-impl.h>
  30 #include <dali/internal/adaptor/common/framework.h>
  31 #include <dali/internal/system/common/environment-options.h>
  32
  33 namespace Dali
  34 {
  35 class Adaptor;
  36 class Window;
  37
  38 namespace Internal
  39 {
  40 namespace Adaptor
  41 {
  42 namespace Launchpad
  43 {
  44 /**
  45  * @brief Launchpad is used to improve application launch performance.
  46  * When an application is pre-initialized, so files are preloaded, some functions are initialized and a window is made in advance.
  47  */
  48 enum State
  49 {
  50   NONE,           ///< The default state
  51   PRE_INITIALIZED ///< Application is pre-initialized.
  52 };
  53
  54 } // namespace Launchpad
  55
  56 class CommandLineOptions;
  57 class FrameworkFactory;
  58
  59 typedef Dali::Rect<int> PositionSize;
  60
  61 class Application;
  62 typedef IntrusivePtr<Application> ApplicationPtr;
  63
  64 /**
  65  * Implementation of the Application class.
  66  */
  67 class Application : public BaseObject, public Framework::Observer, public Framework::TaskObserver
  68 {
  69 public:
  70   typedef Dali::Application::LowBatterySignalType               LowBatterySignalType;
  71   typedef Dali::Application::LowMemorySignalType                LowMemorySignalType;
  72   typedef Dali::Application::DeviceOrientationChangedSignalType DeviceOrientationChangedSignalType;
  73   typedef Dali::Application::AppSignalType                      AppSignalType;
  74   typedef Dali::Application::AppControlSignalType               AppControlSignalType;
  75   typedef Dali::Application::WINDOW_MODE                        WINDOW_MODE;
  76
  77   /**
  78    * Create a new application
  79    * @param[in]  argc              A pointer to the number of arguments
  80    * @param[in]  argv              A pointer to the argument list
  81    * @param[in]  stylesheet        The path to user defined theme file
  82    * @param[in]  applicationType   A member of Dali::Framework::Type
  83    * @param[in]  useUiThread       True if the application would create a UI thread
  84    * @param[in]  windowData        The window data
  85    *
  86    */
  87   static ApplicationPtr New(int* argc, char** argv[], const std::string& stylesheet, Framework::Type applicationType, bool useUiThread, const WindowData& windowData);
  88
  89   /**
  90    * @copydoc Dali::DevelApplication::PreInitialize()
  91    */
  92   static void PreInitialize(int* argc, char** argv[]);
  93
  94 public:
  95   /**
  96    * @copydoc Dali::Application::MainLoop()
  97    */
  98   void MainLoop();
  99
 100   /**
 101    * @copydoc Dali::Application::Lower()
 102    */
 103   void Lower();
 104
 105   /**
 106    * @copydoc Dali::Application::Quit()
 107    */
 108   void Quit();
 109
 110   /**
 111    * @copydoc Dali::Application::AddIdle()
 112    */
 113   bool AddIdle(CallbackBase* callback, bool hasReturnValue);
 114
 115   /**
 116    * @copydoc Dali::Application::GetAdaptor();
 117    */
 118   Dali::Adaptor& GetAdaptor();
 119
 120   /**
 121    * @copydoc Dali::Application::GetWindow();
 122    */
 123   Dali::Window GetWindow();
 124
 125   /**
 126    * @copydoc Dali::Application::GetRegion();
 127    */
 128   std::string GetRegion() const;
 129
 130   /**
 131    * @copydoc Dali::Application::GetLanguage();
 132    */
 133   std::string GetLanguage() const;
 134
 135   /**
 136    * @copydoc Dali::Application::GetObjectRegistry();
 137    */
 138   Dali::ObjectRegistry GetObjectRegistry() const;
 139
 140   /**
 141    * @copydoc Dali::Application::GetResourcePath();
 142    */
 143   static std::string GetResourcePath();
 144
 145   /**
 146    * @copydoc Dali::DevelApplication::GetDataPath()
 147    */
 148   static std::string GetDataPath();
 149
 150   /**
 151    * Retrieves the pre-initialized application.
 152    *
 153    * @return A pointer to the pre-initialized application
 154    */
 155   static ApplicationPtr GetPreInitializedApplication();
 156
 157   /**
 158    * Stores PositionSize of window
 159    */
 160   void StoreWindowPositionSize(PositionSize positionSize);
 161
 162   /**
 163    * @copydoc Dali::DevelApplication::GetRenderThreadId()
 164    */
 165   int32_t GetRenderThreadId() const;
 166
 167 public: // From Framework::Observer
 168   /**
 169    * Called when the framework is initialised.
 170    */
 171   void OnInit() override;
 172
 173   /**
 174    * Called when the framework is terminated.
 175    */
 176   void OnTerminate() override;
 177
 178   /**
 179    * Called when the framework is paused.
 180    */
 181   void OnPause() override;
 182
 183   /**
 184    * Called when the framework resumes from a paused state.
 185    */
 186   void OnResume() override;
 187
 188   /**
 189    * Called when the framework received AppControlSignal.
 190    * @param[in] The bundle data of AppControl event.
 191    */
 192   void OnAppControl(void* data) override;
 193
 194   /**
 195    * Called when the framework informs the application that it should reset itself.
 196    */
 197   void OnReset() override;
 198
 199   /**
 200    * Called when the framework informs the application that the language of the device has changed.
 201    */
 202   void OnLanguageChanged() override;
 203
 204   /**
 205    * Called when the framework informs the application that the region of the device has changed.
 206    */
 207   void OnRegionChanged() override;
 208
 209   /**
 210    * Called when the framework informs the application that the battery level of the device is low.
 211    */
 212   void OnBatteryLow(Dali::DeviceStatus::Battery::Status status) override;
 213
 214   /**
 215    * Called when the framework informs the application that the memory level of the device is low.
 216    */
 217   void OnMemoryLow(Dali::DeviceStatus::Memory::Status status) override;
 218
 219   /**
 220    * Called when the framework informs the application that device orientation is changed.
 221    */
 222   void OnDeviceOrientationChanged(Dali::DeviceStatus::Orientation::Status status) override;
 223
 224   /**
 225    * Called when the framework informs the application that the platform surface is created.
 226    */
 227   void OnSurfaceCreated(Any newSurface) override;
 228
 229   /**
 230    * Called when the framework informs the application that the platform surface is destroyed.
 231    */
 232   void OnSurfaceDestroyed(Any newSurface) override;
 233
 234 public: // From Framework::TaskObserver
 235   /**
 236    * Called when the framework is initialised.
 237    */
 238   void OnTaskInit() override;
 239
 240   /**
 241    * Called when the framework is terminated.
 242    */
 243   void OnTaskTerminate() override;
 244
 245   /**
 246    * Called when the framework received AppControlSignal.
 247    * @param[in] The bundle data of AppControl event.
 248    */
 249   void OnTaskAppControl(void* data) override;
 250
 251   /**
 252    * Called when the framework informs the application that the language of the device has changed.
 253    */
 254   void OnTaskLanguageChanged() override;
 255
 256   /**
 257    * Called when the framework informs the application that the region of the device has changed.
 258    */
 259   void OnTaskRegionChanged() override;
 260
 261   /**
 262    * Called when the framework informs the application that the battery level of the device is low.
 263    */
 264   void OnTaskBatteryLow(Dali::DeviceStatus::Battery::Status status) override;
 265
 266   /**
 267    * Called when the framework informs the application that the memory level of the device is low.
 268    */
 269   void OnTaskMemoryLow(Dali::DeviceStatus::Memory::Status status) override;
 270
 271   /**
 272    * Called when the framework informs the application that the device orientation is changed.
 273    *
 274    * Device orientation changed event is from Application Framework(Sensor Framework), it means it is system event.
 275    * If UIThreading is enable, DALI application has the main thread and UI thread.
 276    * This event is emitted in main thread, then it is posted to the UI thread in this callback function.
 277    */
 278   void OnTaskDeviceOrientationChanged(Dali::DeviceStatus::Orientation::Status status) override;
 279
 280 public:
 281   /**
 282    * Sets a user defined theme file.
 283    * This should be called before initialization.
 284    * @param[in] stylesheet The path to user defined theme file
 285    */
 286   void SetStyleSheet(const std::string& stylesheet);
 287
 288   /**
 289    * Sets a command line options.
 290    * This is used in case of the preinitialized application.
 291    * @param[in] argc A pointer to the number of arguments
 292    * @param[in] argv A pointer to the argument list
 293    */
 294   void SetCommandLineOptions(int* argc, char** argv[]);
 295
 296   /**
 297    * Sets default window type.
 298    * This is used in case of the preinitialized application.
 299    * @param[in] type the window type for default window
 300    */
 301   void SetDefaultWindowType(WindowType type);
 302
 303   /**
 304    * @brief Relayout the application and ensure all pending operations are flushed to the update thread.
 305    */
 306   void FlushUpdateMessages();
 307
 308 public: // Signals
 309   /**
 310    * @copydoc Dali::Application::InitSignal()
 311    */
 312   Dali::Application::AppSignalType& InitSignal()
 313   {
 314     return mInitSignal;
 315   }
 316
 317   /**
 318    * @copydoc Dali::Application::TerminateSignal()
 319    */
 320   Dali::Application::AppSignalType& TerminateSignal()
 321   {
 322     return mTerminateSignal;
 323   }
 324
 325   /**
 326    * @copydoc Dali::Application::PauseSignal()
 327    */
 328   Dali::Application::AppSignalType& PauseSignal()
 329   {
 330     return mPauseSignal;
 331   }
 332
 333   /**
 334    * @copydoc Dali::Application::ResumeSignal()
 335    */
 336   Dali::Application::AppSignalType& ResumeSignal()
 337   {
 338     return mResumeSignal;
 339   }
 340
 341   /**
 342    * @copydoc Dali::Application::ResetSignal()
 343    */
 344   Dali::Application::AppSignalType& ResetSignal()
 345   {
 346     return mResetSignal;
 347   }
 348
 349   /**
 350    * @copydoc Dali::Application::AppControlSignal()
 351    */
 352   Dali::Application::AppControlSignalType& AppControlSignal()
 353   {
 354     return mAppControlSignal;
 355   }
 356
 357   /**
 358    * @copydoc Dali::Application::LanguageChangedSignal()
 359    */
 360   Dali::Application::AppSignalType& LanguageChangedSignal()
 361   {
 362     return mLanguageChangedSignal;
 363   }
 364
 365   /**
 366    * @copydoc Dali::Application::RegionChangedSignal()
 367    */
 368   Dali::Application::AppSignalType& RegionChangedSignal()
 369   {
 370     return mRegionChangedSignal;
 371   }
 372
 373   /**
 374    * @copydoc Dali::Application::LowBatterySignal()
 375    */
 376   Dali::Application::LowBatterySignalType& LowBatterySignal()
 377   {
 378     return mLowBatterySignal;
 379   }
 380
 381   /**
 382    * @copydoc Dali::Application:::LowMemorySignal()
 383    */
 384   Dali::Application::LowMemorySignalType& LowMemorySignal()
 385   {
 386     return mLowMemorySignal;
 387   }
 388
 389   /**
 390    * @copydoc Dali::Application:::DeviceOrientationChangedSignalType()
 391    */
 392   Dali::Application::DeviceOrientationChangedSignalType& DeviceOrientationChangedSignal()
 393   {
 394     return mDeviceOrientationChangedSignal;
 395   }
 396
 397   /**
 398    * @copydoc Dali::Application::TaskInitSignal()
 399    */
 400   Dali::Application::AppSignalType& TaskInitSignal()
 401   {
 402     return mTaskInitSignal;
 403   }
 404
 405   /**
 406    * @copydoc Dali::Application::TaskTerminateSignal()
 407    */
 408   Dali::Application::AppSignalType& TaskTerminateSignal()
 409   {
 410     return mTaskTerminateSignal;
 411   }
 412
 413   /**
 414    * @copydoc Dali::Application::TaskAppControlSignal()
 415    */
 416   Dali::Application::AppControlSignalType& TaskAppControlSignal()
 417   {
 418     return mTaskAppControlSignal;
 419   }
 420
 421   /**
 422    * @copydoc Dali::Application::TaskLanguageChangedSignal()
 423    */
 424   Dali::Application::AppSignalType& TaskLanguageChangedSignal()
 425   {
 426     return mTaskLanguageChangedSignal;
 427   }
 428
 429   /**
 430    * @copydoc Dali::Application::TaskRegionChangedSignal()
 431    */
 432   Dali::Application::AppSignalType& TaskRegionChangedSignal()
 433   {
 434     return mTaskRegionChangedSignal;
 435   }
 436
 437   /**
 438    * @copydoc Dali::Application::TaskLowBatterySignal()
 439    */
 440   Dali::Application::LowBatterySignalType& TaskLowBatterySignal()
 441   {
 442     return mTaskLowBatterySignal;
 443   }
 444
 445   /**
 446    * @copydoc Dali::Application::TaskLowMemorySignal()
 447    */
 448   Dali::Application::LowMemorySignalType& TaskLowMemorySignal()
 449   {
 450     return mTaskLowMemorySignal;
 451   }
 452
 453   /**
 454    * @copydoc Dali::Application::TaskDeviceOrientationChangedSignal()
 455    */
 456   Dali::Application::DeviceOrientationChangedSignalType& TaskDeviceOrientationChangedSignal()
 457   {
 458     return mTaskDeviceOrientationChangedSignal;
 459   }
 460
 461 protected:
 462   /**
 463    * Private Constructor
 464    * @param[in]  argc               A pointer to the number of arguments
 465    * @param[in]  argv               A pointer to the argument list
 466    * @param[in]  stylesheet         The path to user defined theme file
 467    * @param[in]  applicationType    A member of Dali::Framework::Type
 468    * @param[in]  useUiThread        True if the application would create UI thread
 469    * @param[in]  windowData         The WindowData
 470    */
 471   Application(int* argc, char** argv[], const std::string& stylesheet, Framework::Type applicationType, bool useUiThread, const WindowData& windowData);
 472
 473   /**
 474    * Destructor
 475    */
 476   virtual ~Application() override;
 477
 478   // Undefined
 479   Application(const Application&);
 480   Application& operator=(Application&);
 481
 482   /**
 483    * Creates the default window
 484    */
 485   void CreateWindow();
 486
 487   /**
 488    * Creates the adaptor
 489    */
 490   void CreateAdaptor();
 491
 492   /**
 493    * Creates the adaptor builder
 494    */
 495   void CreateAdaptorBuilder();
 496
 497   /**
 498    * Quits from the main loop
 499    */
 500   void QuitFromMainLoop();
 501
 502   /**
 503    * Changes information of preInitialized window
 504    */
 505   void ChangePreInitializedWindowInfo();
 506
 507 private:
 508   AppSignalType                      mInitSignal;
 509   AppSignalType                      mTerminateSignal;
 510   AppSignalType                      mPauseSignal;
 511   AppSignalType                      mResumeSignal;
 512   AppSignalType                      mResetSignal;
 513   AppControlSignalType               mAppControlSignal;
 514   AppSignalType                      mLanguageChangedSignal;
 515   AppSignalType                      mRegionChangedSignal;
 516   LowBatterySignalType               mLowBatterySignal;
 517   LowMemorySignalType                mLowMemorySignal;
 518   DeviceOrientationChangedSignalType mDeviceOrientationChangedSignal;
 519
 520   AppSignalType                      mTaskInitSignal;
 521   AppSignalType                      mTaskTerminateSignal;
 522   AppControlSignalType               mTaskAppControlSignal;
 523   AppSignalType                      mTaskLanguageChangedSignal;
 524   AppSignalType                      mTaskRegionChangedSignal;
 525   LowBatterySignalType               mTaskLowBatterySignal;
 526   LowMemorySignalType                mTaskLowMemorySignal;
 527   DeviceOrientationChangedSignalType mTaskDeviceOrientationChangedSignal;
 528
 529   std::unique_ptr<Framework>        mFramework;
 530   std::unique_ptr<FrameworkFactory> mFrameworkFactory;
 531
 532   CommandLineOptions* mCommandLineOptions;
 533
 534   Dali::Internal::Adaptor::AdaptorBuilder* mAdaptorBuilder; ///< The adaptor builder
 535   Dali::Adaptor*                           mAdaptor;
 536   std::unique_ptr<EnvironmentOptions>      mEnvironmentOptions;
 537
 538   // The Main Window is that window created by the Application during initial startup
 539   // (previously this was the only window)
 540   Dali::Window                   mMainWindow;     ///< Main Window instance
 541   Dali::Application::WINDOW_MODE mMainWindowMode; ///< Window mode of the main window
 542   std::string                    mMainWindowName; ///< Name of the main window as obtained from environment options
 543
 544   std::string      mStylesheet;
 545   PositionSize     mWindowPositionSize;
 546   Launchpad::State mLaunchpadState;
 547   WindowType       mDefaultWindowType; ///< Default window's type. It is used when Application is created.
 548   bool             mUseRemoteSurface;
 549   bool             mUseUiThread;
 550   bool             mIsSystemInitialized;
 551
 552   SlotDelegate<Application> mSlotDelegate;
 553
 554   UIThreadLoader*       mUIThreadLoader;
 555   static ApplicationPtr gPreInitializedApplication;
 556 };
 557
 558 inline Application& GetImplementation(Dali::Application& application)
 559 {
 560   DALI_ASSERT_ALWAYS(application && "application handle is empty");
 561
 562   BaseObject& handle = application.GetBaseObject();
 563
 564   return static_cast<Internal::Adaptor::Application&>(handle);
 565 }
 566
 567 inline const Application& GetImplementation(const Dali::Application& application)
 568 {
 569   DALI_ASSERT_ALWAYS(application && "application handle is empty");
 570
 571   const BaseObject& handle = application.GetBaseObject();
 572
 573   return static_cast<const Internal::Adaptor::Application&>(handle);
 574 }
 575
 576 } // namespace Adaptor
 577
 578 } // namespace Internal
 579
 580 } // namespace Dali
 581
 582 #endif // DALI_INTERNAL_APPLICATION_H