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

   1 #ifndef DALI_INTERNAL_APPLICATION_H
   2 #define DALI_INTERNAL_APPLICATION_H
   3
   4 /*
   5  * Copyright (c) 2021 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 EventLoop;
  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
  68 {
  69 public:
  70   typedef Dali::Application::LowBatterySignalType LowBatterySignalType;
  71   typedef Dali::Application::LowMemorySignalType  LowMemorySignalType;
  72   typedef Dali::Application::AppSignalType        AppSignalType;
  73   typedef Dali::Application::AppControlSignalType AppControlSignalType;
  74   typedef Dali::Application::WINDOW_MODE          WINDOW_MODE;
  75
  76   /**
  77    * Create a new application
  78    * @param[in]  argc         A pointer to the number of arguments
  79    * @param[in]  argv         A pointer to the argument list
  80    * @param[in]  stylesheet   The path to user defined theme file
  81    * @param[in]  windowMode   A member of Dali::Application::WINDOW_MODE
  82    * @param[in]  positionSize A position and a size of the window
  83    * @param[in]  applicationType  A member of Dali::Framework::Type
  84    */
  85   static ApplicationPtr New(int* argc, char** argv[], const std::string& stylesheet, WINDOW_MODE windowMode, const PositionSize& positionSize, Framework::Type applicationType);
  86
  87   /**
  88    * @copydoc Dali::DevelApplication::PreInitialize()
  89    */
  90   static void PreInitialize(int* argc, char** argv[]);
  91
  92 public:
  93   /**
  94    * @copydoc Dali::Application::MainLoop()
  95    */
  96   void MainLoop();
  97
  98   /**
  99    * @copydoc Dali::Application::Lower()
 100    */
 101   void Lower();
 102
 103   /**
 104    * @copydoc Dali::Application::Quit()
 105    */
 106   void Quit();
 107
 108   /**
 109    * @copydoc Dali::Application::AddIdle()
 110    */
 111   bool AddIdle(CallbackBase* callback, bool hasReturnValue);
 112
 113   /**
 114    * @copydoc Dali::Application::GetAdaptor();
 115    */
 116   Dali::Adaptor& GetAdaptor();
 117
 118   /**
 119    * @copydoc Dali::Application::GetWindow();
 120    */
 121   Dali::Window GetWindow();
 122
 123   /**
 124    * @copydoc Dali::Application::GetRegion();
 125    */
 126   std::string GetRegion() const;
 127
 128   /**
 129    * @copydoc Dali::Application::GetLanguage();
 130    */
 131   std::string GetLanguage() const;
 132
 133   /**
 134    * @copydoc Dali::Application::GetObjectRegistry();
 135    */
 136   Dali::ObjectRegistry GetObjectRegistry() const;
 137
 138   /**
 139    * @copydoc Dali::Application::GetResourcePath();
 140    */
 141   static std::string GetResourcePath();
 142
 143   /**
 144    * @copydoc Dali::DevelApplication::GetDataPath()
 145    */
 146   static std::string GetDataPath();
 147
 148   /**
 149    * Retrieves the pre-initialized application.
 150    *
 151    * @return A pointer to the pre-initialized application
 152    */
 153   static ApplicationPtr GetPreInitializedApplication();
 154
 155 public: // From Framework::Observer
 156   /**
 157    * Called when the framework is initialised.
 158    */
 159   void OnInit() override;
 160
 161   /**
 162    * Called when the framework is terminated.
 163    */
 164   void OnTerminate() override;
 165
 166   /**
 167    * Called when the framework is paused.
 168    */
 169   void OnPause() override;
 170
 171   /**
 172    * Called when the framework resumes from a paused state.
 173    */
 174   void OnResume() override;
 175
 176   /**
 177   * Called when the framework received AppControlSignal.
 178   * @param[in] The bundle data of AppControl event.
 179   */
 180   void OnAppControl(void* data) override;
 181
 182   /**
 183    * Called when the framework informs the application that it should reset itself.
 184    */
 185   void OnReset() override;
 186
 187   /**
 188    * Called when the framework informs the application that the language of the device has changed.
 189    */
 190   void OnLanguageChanged() override;
 191
 192   /**
 193   * Called when the framework informs the application that the region of the device has changed.
 194   */
 195   void OnRegionChanged() override;
 196
 197   /**
 198   * Called when the framework informs the application that the battery level of the device is low.
 199   */
 200   void OnBatteryLow(Dali::DeviceStatus::Battery::Status status) override;
 201
 202   /**
 203   * Called when the framework informs the application that the memory level of the device is low.
 204   */
 205   void OnMemoryLow(Dali::DeviceStatus::Memory::Status status) override;
 206
 207   /**
 208    * Called when the framework informs the application that the platform surface is created.
 209    */
 210   void OnSurfaceCreated(Any newSurface) override;
 211
 212   /**
 213    * Called when the framework informs the application that the platform surface is destroyed.
 214    */
 215   void OnSurfaceDestroyed(Any newSurface) override;
 216
 217 public:
 218   /**
 219    * Sets a user defined theme file.
 220    * This should be called before initialization.
 221    * @param[in] stylesheet The path to user defined theme file
 222    */
 223   void SetStyleSheet(const std::string& stylesheet);
 224
 225   /**
 226    * Sets a command line options.
 227    * This is used in case of the preinitialized application.
 228    * @param[in] argc A pointer to the number of arguments
 229    * @param[in] argv A pointer to the argument list
 230    */
 231   void SetCommandLineOptions(int* argc, char** argv[]);
 232
 233 public: // Signals
 234   /**
 235    * @copydoc Dali::Application::InitSignal()
 236    */
 237   Dali::Application::AppSignalType& InitSignal()
 238   {
 239     return mInitSignal;
 240   }
 241
 242   /**
 243    * @copydoc Dali::Application::TerminateSignal()
 244    */
 245   Dali::Application::AppSignalType& TerminateSignal()
 246   {
 247     return mTerminateSignal;
 248   }
 249
 250   /**
 251    * @copydoc Dali::Application::PauseSignal()
 252    */
 253   Dali::Application::AppSignalType& PauseSignal()
 254   {
 255     return mPauseSignal;
 256   }
 257
 258   /**
 259    * @copydoc Dali::Application::ResumeSignal()
 260    */
 261   Dali::Application::AppSignalType& ResumeSignal()
 262   {
 263     return mResumeSignal;
 264   }
 265
 266   /**
 267    * @copydoc Dali::Application::ResetSignal()
 268    */
 269   Dali::Application::AppSignalType& ResetSignal()
 270   {
 271     return mResetSignal;
 272   }
 273
 274   /**
 275   * @copydoc Dali::Application::AppControlSignal()
 276   */
 277   Dali::Application::AppControlSignalType& AppControlSignal()
 278   {
 279     return mAppControlSignal;
 280   }
 281
 282   /**
 283    * @copydoc Dali::Application::LanguageChangedSignal()
 284    */
 285   Dali::Application::AppSignalType& LanguageChangedSignal()
 286   {
 287     return mLanguageChangedSignal;
 288   }
 289
 290   /**
 291   * @copydoc Dali::Application::RegionChangedSignal()
 292   */
 293   Dali::Application::AppSignalType& RegionChangedSignal()
 294   {
 295     return mRegionChangedSignal;
 296   }
 297
 298   /**
 299   * @copydoc Dali::Application::LowBatterySignal()
 300   */
 301   Dali::Application::LowBatterySignalType& LowBatterySignal()
 302   {
 303     return mLowBatterySignal;
 304   }
 305
 306   /**
 307   * @copydoc Dali::Application:::LowMemorySignal()
 308   */
 309   Dali::Application::LowMemorySignalType& LowMemorySignal()
 310   {
 311     return mLowMemorySignal;
 312   }
 313
 314   // Temporary to test GFXApi
 315   Graphics::Controller& GetController();
 316
 317 protected:
 318   /**
 319    * Private Constructor
 320    * @param[in]  argc         A pointer to the number of arguments
 321    * @param[in]  argv         A pointer to the argument list
 322    * @param[in]  stylesheet   The path to user defined theme file
 323    * @param[in]  windowMode   A member of Dali::Application::WINDOW_MODE
 324    * @param[in]  positionSize A position and a size of the window
 325    * @param[in]  applicationType  A member of Dali::Framework::Type
 326    */
 327   Application(int* argc, char** argv[], const std::string& stylesheet, WINDOW_MODE windowMode, const PositionSize& positionSize, Framework::Type applicationType);
 328
 329   /**
 330    * Destructor
 331    */
 332   ~Application() override;
 333
 334   // Undefined
 335   Application(const Application&);
 336   Application& operator=(Application&);
 337
 338   /**
 339    * Creates the window
 340    */
 341   void CreateWindow();
 342
 343   /**
 344    * Creates the adaptor
 345    */
 346   void CreateAdaptor();
 347
 348   /**
 349    * Creates the adaptor builder
 350    */
 351   void CreateAdaptorBuilder();
 352
 353   /**
 354    * Quits from the main loop
 355    */
 356   void QuitFromMainLoop();
 357
 358 private:
 359   AppSignalType        mInitSignal;
 360   AppSignalType        mTerminateSignal;
 361   AppSignalType        mPauseSignal;
 362   AppSignalType        mResumeSignal;
 363   AppSignalType        mResetSignal;
 364   AppControlSignalType mAppControlSignal;
 365   AppSignalType        mLanguageChangedSignal;
 366   AppSignalType        mRegionChangedSignal;
 367   LowBatterySignalType mLowBatterySignal;
 368   LowMemorySignalType  mLowMemorySignal;
 369
 370   EventLoop* mEventLoop;
 371   Framework* mFramework;
 372
 373   CommandLineOptions* mCommandLineOptions;
 374
 375   Dali::Internal::Adaptor::AdaptorBuilder* mAdaptorBuilder; ///< The adaptor builder
 376   Dali::Adaptor*                           mAdaptor;
 377
 378   // The Main Window is that window created by the Application during initial startup
 379   // (previously this was the only window)
 380   Dali::Window                   mMainWindow;     ///< Main Window instance
 381   Dali::Application::WINDOW_MODE mMainWindowMode; ///< Window mode of the main window
 382   std::string                    mMainWindowName; ///< Name of the main window as obtained from environment options
 383
 384   std::string        mStylesheet;
 385   EnvironmentOptions mEnvironmentOptions;
 386   PositionSize       mWindowPositionSize;
 387   Launchpad::State   mLaunchpadState;
 388   bool               mUseRemoteSurface;
 389
 390   SlotDelegate<Application> mSlotDelegate;
 391
 392   static ApplicationPtr gPreInitializedApplication;
 393 };
 394
 395 inline Application& GetImplementation(Dali::Application& application)
 396 {
 397   DALI_ASSERT_ALWAYS(application && "application handle is empty");
 398
 399   BaseObject& handle = application.GetBaseObject();
 400
 401   return static_cast<Internal::Adaptor::Application&>(handle);
 402 }
 403
 404 inline const Application& GetImplementation(const Dali::Application& application)
 405 {
 406   DALI_ASSERT_ALWAYS(application && "application handle is empty");
 407
 408   const BaseObject& handle = application.GetBaseObject();
 409
 410   return static_cast<const Internal::Adaptor::Application&>(handle);
 411 }
 412
 413 } // namespace Adaptor
 414
 415 } // namespace Internal
 416
 417 } // namespace Dali
 418
 419 #endif // DALI_INTERNAL_APPLICATION_H