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   // Quit the application when the window is closed
 150   GetImplementation( mWindow ).DeleteRequestSignal().Connect( mSlotDelegate, &Application::Quit );
 151 }
 152
 153 void Application::CreateAdaptor()
 154 {
 155   DALI_ASSERT_ALWAYS( mWindow && "Window required to create adaptor" );
 156
 157   mAdaptor = Dali::Internal::Adaptor::Adaptor::New( mWindow, mContextLossConfiguration, &mEnvironmentOptions );
 158
 159   mAdaptor->ResizedSignal().Connect( mSlotDelegate, &Application::OnResize );
 160
 161   Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).SetUseRemoteSurface( mUseRemoteSurface );
 162 }
 163
 164 void Application::MainLoop(Dali::Configuration::ContextLoss configuration)
 165 {
 166   mContextLossConfiguration = configuration;
 167
 168   // Run the application
 169   mFramework->Run();
 170 }
 171
 172 void Application::Lower()
 173 {
 174   // Lower the application without quitting it.
 175   mWindow.Lower();
 176 }
 177
 178 void Application::Quit()
 179 {
 180   // Actually quit the application.
 181   AddIdle( MakeCallback( this, &Application::QuitFromMainLoop ) );
 182 }
 183
 184 void Application::QuitFromMainLoop()
 185 {
 186   mAdaptor->Stop();
 187
 188   mFramework->Quit();
 189   // This will trigger OnTerminate(), below, after the main loop has completed.
 190 }
 191
 192 void Application::DoInit()
 193 {
 194   // If an application was pre-initialized, a window was made in advance
 195   if( mLaunchpadState == Launchpad::NONE )
 196   {
 197     CreateWindow();
 198   }
 199
 200   CreateAdaptor();
 201
 202   // Run the adaptor
 203   mAdaptor->Start();
 204
 205   // Check if user requires no vsyncing and set Adaptor
 206   if (mCommandLineOptions->noVSyncOnRender)
 207   {
 208     mAdaptor->SetUseHardwareVSync(false);
 209   }
 210
 211   Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).SetStereoBase( mCommandLineOptions->stereoBase );
 212   if( mCommandLineOptions->viewMode != 0 )
 213   {
 214     ViewMode viewMode = MONO;
 215     if( mCommandLineOptions->viewMode <= STEREO_INTERLACED )
 216     {
 217       viewMode = static_cast<ViewMode>( mCommandLineOptions->viewMode );
 218     }
 219     Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).SetViewMode( viewMode );
 220   }
 221
 222   if( ! mStylesheet.empty() )
 223   {
 224     Dali::StyleMonitor::Get().SetTheme( mStylesheet );
 225   }
 226 }
 227
 228 void Application::DoStart()
 229 {
 230   mAdaptor->NotifySceneCreated();
 231 }
 232
 233 void Application::DoTerminate()
 234 {
 235   if( mAdaptor )
 236   {
 237     // Ensure that the render-thread is not using the surface(window) after we delete it
 238     mAdaptor->Stop();
 239   }
 240
 241   mWindow.Reset();
 242 }
 243
 244 void Application::DoPause()
 245 {
 246   mAdaptor->Pause();
 247 }
 248
 249 void Application::DoResume()
 250 {
 251   mAdaptor->Resume();
 252 }
 253
 254 void Application::DoLanguageChange()
 255 {
 256   mAdaptor->NotifyLanguageChanged();
 257 }
 258
 259 void Application::OnInit()
 260 {
 261   mFramework->AddAbortCallback( MakeCallback( this, &Application::QuitFromMainLoop ) );
 262
 263   DoInit();
 264
 265   // Wire up the LifecycleController
 266   Dali::LifecycleController lifecycleController = Dali::LifecycleController::Get();
 267
 268   InitSignal().Connect( &GetImplementation( lifecycleController ), &LifecycleController::OnInit );
 269   TerminateSignal().Connect( &GetImplementation( lifecycleController ), &LifecycleController::OnTerminate );
 270   PauseSignal().Connect( &GetImplementation( lifecycleController ), &LifecycleController::OnPause );
 271   ResumeSignal().Connect( &GetImplementation( lifecycleController ), &LifecycleController::OnResume );
 272   ResetSignal().Connect( &GetImplementation( lifecycleController ), &LifecycleController::OnReset );
 273   ResizeSignal().Connect( &GetImplementation( lifecycleController ), &LifecycleController::OnResize );
 274   LanguageChangedSignal().Connect( &GetImplementation( lifecycleController ), &LifecycleController::OnLanguageChanged );
 275
 276   Dali::Application application(this);
 277   mInitSignal.Emit( application );
 278
 279   DoStart();
 280 }
 281
 282 void Application::OnTerminate()
 283 {
 284   // we've been told to quit by AppCore, ecore_x_destroy has been called, need to quit synchronously
 285   // delete the window as ecore_x has been destroyed by AppCore
 286
 287   Dali::Application application(this);
 288   mTerminateSignal.Emit( application );
 289
 290   DoTerminate();
 291 }
 292
 293 void Application::OnPause()
 294 {
 295   // A DALi app should handle Pause/Resume events.
 296   // DALi just delivers the framework Pause event to the application, but not actually pause DALi core.
 297   // Pausing DALi core only occurs on the Window Hidden framework event
 298   Dali::Application application(this);
 299   mPauseSignal.Emit( application );
 300 }
 301
 302 void Application::OnResume()
 303 {
 304   // Emit the signal first so the application can queue any messages before we do an update/render
 305   // This ensures we do not just redraw the last frame before pausing if that's not required
 306   Dali::Application application(this);
 307   mResumeSignal.Emit( application );
 308
 309   // DALi just delivers the framework Resume event to the application.
 310   // Resuming DALi core only occurs on the Window Show framework event
 311 }
 312
 313 void Application::OnReset()
 314 {
 315   /*
 316    * usually, reset callback was called when a caller request to launch this application via aul.
 317    * because Application class already handled initialization in OnInit(), OnReset do nothing.
 318    */
 319   Dali::Application application(this);
 320   mResetSignal.Emit( application );
 321 }
 322
 323 void Application::OnAppControl(void *data)
 324 {
 325   Dali::Application application(this);
 326   mAppControlSignal.Emit( application , data );
 327 }
 328
 329 void Application::OnLanguageChanged()
 330 {
 331   DoLanguageChange();
 332   Dali::Application application(this);
 333   mLanguageChangedSignal.Emit( application );
 334 }
 335
 336 void Application::OnRegionChanged()
 337 {
 338   Dali::Application application(this);
 339   mRegionChangedSignal.Emit( application );
 340 }
 341
 342 void Application::OnBatteryLow()
 343 {
 344   Dali::Application application(this);
 345   mBatteryLowSignal.Emit( application );
 346 }
 347
 348 void Application::OnMemoryLow()
 349 {
 350   Dali::Application application(this);
 351   mMemoryLowSignal.Emit( application );
 352 }
 353
 354 void Application::OnResize(Dali::Adaptor& adaptor)
 355 {
 356   Dali::Application application(this);
 357   mResizeSignal.Emit( application );
 358 }
 359
 360 bool Application::AddIdle( CallbackBase* callback )
 361 {
 362   return mAdaptor->AddIdle( callback );
 363 }
 364
 365 Dali::Adaptor& Application::GetAdaptor()
 366 {
 367   return *mAdaptor;
 368 }
 369
 370 Dali::Window Application::GetWindow()
 371 {
 372   return mWindow;
 373 }
 374
 375 // Stereoscopy
 376
 377 void Application::SetViewMode( ViewMode viewMode )
 378 {
 379   Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).SetViewMode( viewMode );
 380 }
 381
 382 ViewMode Application::GetViewMode() const
 383 {
 384   return Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).GetViewMode();
 385 }
 386
 387 void Application::SetStereoBase( float stereoBase )
 388 {
 389   Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).SetStereoBase( stereoBase );
 390 }
 391
 392 float Application::GetStereoBase() const
 393 {
 394   return Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).GetStereoBase();
 395 }
 396
 397
 398 void Application::ReplaceWindow( const PositionSize& positionSize, const std::string& name )
 399 {
 400   Dali::Window newWindow = Dali::Window::New( positionSize, name, mWindowMode == Dali::Application::TRANSPARENT );
 401   Window& windowImpl = GetImplementation(newWindow);
 402   windowImpl.SetAdaptor(*mAdaptor);
 403   newWindow.ShowIndicator(Dali::Window::INVISIBLE);
 404   Dali::RenderSurface* renderSurface = windowImpl.GetSurface();
 405
 406   Any nativeWindow = newWindow.GetNativeHandle();
 407   Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).ReplaceSurface(nativeWindow, *renderSurface);
 408   mWindow = newWindow;
 409   mWindowPositionSize = positionSize;
 410 }
 411
 412 std::string Application::GetResourcePath()
 413 {
 414   return Internal::Adaptor::Framework::GetResourcePath();
 415 }
 416
 417 void Application::SetStyleSheet( const std::string& stylesheet )
 418 {
 419   mStylesheet = stylesheet;
 420 }
 421
 422
 423 ApplicationPtr Application::GetPreInitializedApplication()
 424 {
 425   return gPreInitializedApplication;
 426 }
 427
 428 } // namespace Adaptor
 429
 430 } // namespace Internal
 431
 432 } // namespace Dali