adaptors/common/application-impl.cpp

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include "application-impl.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/integration-api/debug.h>
  23
  24 // INTERNAL INCLUDES
  25 #include <style-monitor.h>
  26 #include <command-line-options.h>
  27 #include <common/adaptor-impl.h>
  28 #include <common/framework.h>
  29 #include <singleton-service-impl.h>
  30 #include <lifecycle-controller-impl.h>
  31
  32 namespace Dali
  33 {
  34
  35 namespace TizenPlatform
  36 {
  37 class TizenPlatformAbstraction;
  38 }
  39
  40 namespace Integration
  41 {
  42 class Core;
  43 }
  44
  45 namespace Internal
  46 {
  47
  48 namespace Adaptor
  49 {
  50
  51 ApplicationPtr Application::gPreInitializedApplication( NULL );
  52
  53 ApplicationPtr Application::New(
  54   int* argc,
  55   char **argv[],
  56   const std::string& stylesheet,
  57   Dali::Application::WINDOW_MODE windowMode,
  58   const PositionSize& positionSize,
  59   Framework::Type applicationType)
  60 {
  61   ApplicationPtr application ( new Application (argc, argv, stylesheet, windowMode, positionSize, applicationType ) );
  62   return application;
  63 }
  64
  65 void Application::PreInitialize( int* argc, char** argv[] )
  66 {
  67   if( !gPreInitializedApplication )
  68   {
  69     gPreInitializedApplication = new Application ( argc, argv, "", Dali::Application::OPAQUE, PositionSize(), Framework::NORMAL );
  70
  71     gPreInitializedApplication->CreateWindow();    // Only create window
  72
  73     gPreInitializedApplication->mLaunchpadState = Launchpad::PRE_INITIALIZED;
  74   }
  75 }
  76
  77 Application::Application( int* argc, char** argv[], const std::string& stylesheet,
  78   Dali::Application::WINDOW_MODE windowMode, const PositionSize& positionSize, Framework::Type applicationType )
  79 : mInitSignal(),
  80   mTerminateSignal(),
  81   mPauseSignal(),
  82   mResumeSignal(),
  83   mResetSignal(),
  84   mResizeSignal(),
  85   mAppControlSignal(),
  86   mLanguageChangedSignal(),
  87   mRegionChangedSignal(),
  88   mBatteryLowSignal(),
  89   mMemoryLowSignal(),
  90   mEventLoop( NULL ),
  91   mFramework( NULL ),
  92   mContextLossConfiguration( Configuration::APPLICATION_DOES_NOT_HANDLE_CONTEXT_LOSS ),
  93   mCommandLineOptions( NULL ),
  94   mSingletonService( SingletonService::New() ),
  95   mAdaptor( NULL ),
  96   mWindow(),
  97   mWindowMode( windowMode ),
  98   mName(),
  99   mStylesheet( stylesheet ),
 100   mEnvironmentOptions(),
 101   mWindowPositionSize( positionSize ),
 102   mLaunchpadState( Launchpad::NONE ),
 103   mSlotDelegate( this )
 104 {
 105   // Get mName from environment options
 106   mName = mEnvironmentOptions.GetWindowName();
 107   if( mName.empty() && argc && ( *argc > 0 ) )
 108   {
 109     // Set mName from command-line args if environment option not set
 110     mName = (*argv)[0];
 111   }
 112
 113   mCommandLineOptions = new CommandLineOptions(argc, argv);
 114   mFramework = new Framework( *this, argc, argv, applicationType );
 115   mUseRemoteSurface = (applicationType == Framework::WATCH);
 116 }
 117
 118 Application::~Application()
 119 {
 120   mSingletonService.UnregisterAll();
 121
 122   mWindow.Reset();
 123   delete mAdaptor;
 124   delete mCommandLineOptions;
 125   delete mFramework;
 126 }
 127
 128 void Application::CreateWindow()
 129 {
 130   if( mWindowPositionSize.width == 0 && mWindowPositionSize.height == 0 )
 131   {
 132     if( mCommandLineOptions->stageWidth > 0 && mCommandLineOptions->stageHeight > 0 )
 133     {
 134       // Command line options override environment options and full screen
 135       mWindowPositionSize.width = mCommandLineOptions->stageWidth;
 136       mWindowPositionSize.height = mCommandLineOptions->stageHeight;
 137     }
 138     else if( mEnvironmentOptions.GetWindowWidth() && mEnvironmentOptions.GetWindowHeight() )
 139     {
 140       // Environment options override full screen functionality if command line arguments not provided
 141       mWindowPositionSize.width = mEnvironmentOptions.GetWindowWidth();
 142       mWindowPositionSize.height = mEnvironmentOptions.GetWindowHeight();
 143     }
 144   }
 145
 146   const std::string& windowClassName = mEnvironmentOptions.GetWindowClassName();
 147   mWindow = Dali::Window::New( mWindowPositionSize, mName, windowClassName, mWindowMode == Dali::Application::TRANSPARENT );
 148
 149   int indicatorVisibleMode = mEnvironmentOptions.GetIndicatorVisibleMode();
 150   if( indicatorVisibleMode >= Dali::Window::INVISIBLE && indicatorVisibleMode <= Dali::Window::AUTO )
 151   {
 152     GetImplementation( mWindow ).SetIndicatorVisibleMode( static_cast< Dali::Window::IndicatorVisibleMode >( indicatorVisibleMode ) );
 153   }
 154
 155   // Quit the application when the window is closed
 156   GetImplementation( mWindow ).DeleteRequestSignal().Connect( mSlotDelegate, &Application::Quit );
 157 }
 158
 159 void Application::CreateAdaptor()
 160 {
 161   DALI_ASSERT_ALWAYS( mWindow && "Window required to create adaptor" );
 162
 163   mAdaptor = Dali::Internal::Adaptor::Adaptor::New( mWindow, mContextLossConfiguration, &mEnvironmentOptions );
 164
 165   mAdaptor->ResizedSignal().Connect( mSlotDelegate, &Application::OnResize );
 166
 167   Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).SetUseRemoteSurface( mUseRemoteSurface );
 168 }
 169
 170 void Application::MainLoop(Dali::Configuration::ContextLoss configuration)
 171 {
 172   mContextLossConfiguration = configuration;
 173
 174   // Run the application
 175   mFramework->Run();
 176 }
 177
 178 void Application::Lower()
 179 {
 180   // Lower the application without quitting it.
 181   mWindow.Lower();
 182 }
 183
 184 void Application::Quit()
 185 {
 186   // Actually quit the application.
 187   AddIdle( MakeCallback( this, &Application::QuitFromMainLoop ) );
 188 }
 189
 190 void Application::QuitFromMainLoop()
 191 {
 192   mAdaptor->Stop();
 193
 194   mFramework->Quit();
 195   // This will trigger OnTerminate(), below, after the main loop has completed.
 196 }
 197
 198 void Application::DoInit()
 199 {
 200   // If an application was pre-initialized, a window was made in advance
 201   if( mLaunchpadState == Launchpad::NONE )
 202   {
 203     CreateWindow();
 204   }
 205
 206   CreateAdaptor();
 207
 208   // Run the adaptor
 209   mAdaptor->Start();
 210
 211   // Check if user requires no vsyncing and set Adaptor
 212   if (mCommandLineOptions->noVSyncOnRender)
 213   {
 214     mAdaptor->SetUseHardwareVSync(false);
 215   }
 216
 217   Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).SetStereoBase( mCommandLineOptions->stereoBase );
 218   if( mCommandLineOptions->viewMode != 0 )
 219   {
 220     ViewMode viewMode = MONO;
 221     if( mCommandLineOptions->viewMode <= STEREO_INTERLACED )
 222     {
 223       viewMode = static_cast<ViewMode>( mCommandLineOptions->viewMode );
 224     }
 225     Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).SetViewMode( viewMode );
 226   }
 227
 228   if( ! mStylesheet.empty() )
 229   {
 230     Dali::StyleMonitor::Get().SetTheme( mStylesheet );
 231   }
 232 }
 233
 234 void Application::DoStart()
 235 {
 236   mAdaptor->NotifySceneCreated();
 237 }
 238
 239 void Application::DoTerminate()
 240 {
 241   if( mAdaptor )
 242   {
 243     // Ensure that the render-thread is not using the surface(window) after we delete it
 244     mAdaptor->Stop();
 245   }
 246
 247   mWindow.Reset();
 248 }
 249
 250 void Application::DoPause()
 251 {
 252   mAdaptor->Pause();
 253 }
 254
 255 void Application::DoResume()
 256 {
 257   mAdaptor->Resume();
 258 }
 259
 260 void Application::DoLanguageChange()
 261 {
 262   mAdaptor->NotifyLanguageChanged();
 263 }
 264
 265 void Application::OnInit()
 266 {
 267   mFramework->AddAbortCallback( MakeCallback( this, &Application::QuitFromMainLoop ) );
 268
 269   DoInit();
 270
 271   // Wire up the LifecycleController
 272   Dali::LifecycleController lifecycleController = Dali::LifecycleController::Get();
 273
 274   InitSignal().Connect( &GetImplementation( lifecycleController ), &LifecycleController::OnInit );
 275   TerminateSignal().Connect( &GetImplementation( lifecycleController ), &LifecycleController::OnTerminate );
 276   PauseSignal().Connect( &GetImplementation( lifecycleController ), &LifecycleController::OnPause );
 277   ResumeSignal().Connect( &GetImplementation( lifecycleController ), &LifecycleController::OnResume );
 278   ResetSignal().Connect( &GetImplementation( lifecycleController ), &LifecycleController::OnReset );
 279   ResizeSignal().Connect( &GetImplementation( lifecycleController ), &LifecycleController::OnResize );
 280   LanguageChangedSignal().Connect( &GetImplementation( lifecycleController ), &LifecycleController::OnLanguageChanged );
 281
 282   Dali::Application application(this);
 283   mInitSignal.Emit( application );
 284
 285   DoStart();
 286 }
 287
 288 void Application::OnTerminate()
 289 {
 290   // we've been told to quit by AppCore, ecore_x_destroy has been called, need to quit synchronously
 291   // delete the window as ecore_x has been destroyed by AppCore
 292
 293   Dali::Application application(this);
 294   mTerminateSignal.Emit( application );
 295
 296   DoTerminate();
 297 }
 298
 299 void Application::OnPause()
 300 {
 301   // A DALi app should handle Pause/Resume events.
 302   // DALi just delivers the framework Pause event to the application, but not actually pause DALi core.
 303   // Pausing DALi core only occurs on the Window Hidden framework event
 304   Dali::Application application(this);
 305   mPauseSignal.Emit( application );
 306 }
 307
 308 void Application::OnResume()
 309 {
 310   // Emit the signal first so the application can queue any messages before we do an update/render
 311   // This ensures we do not just redraw the last frame before pausing if that's not required
 312   Dali::Application application(this);
 313   mResumeSignal.Emit( application );
 314
 315   // DALi just delivers the framework Resume event to the application.
 316   // Resuming DALi core only occurs on the Window Show framework event
 317 }
 318
 319 void Application::OnReset()
 320 {
 321   /*
 322    * usually, reset callback was called when a caller request to launch this application via aul.
 323    * because Application class already handled initialization in OnInit(), OnReset do nothing.
 324    */
 325   Dali::Application application(this);
 326   mResetSignal.Emit( application );
 327 }
 328
 329 void Application::OnAppControl(void *data)
 330 {
 331   Dali::Application application(this);
 332   mAppControlSignal.Emit( application , data );
 333 }
 334
 335 void Application::OnLanguageChanged()
 336 {
 337   DoLanguageChange();
 338   Dali::Application application(this);
 339   mLanguageChangedSignal.Emit( application );
 340 }
 341
 342 void Application::OnRegionChanged()
 343 {
 344   Dali::Application application(this);
 345   mRegionChangedSignal.Emit( application );
 346 }
 347
 348 void Application::OnBatteryLow()
 349 {
 350   Dali::Application application(this);
 351   mBatteryLowSignal.Emit( application );
 352 }
 353
 354 void Application::OnMemoryLow()
 355 {
 356   Dali::Application application(this);
 357   mMemoryLowSignal.Emit( application );
 358 }
 359
 360 void Application::OnResize(Dali::Adaptor& adaptor)
 361 {
 362   Dali::Application application(this);
 363   mResizeSignal.Emit( application );
 364 }
 365
 366 bool Application::AddIdle( CallbackBase* callback )
 367 {
 368   return mAdaptor->AddIdle( callback );
 369 }
 370
 371 Dali::Adaptor& Application::GetAdaptor()
 372 {
 373   return *mAdaptor;
 374 }
 375
 376 Dali::Window Application::GetWindow()
 377 {
 378   return mWindow;
 379 }
 380
 381 // Stereoscopy
 382
 383 void Application::SetViewMode( ViewMode viewMode )
 384 {
 385   Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).SetViewMode( viewMode );
 386 }
 387
 388 ViewMode Application::GetViewMode() const
 389 {
 390   return Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).GetViewMode();
 391 }
 392
 393 void Application::SetStereoBase( float stereoBase )
 394 {
 395   Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).SetStereoBase( stereoBase );
 396 }
 397
 398 float Application::GetStereoBase() const
 399 {
 400   return Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).GetStereoBase();
 401 }
 402
 403
 404 void Application::ReplaceWindow( const PositionSize& positionSize, const std::string& name )
 405 {
 406   Dali::Window newWindow = Dali::Window::New( positionSize, name, mWindowMode == Dali::Application::TRANSPARENT );
 407   Window& windowImpl = GetImplementation(newWindow);
 408   windowImpl.SetAdaptor(*mAdaptor);
 409
 410   int indicatorVisibleMode = mEnvironmentOptions.GetIndicatorVisibleMode();
 411   if( indicatorVisibleMode >= Dali::Window::INVISIBLE && indicatorVisibleMode <= Dali::Window::AUTO )
 412   {
 413     GetImplementation( newWindow ).SetIndicatorVisibleMode( static_cast< Dali::Window::IndicatorVisibleMode >( indicatorVisibleMode ) );
 414   }
 415
 416   Dali::RenderSurface* renderSurface = windowImpl.GetSurface();
 417
 418   Any nativeWindow = newWindow.GetNativeHandle();
 419   Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).ReplaceSurface(nativeWindow, *renderSurface);
 420   mWindow = newWindow;
 421   mWindowPositionSize = positionSize;
 422 }
 423
 424 std::string Application::GetResourcePath()
 425 {
 426   return Internal::Adaptor::Framework::GetResourcePath();
 427 }
 428
 429 void Application::SetStyleSheet( const std::string& stylesheet )
 430 {
 431   mStylesheet = stylesheet;
 432 }
 433
 434
 435 ApplicationPtr Application::GetPreInitializedApplication()
 436 {
 437   return gPreInitializedApplication;
 438 }
 439
 440 } // namespace Adaptor
 441
 442 } // namespace Internal
 443
 444 } // namespace Dali