X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=adaptors%2Ftizen%2Fframework-tizen.cpp;h=9628bddd0fab5d200b9325621a72a76e0a7c0898;hb=d0bee11f2716fecd5198b206c1a9a045f5ef5b7b;hp=baeff235747995e5f446f17725884f9575ef133c;hpb=dacd7e5de5e9738c6ec102e7cbbc4a1cb8c37325;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git

diff --git a/adaptors/tizen/framework-tizen.cpp b/adaptors/tizen/framework-tizen.cpp
index baeff23..9628bdd 100644
--- a/adaptors/tizen/framework-tizen.cpp
+++ b/adaptors/tizen/framework-tizen.cpp
@@ -19,14 +19,16 @@
 #include "framework.h"
 
 // EXTERNAL INCLUDES
-#include <app.h>
+#include <appcore_ui_base.h>
+#include <app_control_internal.h>
+#include <app_common.h>
 #include <bundle.h>
 #include <Ecore.h>
 
 #include <system_info.h>
-#include <app_control_internal.h>
+#include <system_settings.h>
 #include <bundle_internal.h>
-
+#include <widget_base.h>
 // CONDITIONAL INCLUDES
 #ifdef APPCORE_WATCH_AVAILABLE
 #include <appcore-watch/watch_app.h>
@@ -53,13 +55,120 @@ namespace Internal
 namespace Adaptor
 {
 
-#if defined(DEBUG_ENABLED)
 namespace
 {
+#if defined(DEBUG_ENABLED)
 Integration::Log::Filter* gDBusLogging = Integration::Log::Filter::New( Debug::NoLogging, false, "LOG_ADAPTOR_EVENTS_DBUS" );
-} // anonymous namespace
 #endif
 
+bool IsWidgetFeatureEnabled()
+{
+  static bool feature = false;
+  static bool retrieved = false;
+  int ret;
+
+  if(retrieved == true)
+  {
+    return feature;
+  }
+
+  ret = system_info_get_platform_bool("http://tizen.org/feature/shell.appwidget", &feature);
+  if(ret != SYSTEM_INFO_ERROR_NONE)
+  {
+    DALI_LOG_ERROR("failed to get system info");
+    return false;
+  }
+
+  retrieved = true;
+  return feature;
+}
+
+} // anonymous namespace
+
+namespace AppCore
+{
+
+typedef enum
+{
+  LOW_MEMORY,                 //< The low memory event
+  LOW_BATTERY,                //< The low battery event
+  LANGUAGE_CHANGED,           //< The system language changed event
+  DEVICE_ORIENTATION_CHANGED, //< The device orientation changed event
+  REGION_FORMAT_CHANGED,      //< The region format changed event
+  SUSPENDED_STATE_CHANGED,    //< The suspended state changed event of the application
+  UPDATE_REQUESTED,           //< The update requested event. This event can occur when an app needs to be updated. It is dependent on target devices.
+} AppEventType;
+
+static int AppEventConverter[APPCORE_BASE_EVENT_MAX] =
+{
+  [LOW_MEMORY] = APPCORE_BASE_EVENT_LOW_MEMORY,
+  [LOW_BATTERY] = APPCORE_BASE_EVENT_LOW_BATTERY,
+  [LANGUAGE_CHANGED] = APPCORE_BASE_EVENT_LANG_CHANGE,
+  [DEVICE_ORIENTATION_CHANGED] = APPCORE_BASE_EVENT_DEVICE_ORIENTATION_CHANGED,
+  [REGION_FORMAT_CHANGED] = APPCORE_BASE_EVENT_REGION_CHANGE,
+  [SUSPENDED_STATE_CHANGED] = APPCORE_BASE_EVENT_SUSPENDED_STATE_CHANGE,
+};
+
+struct AppEventInfo
+{
+  AppEventType type;
+  void *value;
+};
+
+typedef struct AppEventInfo *AppEventInfoPtr;
+
+typedef void (*AppEventCallback)(AppEventInfoPtr eventInfo, void *userData);
+
+struct AppEventHandler
+{
+  AppEventType type;
+  AppEventCallback cb;
+  void *data;
+  void *raw;
+};
+
+typedef struct AppEventHandler *AppEventHandlerPtr;
+
+int EventCallback(void *event, void *data)
+{
+  AppEventHandlerPtr handler = static_cast<AppEventHandlerPtr>(data);
+
+  struct AppEventInfo appEvent;
+
+  appEvent.type = handler->type;
+  appEvent.value = event;
+
+  if (handler->cb)
+    handler->cb(&appEvent, handler->data);
+
+  return 0;
+}
+
+int AppAddEventHandler(AppEventHandlerPtr *eventHandler, AppEventType eventType, AppEventCallback callback, void *userData)
+{
+  AppEventHandlerPtr handler;
+
+  handler = static_cast<AppEventHandlerPtr>( calloc(1, sizeof(struct AppEventHandler)) );
+  if (!handler)
+  {
+    DALI_LOG_ERROR( "failed to create handler" );
+    return TIZEN_ERROR_UNKNOWN;
+  }
+  else
+  {
+    handler->type = eventType;
+    handler->cb = callback;
+    handler->data = userData;
+    handler->raw = appcore_base_add_event( static_cast<appcore_base_event>(AppEventConverter[static_cast<int>(eventType)]), EventCallback, handler);
+
+    *eventHandler = handler;
+
+    return TIZEN_ERROR_NONE;
+  }
+}
+
+} // namespace Appcore
+
 /**
  * Impl to hide EFL data members
  */
@@ -68,8 +177,10 @@ struct Framework::Impl
 // Constructor
   Impl(void* data, Type type )
   : mAbortCallBack( NULL ),
-    mCallbackManager( NULL ),
-    mEventCallback()
+    mCallbackManager( NULL )
+#ifdef APPCORE_WATCH_AVAILABLE
+    , mWatchCallback()
+#endif
   {
     mFramework = static_cast<Framework*>(data);
 
@@ -81,6 +192,13 @@ struct Framework::Impl
 #endif
     mApplicationType = type;
     mCallbackManager = CallbackManager::New();
+
+    char* region;
+    char* language;
+    system_settings_get_value_string( SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, &region );
+    system_settings_get_value_string( SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE, &language );
+    mRegion = std::string( region );
+    mLanguage = std::string( language );
   }
 
   ~Impl()
@@ -101,6 +219,10 @@ struct Framework::Impl
     {
       ret = AppNormalMain();
     }
+    else if(mApplicationType == WIDGET)
+    {
+      ret = AppWidgetMain();
+    }
     else
     {
       ret = AppWatchMain();
@@ -114,49 +236,84 @@ struct Framework::Impl
     {
       AppNormalExit();
     }
+    else if(mApplicationType == WIDGET)
+    {
+      AppWidgetExit();
+    }
     else
     {
       AppWatchExit();
     }
   }
 
+  void SetLanguage( const std::string& language )
+  {
+    mLanguage = language;
+  }
+
+  void SetRegion( const std::string& region )
+  {
+    mRegion = region;
+  }
+
+  std::string GetLanguage() const
+  {
+    return mLanguage;
+  }
+
+  std::string GetRegion() const
+  {
+    return mRegion;
+  }
 
   // Data
   Type mApplicationType;
   CallbackBase* mAbortCallBack;
   CallbackManager *mCallbackManager;
+  std::string mLanguage;
+  std::string mRegion;
 
   Framework* mFramework;
-  app_event_handler_h handlers[5];
-  ui_app_lifecycle_callback_s mEventCallback;
+  AppCore::AppEventHandlerPtr handlers[5];
 #ifdef APPCORE_WATCH_AVAILABLE
   watch_app_lifecycle_callback_s mWatchCallback;
+  app_event_handler_h watchHandlers[5];
 #endif
 
-  static bool AppCreate(void *data)
+  static int AppCreate(void *data)
   {
-    return static_cast<Framework*>(data)->Create();
+    appcore_ui_base_on_create();
+    return static_cast<int>( static_cast<Framework*>(data)->Create() );
   }
 
-  static void AppTerminate(void *data)
+  static int AppTerminate(void *data)
   {
+    appcore_ui_base_on_terminate();
     Observer *observer = &static_cast<Framework*>(data)->mObserver;
 
     observer->OnTerminate();
+
+    return 0;
   }
 
-  static void AppPause(void *data)
+  static int AppPause(void *data)
   {
+    appcore_ui_base_on_pause();
     Observer *observer = &static_cast<Framework*>(data)->mObserver;
 
     observer->OnPause();
+
+    return 0;
   }
 
-  static void AppResume(void *data)
+  static int AppResume(void *data)
   {
+    appcore_ui_base_on_resume();
     Observer *observer = &static_cast<Framework*>(data)->mObserver;
 
     observer->OnResume();
+
+    return 0;
   }
 
   static void ProcessBundle(Framework* framework, bundle *bundleData)
@@ -173,7 +330,7 @@ struct Framework::Impl
       framework->SetBundleName(bundleName);
     }
 
-    // get bundle id
+    // get bundle? id
     char* bundleId = const_cast<char*>(bundle_get_val(bundleData, "id"));
     if(bundleId != NULL)
     {
@@ -185,52 +342,264 @@ struct Framework::Impl
    * Called by AppCore when the application is launched from another module (e.g. homescreen).
    * @param[in] b the bundle data which the launcher module sent
    */
-  static void AppControl(app_control_h app_control, void *data)
+  static int AppControl(bundle* bundleData, void *data)
   {
+    app_control_h appControl = NULL;
+
+    appcore_ui_base_on_control(bundleData);
+
+    if (bundleData)
+    {
+      if (app_control_create_event(bundleData, &appControl) != TIZEN_ERROR_NONE)
+      {
+        DALI_LOG_ERROR("Failed to create an app_control handle");
+      }
+    }
+    else
+    {
+      if (app_control_create(&appControl) != TIZEN_ERROR_NONE)
+      {
+        DALI_LOG_ERROR("Failed to create an app_control handle");
+      }
+    }
+
     Framework* framework = static_cast<Framework*>(data);
     Observer *observer = &framework->mObserver;
-    bundle *bundleData = NULL;
 
-    app_control_to_bundle(app_control, &bundleData);
     ProcessBundle(framework, bundleData);
 
     observer->OnReset();
-    observer->OnAppControl(app_control);
+    observer->OnAppControl(appControl);
+
+    app_control_destroy(appControl);
+
+    return 0;
+  }
+
+  static void AppInit(int argc, char **argv, void *data)
+  {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+
+    ecore_init();
+    ecore_app_args_set( argc, (const char **)argv );
+
+#pragma GCC diagnostic pop
+  }
+
+  static void AppFinish(void)
+  {
+    ecore_shutdown();
+
+    if(getenv("AUL_LOADER_INIT"))
+    {
+      unsetenv("AUL_LOADER_INIT");
+      ecore_shutdown();
+    }
+  }
+
+  static void AppRun(void *data)
+  {
+    ecore_main_loop_begin();
+  }
+
+  static void AppExit(void *data)
+  {
+    ecore_main_loop_quit();
+  }
+
+  static void AppLanguageChanged(AppCore::AppEventInfoPtr event, void *data)
+  {
+    Framework* framework = static_cast<Framework*>(data);
+    Observer *observer = &framework->mObserver;
+
+    if( event && event->value )
+    {
+      framework->SetLanguage( std::string( static_cast<const char *>(event->value) ) );
+      observer->OnLanguageChanged();
+    }
+    else
+    {
+      DALI_LOG_ERROR( "NULL pointer in Language changed event\n" );
+    }
+  }
+
+  static void AppDeviceRotated(AppCore::AppEventInfoPtr event_info, void *data)
+  {
+  }
+
+  static void AppRegionChanged(AppCore::AppEventInfoPtr event, void *data)
+  {
+    Framework* framework = static_cast<Framework*>(data);
+    Observer *observer = &framework->mObserver;
+
+    if( event && event->value )
+    {
+      framework->SetRegion( std::string( static_cast<const char *>(event->value) ) );
+      observer->OnRegionChanged();
+    }
+    else
+    {
+      DALI_LOG_ERROR( "NULL pointer in Region changed event\n" );
+    }
+  }
+
+  static void AppBatteryLow(AppCore::AppEventInfoPtr event, void *data)
+  {
+    Observer *observer = &static_cast<Framework*>(data)->mObserver;
+    int status = *static_cast<int *>(event->value);
+    Dali::DeviceStatus::Battery::Status result = Dali::DeviceStatus::Battery::NORMAL;
+
+    // convert to dali battery status
+    switch( status )
+    {
+      case 1:
+      {
+        result = Dali::DeviceStatus::Battery::POWER_OFF;
+        break;
+      }
+      case 2:
+      {
+        result = Dali::DeviceStatus::Battery::CRITICALLY_LOW;
+        break;
+      }
+      default :
+        break;
+    }
+    observer->OnBatteryLow(result);
+  }
+
+  static void AppMemoryLow(AppCore::AppEventInfoPtr event, void *data)
+  {
+    Observer *observer = &static_cast<Framework*>(data)->mObserver;
+    int status = *static_cast<int *>(event->value);
+    Dali::DeviceStatus::Memory::Status result = Dali::DeviceStatus::Memory::NORMAL;
+
+    // convert to dali memmory status
+    switch( status )
+    {
+      case 1:
+      {
+        result = Dali::DeviceStatus::Memory::NORMAL;
+        break;
+      }
+      case 2:
+      {
+        result = Dali::DeviceStatus::Memory::LOW;
+        break;
+      }
+      case 4:
+      {
+        result = Dali::DeviceStatus::Memory::CRITICALLY_LOW;
+        break;
+      }
+      default :
+        break;
+    }
+    observer->OnMemoryLow(result);
   }
 
+
   int AppNormalMain()
   {
     int ret;
 
-    mEventCallback.create = AppCreate;
-    mEventCallback.terminate = AppTerminate;
-    mEventCallback.pause = AppPause;
-    mEventCallback.resume = AppResume;
-    mEventCallback.app_control = AppControl;
+    AppCore::AppAddEventHandler(&handlers[AppCore::LOW_BATTERY], AppCore::LOW_BATTERY, AppBatteryLow, mFramework);
+    AppCore::AppAddEventHandler(&handlers[AppCore::LOW_MEMORY], AppCore::LOW_MEMORY, AppMemoryLow, mFramework);
+    AppCore::AppAddEventHandler(&handlers[AppCore::DEVICE_ORIENTATION_CHANGED], AppCore::DEVICE_ORIENTATION_CHANGED, AppDeviceRotated, mFramework);
+    AppCore::AppAddEventHandler(&handlers[AppCore::LANGUAGE_CHANGED], AppCore::LANGUAGE_CHANGED, AppLanguageChanged, mFramework);
+    AppCore::AppAddEventHandler(&handlers[AppCore::REGION_FORMAT_CHANGED], AppCore::REGION_FORMAT_CHANGED, AppRegionChanged, mFramework);
+
+    appcore_ui_base_ops ops = appcore_ui_base_get_default_ops();
+
+    /* override methods */
+    ops.base.create = AppCreate;
+    ops.base.control = AppControl;
+    ops.base.terminate = AppTerminate;
+    ops.pause = AppPause;
+    ops.resume = AppResume;
+    ops.base.init = AppInit;
+    ops.base.finish = AppFinish;
+    ops.base.run = AppRun;
+    ops.base.exit = AppExit;
+
+    ret = appcore_ui_base_init(ops, *mFramework->mArgc, *mFramework->mArgv, mFramework, APPCORE_UI_BASE_HINT_WINDOW_GROUP_CONTROL |
+                                                                                        APPCORE_UI_BASE_HINT_WINDOW_STACK_CONTROL |
+                                                                                        APPCORE_UI_BASE_HINT_BG_LAUNCH_CONTROL |
+                                                                                        APPCORE_UI_BASE_HINT_HW_ACC_CONTROL |
+                                                                                        APPCORE_UI_BASE_HINT_WINDOW_AUTO_CONTROL );
+
+    if (ret != TIZEN_ERROR_NONE)
+      return ret;
+
+    appcore_ui_base_fini();
+
+    return TIZEN_ERROR_NONE;
+  }
 
-    ui_app_add_event_handler(&handlers[APP_EVENT_LOW_BATTERY], APP_EVENT_LOW_BATTERY, AppBatteryLow, mFramework);
-    ui_app_add_event_handler(&handlers[APP_EVENT_LOW_MEMORY], APP_EVENT_LOW_MEMORY, AppMemoryLow, mFramework);
-    ui_app_add_event_handler(&handlers[APP_EVENT_DEVICE_ORIENTATION_CHANGED], APP_EVENT_DEVICE_ORIENTATION_CHANGED, AppDeviceRotated, mFramework);
-    ui_app_add_event_handler(&handlers[APP_EVENT_LANGUAGE_CHANGED], APP_EVENT_LANGUAGE_CHANGED, AppLanguageChanged, mFramework);
-    ui_app_add_event_handler(&handlers[APP_EVENT_REGION_FORMAT_CHANGED], APP_EVENT_REGION_FORMAT_CHANGED, AppRegionChanged, mFramework);
+  void AppNormalExit()
+  {
+    appcore_ui_base_exit();
+  }
 
-    ret = ui_app_main(*mFramework->mArgc, *mFramework->mArgv, &mEventCallback, mFramework);
+  void AppWidgetExit()
+  {
+    widget_base_exit();
+  }
 
-    return ret;
+  static int WidgetAppCreate( void *data )
+  {
+    widget_base_on_create();
+    return static_cast<int>( static_cast<Framework*>(data)->Create() );
   }
 
-  void AppNormalExit()
+  static int WidgetAppTerminate( void *data )
   {
-      ui_app_exit();
+    Observer *observer = &static_cast<Framework*>(data)->mObserver;
+    observer->OnTerminate();
+
+    widget_base_on_terminate();
+    return 0;
+  }
+
+  int AppWidgetMain()
+  {
+    if( !IsWidgetFeatureEnabled() )
+    {
+      DALI_LOG_ERROR("widget feature is not supported");
+      return 0;
+    }
+
+    AppCore::AppAddEventHandler(&handlers[AppCore::LOW_BATTERY], AppCore::LOW_BATTERY, AppBatteryLow, mFramework);
+    AppCore::AppAddEventHandler(&handlers[AppCore::LOW_MEMORY], AppCore::LOW_MEMORY, AppMemoryLow, mFramework);
+    AppCore::AppAddEventHandler(&handlers[AppCore::DEVICE_ORIENTATION_CHANGED], AppCore::DEVICE_ORIENTATION_CHANGED, AppDeviceRotated, mFramework);
+    AppCore::AppAddEventHandler(&handlers[AppCore::LANGUAGE_CHANGED], AppCore::LANGUAGE_CHANGED, AppLanguageChanged, mFramework);
+    AppCore::AppAddEventHandler(&handlers[AppCore::REGION_FORMAT_CHANGED], AppCore::REGION_FORMAT_CHANGED, AppRegionChanged, mFramework);
+
+    widget_base_ops ops = widget_base_get_default_ops();
+
+    /* override methods */
+    ops.create = WidgetAppCreate;
+    ops.terminate = WidgetAppTerminate;
+    ops.init = AppInit;
+    ops.finish = AppFinish;
+    ops.run = AppRun;
+    ops.exit = AppExit;
+
+    int result = widget_base_init(ops, *mFramework->mArgc, *mFramework->mArgv, mFramework);
+
+    widget_base_fini();
+
+    return result;
   }
 
 #ifdef APPCORE_WATCH_AVAILABLE
-  static bool AppCreateWatch(int width, int height, void *data)
+  static bool WatchAppCreate(int width, int height, void *data)
   {
     return static_cast<Framework*>(data)->Create();
   }
 
-  static void AppTimeTick(watch_time_h time, void *data)
+  static void WatchAppTimeTick(watch_time_h time, void *data)
   {
     Observer *observer = &static_cast<Framework*>(data)->mObserver;
     WatchTime curTime(time);
@@ -238,7 +607,7 @@ struct Framework::Impl
     observer->OnTimeTick(curTime);
   }
 
-  static void AppAmbientTick(watch_time_h time, void *data)
+  static void WatchAppAmbientTick(watch_time_h time, void *data)
   {
     Observer *observer = &static_cast<Framework*>(data)->mObserver;
     WatchTime curTime(time);
@@ -246,75 +615,78 @@ struct Framework::Impl
     observer->OnAmbientTick(curTime);
   }
 
-  static void AppAmbientChanged(bool ambient, void *data)
+  static void WatchAppAmbientChanged(bool ambient, void *data)
   {
     Observer *observer = &static_cast<Framework*>(data)->mObserver;
 
     observer->OnAmbientChanged(ambient);
   }
-#endif
 
-  int AppWatchMain()
+  static void WatchAppControl(app_control_h app_control, void *data)
   {
-    int ret = true;
-
-#ifdef APPCORE_WATCH_AVAILABLE
-    mWatchCallback.create = AppCreateWatch;
-    mWatchCallback.app_control = AppControl;
-    mWatchCallback.terminate = AppTerminate;
-    mWatchCallback.pause = AppPause;
-    mWatchCallback.resume = AppResume;
-    mWatchCallback.time_tick = AppTimeTick;
-    mWatchCallback.ambient_tick = AppAmbientTick;
-    mWatchCallback.ambient_changed = AppAmbientChanged;
-
-    watch_app_add_event_handler(&handlers[APP_EVENT_LOW_BATTERY], APP_EVENT_LOW_BATTERY, AppBatteryLow, mFramework);
-    watch_app_add_event_handler(&handlers[APP_EVENT_LOW_MEMORY], APP_EVENT_LOW_MEMORY, AppMemoryLow, mFramework);
-    watch_app_add_event_handler(&handlers[APP_EVENT_LANGUAGE_CHANGED], APP_EVENT_LANGUAGE_CHANGED, AppLanguageChanged, mFramework);
-    watch_app_add_event_handler(&handlers[APP_EVENT_REGION_FORMAT_CHANGED], APP_EVENT_REGION_FORMAT_CHANGED, AppRegionChanged, mFramework);
+    Framework* framework = static_cast<Framework*>(data);
+    Observer *observer = &framework->mObserver;
+    bundle *bundleData = NULL;
 
-    ret = watch_app_main(*mFramework->mArgc, *mFramework->mArgv, &mWatchCallback, mFramework);
-#endif
-    return ret;
-  }
+    app_control_to_bundle(app_control, &bundleData);
+    ProcessBundle(framework, bundleData);
 
-  void AppWatchExit()
-  {
-#ifdef APPCORE_WATCH_AVAILABLE
-    watch_app_exit();
-#endif
+    observer->OnReset();
+    observer->OnAppControl(app_control);
   }
 
-  static void AppLanguageChanged(app_event_info_h event, void *data)
+  static void WatchAppTerminate(void *data)
   {
     Observer *observer = &static_cast<Framework*>(data)->mObserver;
 
-    observer->OnLanguageChanged();
+    observer->OnTerminate();
   }
 
-  static void AppDeviceRotated(app_event_info_h event_info, void *data)
+  static void WatchAppPause(void *data)
   {
+    Observer *observer = &static_cast<Framework*>(data)->mObserver;
+
+    observer->OnPause();
   }
 
-  static void AppRegionChanged(app_event_info_h event, void *data)
+  static void WatchAppResume(void *data)
   {
     Observer *observer = &static_cast<Framework*>(data)->mObserver;
 
-    observer->OnRegionChanged();
+    observer->OnResume();
   }
 
-  static void AppBatteryLow(app_event_info_h event, void *data)
+#endif
+
+  int AppWatchMain()
   {
-    Observer *observer = &static_cast<Framework*>(data)->mObserver;
+    int ret = true;
 
-    observer->OnBatteryLow();
+#ifdef APPCORE_WATCH_AVAILABLE
+    mWatchCallback.create = WatchAppCreate;
+    mWatchCallback.app_control = WatchAppControl;
+    mWatchCallback.terminate = WatchAppTerminate;
+    mWatchCallback.pause = WatchAppPause;
+    mWatchCallback.resume = WatchAppResume;
+    mWatchCallback.time_tick = WatchAppTimeTick;
+    mWatchCallback.ambient_tick = WatchAppAmbientTick;
+    mWatchCallback.ambient_changed = WatchAppAmbientChanged;
+
+    AppCore::AppAddEventHandler(&handlers[AppCore::LOW_BATTERY], AppCore::LOW_BATTERY, AppBatteryLow, mFramework);
+    AppCore::AppAddEventHandler(&handlers[AppCore::LOW_MEMORY], AppCore::LOW_MEMORY, AppMemoryLow, mFramework);
+    AppCore::AppAddEventHandler(&handlers[AppCore::LANGUAGE_CHANGED], AppCore::LANGUAGE_CHANGED, AppLanguageChanged, mFramework);
+    AppCore::AppAddEventHandler(&handlers[AppCore::REGION_FORMAT_CHANGED], AppCore::REGION_FORMAT_CHANGED, AppRegionChanged, mFramework);
+
+    ret = watch_app_main(*mFramework->mArgc, *mFramework->mArgv, &mWatchCallback, mFramework);
+#endif
+    return ret;
   }
 
-  static void AppMemoryLow(app_event_info_h event, void *data)
+  void AppWatchExit()
   {
-    Observer *observer = &static_cast<Framework*>(data)->mObserver;
-
-    observer->OnMemoryLow();
+#ifdef APPCORE_WATCH_AVAILABLE
+    watch_app_exit();
+#endif
   }
 
 private:
@@ -456,6 +828,26 @@ void Framework::AbortCallback( )
   }
 }
 
+void Framework::SetLanguage( const std::string& language )
+{
+  mImpl->SetLanguage( language );
+}
+
+void Framework::SetRegion( const std::string& region )
+{
+  mImpl->SetRegion( region );
+}
+
+std::string Framework::GetLanguage() const
+{
+  return mImpl->GetLanguage();
+}
+
+std::string Framework::GetRegion() const
+{
+  return mImpl->GetRegion();
+}
+
 } // namespace Adaptor
 
 } // namespace Internal