X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=adaptors%2Fcommon%2Fapplication-impl.cpp;h=cd05c9537803ec7a6e94e5528c092e92197023fb;hb=788496092f35a4bf77163b29aad5f9d64a0b7b92;hp=dfb9f1267d21eb697f5893a840511933170783a3;hpb=e54d4d1af5dfd8eeaa591f177367cff25cfeb8b2;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git

diff --git a/adaptors/common/application-impl.cpp b/adaptors/common/application-impl.cpp
index dfb9f12..cd05c95 100644
--- a/adaptors/common/application-impl.cpp
+++ b/adaptors/common/application-impl.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,6 +25,7 @@
 #include <style-monitor.h>
 #include <command-line-options.h>
 #include <common/adaptor-impl.h>
+#include <common/framework.h>
 #include <singleton-service-impl.h>
 #include <lifecycle-controller-impl.h>
 
@@ -50,15 +51,17 @@ namespace Adaptor
 ApplicationPtr Application::New(
   int* argc,
   char **argv[],
-  const std::string& name,
-  const DeviceLayout& baseLayout,
-  Dali::Application::WINDOW_MODE windowMode)
+  const std::string& stylesheet,
+  Dali::Application::WINDOW_MODE windowMode,
+  const PositionSize& positionSize,
+  Framework::Type applicationType)
 {
-  ApplicationPtr application ( new Application (argc, argv, name, baseLayout, windowMode ) );
+  ApplicationPtr application ( new Application (argc, argv, stylesheet, windowMode, positionSize, applicationType ) );
   return application;
 }
 
-Application::Application( int* argc, char** argv[], const std::string& name, const DeviceLayout& baseLayout, Dali::Application::WINDOW_MODE windowMode)
+Application::Application( int* argc, char** argv[], const std::string& stylesheet,
+  Dali::Application::WINDOW_MODE windowMode, const PositionSize& positionSize, Framework::Type applicationType )
 : mInitSignal(),
   mTerminateSignal(),
   mPauseSignal(),
@@ -72,63 +75,75 @@ Application::Application( int* argc, char** argv[], const std::string& name, con
   mMemoryLowSignal(),
   mEventLoop( NULL ),
   mFramework( NULL ),
+  mContextLossConfiguration( Configuration::APPLICATION_DOES_NOT_HANDLE_CONTEXT_LOSS ),
   mCommandLineOptions( NULL ),
   mSingletonService( SingletonService::New() ),
   mAdaptor( NULL ),
   mWindow(),
   mWindowMode( windowMode ),
-  mName( name ),
-  mInitialized( false ),
-  mBaseLayout( baseLayout ),
+  mName(),
+  mStylesheet( stylesheet ),
+  mEnvironmentOptions(),
+  mWindowPositionSize( positionSize ),
   mSlotDelegate( this )
 {
-  mCommandLineOptions = new CommandLineOptions(argc, argv);
+  // Get mName from environment options
+  mName = mEnvironmentOptions.GetWindowName();
+  if( mName.empty() && argc && ( *argc > 0 ) )
+  {
+    // Set mName from command-line args if environment option not set
+    mName = (*argv)[0];
+  }
 
-  mFramework = new Framework(*this, argc, argv, name);
+  mCommandLineOptions = new CommandLineOptions(argc, argv);
+  mFramework = new Framework( *this, argc, argv, applicationType );
+  mUseRemoteSurface = (applicationType == Framework::WATCH);
 }
 
 Application::~Application()
 {
   mSingletonService.UnregisterAll();
 
-  delete mFramework;
-  delete mCommandLineOptions;
-  delete mAdaptor;
   mWindow.Reset();
+  delete mAdaptor;
+  delete mCommandLineOptions;
+  delete mFramework;
 }
 
 void Application::CreateWindow()
 {
-  PositionSize windowPosition(0, 0, 0, 0);  // this will use full screen
-
-  if( mCommandLineOptions->stageWidth > 0 && mCommandLineOptions->stageHeight > 0 )
+  if( mWindowPositionSize.width == 0 && mWindowPositionSize.height == 0 )
   {
-    // let the command line options over ride
-    windowPosition = PositionSize( 0, 0, mCommandLineOptions->stageWidth, mCommandLineOptions->stageHeight );
+    if( mCommandLineOptions->stageWidth > 0 && mCommandLineOptions->stageHeight > 0 )
+    {
+      // Command line options override environment options and full screen
+      mWindowPositionSize.width = mCommandLineOptions->stageWidth;
+      mWindowPositionSize.height = mCommandLineOptions->stageHeight;
+    }
+    else if( mEnvironmentOptions.GetWindowWidth() && mEnvironmentOptions.GetWindowHeight() )
+    {
+      // Environment options override full screen functionality if command line arguments not provided
+      mWindowPositionSize.width = mEnvironmentOptions.GetWindowWidth();
+      mWindowPositionSize.height = mEnvironmentOptions.GetWindowHeight();
+    }
   }
 
-  mWindow = Dali::Window::New( windowPosition, mName, mWindowMode == Dali::Application::TRANSPARENT );
+  const std::string& windowClassName = mEnvironmentOptions.GetWindowClassName();
+  mWindow = Dali::Window::New( mWindowPositionSize, mName, windowClassName, mWindowMode == Dali::Application::TRANSPARENT );
+
+  // Quit the application when the window is closed
+  GetImplementation( mWindow ).DeleteRequestSignal().Connect( mSlotDelegate, &Application::Quit );
 }
 
 void Application::CreateAdaptor()
 {
   DALI_ASSERT_ALWAYS( mWindow && "Window required to create adaptor" );
 
-  mAdaptor = &Dali::Adaptor::New( mWindow, mBaseLayout, mContextLossConfiguration );
-
-  std::string dpiStr = mCommandLineOptions->stageDPI;
-  if(!dpiStr.empty())
-  {
-    // Use DPI from command line.
-    unsigned int hDPI = 0;
-    unsigned int vDPI = 0;
-
-    sscanf(dpiStr.c_str(), "%ux%u", &hDPI, &vDPI);
-
-    Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).SetDpi(hDPI, vDPI);
-  }
+  mAdaptor = Dali::Internal::Adaptor::Adaptor::New( mWindow, mContextLossConfiguration, &mEnvironmentOptions );
 
   mAdaptor->ResizedSignal().Connect( mSlotDelegate, &Application::OnResize );
+
+  Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).SetUseRemoteSurface( mUseRemoteSurface );
 }
 
 void Application::MainLoop(Dali::Configuration::ContextLoss configuration)
@@ -155,25 +170,19 @@ void Application::QuitFromMainLoop()
 {
   mAdaptor->Stop();
 
-  Dali::Application application(this);
-  mTerminateSignal.Emit( application );
-
   mFramework->Quit();
   // This will trigger OnTerminate(), below, after the main loop has completed.
-  mInitialized = false;
 }
 
-void Application::OnInit()
+void Application::DoInit()
 {
-  mFramework->AddAbortCallback( MakeCallback( this, &Application::QuitFromMainLoop ) );
-
   CreateWindow();
   CreateAdaptor();
 
   // Run the adaptor
   mAdaptor->Start();
 
-  // Check if user requires no vsyncing and set on X11 Adaptor
+  // Check if user requires no vsyncing and set Adaptor
   if (mCommandLineOptions->noVSyncOnRender)
   {
     mAdaptor->SetUseHardwareVSync(false);
@@ -190,7 +199,48 @@ void Application::OnInit()
     Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).SetViewMode( viewMode );
   }
 
-  mInitialized = true;
+  if( ! mStylesheet.empty() )
+  {
+    Dali::StyleMonitor::Get().SetTheme( mStylesheet );
+  }
+}
+
+void Application::DoStart()
+{
+  mAdaptor->NotifySceneCreated();
+}
+
+void Application::DoTerminate()
+{
+  if( mAdaptor )
+  {
+    // Ensure that the render-thread is not using the surface(window) after we delete it
+    mAdaptor->Stop();
+  }
+
+  mWindow.Reset();
+}
+
+void Application::DoPause()
+{
+  mAdaptor->Pause();
+}
+
+void Application::DoResume()
+{
+  mAdaptor->Resume();
+}
+
+void Application::DoLanguageChange()
+{
+  mAdaptor->NotifyLanguageChanged();
+}
+
+void Application::OnInit()
+{
+  mFramework->AddAbortCallback( MakeCallback( this, &Application::QuitFromMainLoop ) );
+
+  DoInit();
 
   // Wire up the LifecycleController
   Dali::LifecycleController lifecycleController = Dali::LifecycleController::Get();
@@ -206,7 +256,7 @@ void Application::OnInit()
   Dali::Application application(this);
   mInitSignal.Emit( application );
 
-  Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).GetCore().SceneCreated();
+  DoStart();
 }
 
 void Application::OnTerminate()
@@ -214,22 +264,30 @@ void Application::OnTerminate()
   // we've been told to quit by AppCore, ecore_x_destroy has been called, need to quit synchronously
   // delete the window as ecore_x has been destroyed by AppCore
 
-  mWindow.Reset();
-  mInitialized = false;
+  Dali::Application application(this);
+  mTerminateSignal.Emit( application );
+
+  DoTerminate();
 }
 
 void Application::OnPause()
 {
-  mAdaptor->Pause();
+  // A DALi app should handle Pause/Resume events.
+  // DALi just delivers the framework Pause event to the application, but not actually pause DALi core.
+  // Pausing DALi core only occurs on the Window Hidden framework event
   Dali::Application application(this);
   mPauseSignal.Emit( application );
 }
 
 void Application::OnResume()
 {
-  mAdaptor->Resume();
+  // Emit the signal first so the application can queue any messages before we do an update/render
+  // This ensures we do not just redraw the last frame before pausing if that's not required
   Dali::Application application(this);
   mResumeSignal.Emit( application );
+
+  // DALi just delivers the framework Resume event to the application.
+  // Resuming DALi core only occurs on the Window Show framework event
 }
 
 void Application::OnReset()
@@ -240,8 +298,6 @@ void Application::OnReset()
    */
   Dali::Application application(this);
   mResetSignal.Emit( application );
-
-  mWindow.Raise();
 }
 
 void Application::OnAppControl(void *data)
@@ -252,7 +308,9 @@ void Application::OnAppControl(void *data)
 
 void Application::OnLanguageChanged()
 {
-  mAdaptor->NotifyLanguageChanged();
+  DoLanguageChange();
+  Dali::Application application(this);
+  mLanguageChangedSignal.Emit( application );
 }
 
 void Application::OnRegionChanged()
@@ -294,16 +352,6 @@ Dali::Window Application::GetWindow()
   return mWindow;
 }
 
-const std::string& Application::GetTheme()
-{
-  return Dali::StyleMonitor::Get().GetTheme();
-}
-
-void Application::SetTheme(const std::string& themeFilePath)
-{
-  return Dali::StyleMonitor::Get().SetTheme(themeFilePath);
-}
-
 // Stereoscopy
 
 void Application::SetViewMode( ViewMode viewMode )
@@ -327,15 +375,24 @@ float Application::GetStereoBase() const
 }
 
 
-void Application::ReplaceWindow(PositionSize windowPosition, const std::string& name)
+void Application::ReplaceWindow( const PositionSize& positionSize, const std::string& name )
 {
-  Dali::Window newWindow = Dali::Window::New( windowPosition, name, mWindowMode == Dali::Application::TRANSPARENT );
+  Dali::Window newWindow = Dali::Window::New( positionSize, name, mWindowMode == Dali::Application::TRANSPARENT );
   Window& windowImpl = GetImplementation(newWindow);
   windowImpl.SetAdaptor(*mAdaptor);
   newWindow.ShowIndicator(Dali::Window::INVISIBLE);
   Dali::RenderSurface* renderSurface = windowImpl.GetSurface();
-  Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).ReplaceSurface(*renderSurface);
+
+  Any nativeWindow = newWindow.GetNativeHandle();
+  Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).SurfaceSizeChanged( Dali::Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
+  Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).ReplaceSurface(nativeWindow, *renderSurface);
   mWindow = newWindow;
+  mWindowPositionSize = positionSize;
+}
+
+std::string Application::GetResourcePath()
+{
+  return Internal::Adaptor::Framework::GetResourcePath();
 }
 
 } // namespace Adaptor