X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=adaptors%2Ftizen%2Fframework-tizen.cpp;h=f437a92c4e1cf91a6f636bdf2f51b812033184e3;hb=3f6b02327d95f846759b251568ab34a03c545096;hp=898685352d326e155f9c86cfa34eaad3ab83978e;hpb=7f1ec8d94a8737c17a1c428b188654291a01c630;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git

diff --git a/adaptors/tizen/framework-tizen.cpp b/adaptors/tizen/framework-tizen.cpp
index 8986853..f437a92 100644
--- a/adaptors/tizen/framework-tizen.cpp
+++ b/adaptors/tizen/framework-tizen.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.
@@ -19,10 +19,26 @@
 #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 <boost/bind.hpp>
+
+#include <system_info.h>
+#include <bundle_internal.h>
+
+// CONDITIONAL INCLUDES
+#ifdef APPCORE_WATCH_AVAILABLE
+#include <appcore-watch/watch_app.h>
+#endif
+#ifdef DALI_ELDBUS_AVAILABLE
+#include <Eldbus.h>
+#endif // DALI_ELDBUS_AVAILABLE
+
+#if defined( TIZEN_PLATFORM_CONFIG_SUPPORTED ) && TIZEN_PLATFORM_CONFIG_SUPPORTED
+#include <tzplatform_config.h>
+#endif // TIZEN_PLATFORM_CONFIG_SUPPORTED
 
 #include <dali/integration-api/debug.h>
 
@@ -38,177 +54,535 @@ namespace Internal
 namespace Adaptor
 {
 
+#if defined(DEBUG_ENABLED)
 namespace
 {
+Integration::Log::Filter* gDBusLogging = Integration::Log::Filter::New( Debug::NoLogging, false, "LOG_ADAPTOR_EVENTS_DBUS" );
+} // anonymous namespace
+#endif
+
+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;
 
-/// Application Status Enum
-enum
+typedef void (*AppEventCallback)(AppEventInfoPtr eventInfo, void *userData);
+
+struct AppEventHandler
 {
-  APP_CREATE,
-  APP_TERMINATE,
-  APP_PAUSE,
-  APP_RESUME,
-  APP_RESET,
-  APP_LANGUAGE_CHANGE,
+  AppEventType type;
+  AppEventCallback cb;
+  void *data;
+  void *raw;
 };
 
-} // Unnamed namespace
+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
  */
 struct Framework::Impl
 {
-  // Constructor
-
-  Impl(void* data)
-  {
-    mEventCallback.create = AppCreate;
-    mEventCallback.terminate = AppTerminate;
-    mEventCallback.pause = AppPause;
-    mEventCallback.resume = AppResume;
-#if defined(TIZEN_SDK_2_3)
-    mEventCallback.app_control = AppControl;
-#else
-    mEventCallback.service = AppService;
+// Constructor
+  Impl(void* data, Type type )
+  : mAbortCallBack( NULL ),
+    mCallbackManager( NULL )
+#ifdef APPCORE_WATCH_AVAILABLE
+    , mWatchCallback()
 #endif
-    mEventCallback.low_memory = NULL;
-    mEventCallback.low_battery = NULL;
-    mEventCallback.device_orientation = DeviceRotated;
-    mEventCallback.language_changed = AppLanguageChange;
-    mEventCallback.region_format_changed = NULL;
+  {
+    mFramework = static_cast<Framework*>(data);
 
+#ifndef APPCORE_WATCH_AVAILABLE
+    if ( type == WATCH )
+    {
+      throw Dali::DaliException( "", "Watch Application is not supported." );
+    }
+#endif
+    mApplicationType = type;
     mCallbackManager = CallbackManager::New();
   }
 
   ~Impl()
   {
+    delete mAbortCallBack;
+
     // we're quiting the main loop so
     // mCallbackManager->RemoveAllCallBacks() does not need to be called
     // to delete our abort handler
     delete mCallbackManager;
   }
 
-  // Data
+  int AppMain()
+  {
+    int ret;
 
-  boost::function<void(void)> mAbortCallBack;
-  app_event_callback_s mEventCallback;
+    if (mApplicationType == NORMAL)
+    {
+      ret = AppNormalMain();
+    }
+    else
+    {
+      ret = AppWatchMain();
+    }
+    return ret;
+  }
+
+  void AppExit()
+  {
+    if (mApplicationType == NORMAL)
+    {
+      AppNormalExit();
+    }
+    else
+    {
+      AppWatchExit();
+    }
+  }
+
+
+  // Data
+  Type mApplicationType;
+  CallbackBase* mAbortCallBack;
   CallbackManager *mCallbackManager;
-  // Static methods
 
-  /**
-   * Called by AppCore on application creation.
-   */
-  static bool AppCreate(void *data)
+  Framework* mFramework;
+  AppCore::AppEventHandlerPtr handlers[5];
+#ifdef APPCORE_WATCH_AVAILABLE
+  watch_app_lifecycle_callback_s mWatchCallback;
+  app_event_handler_h watchHandlers[5];
+#endif
+
+  static int AppCreate(void *data)
   {
-    return static_cast<Framework*>(data)->SlpAppStatusHandler(APP_CREATE);
+    appcore_ui_base_on_create();
+    return static_cast<int>( static_cast<Framework*>(data)->Create() );
   }
 
-  /**
-   * Called by AppCore when the application should terminate.
-   */
-  static void AppTerminate(void *data)
+  static int AppTerminate(void *data)
   {
-    static_cast<Framework*>(data)->SlpAppStatusHandler(APP_TERMINATE);
+    appcore_ui_base_on_terminate();
+    Observer *observer = &static_cast<Framework*>(data)->mObserver;
+
+    observer->OnTerminate();
+
+    return 0;
   }
 
-  /**
-   * Called by AppCore when the application is paused.
-   */
-  static void AppPause(void *data)
+  static int AppPause(void *data)
   {
-    static_cast<Framework*>(data)->SlpAppStatusHandler(APP_PAUSE);
+    appcore_ui_base_on_pause();
+    Observer *observer = &static_cast<Framework*>(data)->mObserver;
+
+    observer->OnPause();
+
+    return 0;
   }
 
-  /**
-   * Called by AppCore when the application is resumed.
-   */
-  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)
   {
-    static_cast<Framework*>(data)->SlpAppStatusHandler(APP_RESUME);
+    if(bundleData == NULL)
+    {
+      return;
+    }
+
+    // get bundle name
+    char* bundleName = const_cast<char*>(bundle_get_val(bundleData, "name"));
+    if(bundleName != NULL)
+    {
+      framework->SetBundleName(bundleName);
+    }
+
+    // get bundle? id
+    char* bundleId = const_cast<char*>(bundle_get_val(bundleData, "id"));
+    if(bundleId != NULL)
+    {
+      framework->SetBundleId(bundleId);
+    }
   }
 
   /**
    * 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
    */
-
-#if defined(TIZEN_SDK_2_3)
-  static void AppControl(app_control_h app_control, void *data)
-#else
-  static void AppService(service_h service, void *data)
-#endif
+  static int AppControl(bundle* bundleData, void *data)
   {
-    Framework* framework = static_cast<Framework*>(data);
+    app_control_h appControl = NULL;
 
-    if(framework)
-    {
-      bundle *bundleData = NULL;
-#if defined(TIZEN_SDK_2_3)
-      app_control_to_bundle(app_control, &bundleData);
-#else
-      service_to_bundle(service, &bundleData);
-#endif
+    appcore_ui_base_on_control(bundleData);
 
-      if(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)
       {
-        // get bundle name
-        char* bundleName = const_cast<char*>(bundle_get_val(bundleData, "name"));
-        if(bundleName != NULL)
-        {
-          framework->SetBundleName(bundleName);
-        }
-
-        // get bundle id
-        char* bundleId = const_cast<char*>(bundle_get_val(bundleData, "id"));
-        if(bundleId != NULL)
-        {
-          framework->SetBundleId(bundleId);
-        }
+        DALI_LOG_ERROR("Failed to create an app_control handle");
       }
-      framework->SlpAppStatusHandler(APP_RESET);
     }
+
+    Framework* framework = static_cast<Framework*>(data);
+    Observer *observer = &framework->mObserver;
+
+    ProcessBundle(framework, bundleData);
+
+    observer->OnReset();
+    observer->OnAppControl(appControl);
+
+    app_control_destroy(appControl);
+
+    return 0;
   }
 
-  /**
-   * Called by AppCore when the language changes on the device.
-   */
-  static void AppLanguageChange(void* data)
+  static int AppInit(int argc, char **argv, void *data)
   {
-    static_cast<Framework*>(data)->SlpAppStatusHandler(APP_LANGUAGE_CHANGE);
+#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
+    return 0;
   }
 
-  static void DeviceRotated(app_device_orientation_e orientation, void *user_data)
+  static void AppFinish(void)
   {
-    switch(orientation)
+    ecore_shutdown();
+
+    if(getenv("AUL_LOADER_INIT"))
     {
-      case APP_DEVICE_ORIENTATION_0:
-        break;
-      case APP_DEVICE_ORIENTATION_90:
-        break;
-      case APP_DEVICE_ORIENTATION_180:
-        break;
-      case APP_DEVICE_ORIENTATION_270:
-        break;
+      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)
+  {
+    Observer *observer = &static_cast<Framework*>(data)->mObserver;
+
+    observer->OnLanguageChanged();
+  }
+
+  static void AppDeviceRotated(AppCore::AppEventInfoPtr event_info, void *data)
+  {
+  }
+
+  static void AppRegionChanged(AppCore::AppEventInfoPtr event, void *data)
+  {
+    Observer *observer = &static_cast<Framework*>(data)->mObserver;
+
+    observer->OnRegionChanged();
+  }
+
+  static void AppBatteryLow(AppCore::AppEventInfoPtr event, void *data)
+  {
+    Observer *observer = &static_cast<Framework*>(data)->mObserver;
+
+    observer->OnBatteryLow();
+  }
+
+  static void AppMemoryLow(AppCore::AppEventInfoPtr event, void *data)
+  {
+    Observer *observer = &static_cast<Framework*>(data)->mObserver;
+
+    observer->OnMemoryLow();
+  }
+
+
+  int AppNormalMain()
+  {
+    int ret;
+
+    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;
+  }
+
+  void AppNormalExit()
+  {
+    appcore_ui_base_exit();
+  }
+
+#ifdef APPCORE_WATCH_AVAILABLE
+  static bool WatchAppCreate(int width, int height, void *data)
+  {
+    return static_cast<Framework*>(data)->Create();
+  }
+
+  static void WatchAppTimeTick(watch_time_h time, void *data)
+  {
+    Observer *observer = &static_cast<Framework*>(data)->mObserver;
+    WatchTime curTime(time);
+
+    observer->OnTimeTick(curTime);
+  }
+
+  static void WatchAppAmbientTick(watch_time_h time, void *data)
+  {
+    Observer *observer = &static_cast<Framework*>(data)->mObserver;
+    WatchTime curTime(time);
+
+    observer->OnAmbientTick(curTime);
+  }
+
+  static void WatchAppAmbientChanged(bool ambient, void *data)
+  {
+    Observer *observer = &static_cast<Framework*>(data)->mObserver;
+
+    observer->OnAmbientChanged(ambient);
+  }
+
+  static void WatchAppLanguageChanged(app_event_info_h event, void *data)
+  {
+    Observer *observer = &static_cast<Framework*>(data)->mObserver;
+
+    observer->OnLanguageChanged();
+  }
+
+  static void WatchAppRegionChanged(app_event_info_h event, void *data)
+  {
+    Observer *observer = &static_cast<Framework*>(data)->mObserver;
+
+    observer->OnRegionChanged();
+  }
+
+  static void WatchAppBatteryLow(app_event_info_h event, void *data)
+  {
+    Observer *observer = &static_cast<Framework*>(data)->mObserver;
+
+    observer->OnBatteryLow();
+  }
+
+  static void WatchAppMemoryLow(app_event_info_h event, void *data)
+  {
+    Observer *observer = &static_cast<Framework*>(data)->mObserver;
+
+    observer->OnMemoryLow();
+  }
+
+  static void WatchAppControl(app_control_h app_control, void *data)
+  {
+    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);
+  }
+
+  static void WatchAppTerminate(void *data)
+  {
+    Observer *observer = &static_cast<Framework*>(data)->mObserver;
+
+    observer->OnTerminate();
+  }
+
+  static void WatchAppPause(void *data)
+  {
+    Observer *observer = &static_cast<Framework*>(data)->mObserver;
+
+    observer->OnPause();
+  }
+
+  static void WatchAppResume(void *data)
+  {
+    Observer *observer = &static_cast<Framework*>(data)->mObserver;
+
+    observer->OnResume();
+  }
+
+#endif
+
+  int AppWatchMain()
+  {
+    int ret = true;
+
+#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;
+
+    watch_app_add_event_handler(&watchHandlers[APP_EVENT_LOW_BATTERY], APP_EVENT_LOW_BATTERY, WatchAppBatteryLow, mFramework);
+    watch_app_add_event_handler(&watchHandlers[APP_EVENT_LOW_MEMORY], APP_EVENT_LOW_MEMORY, WatchAppMemoryLow, mFramework);
+    watch_app_add_event_handler(&watchHandlers[APP_EVENT_LANGUAGE_CHANGED], APP_EVENT_LANGUAGE_CHANGED, WatchAppLanguageChanged, mFramework);
+    watch_app_add_event_handler(&watchHandlers[APP_EVENT_REGION_FORMAT_CHANGED], APP_EVENT_REGION_FORMAT_CHANGED, WatchAppRegionChanged, mFramework);
+
+    ret = watch_app_main(*mFramework->mArgc, *mFramework->mArgv, &mWatchCallback, mFramework);
+#endif
+    return ret;
+  }
+
+  void AppWatchExit()
+  {
+#ifdef APPCORE_WATCH_AVAILABLE
+    watch_app_exit();
+#endif
+  }
+
+
+private:
+  // Undefined
+  Impl( const Impl& impl );
+
+  // Undefined
+  Impl& operator=( const Impl& impl );
 };
 
-Framework::Framework(Framework::Observer& observer, int *argc, char ***argv, const std::string& name)
+Framework::Framework( Framework::Observer& observer, int *argc, char ***argv, Type type )
 : mObserver(observer),
   mInitialised(false),
   mRunning(false),
   mArgc(argc),
   mArgv(argv),
-  mName(name),
   mBundleName(""),
   mBundleId(""),
-  mAbortHandler(boost::bind(&Framework::AbortCallback, this)),
+  mAbortHandler( MakeCallback( this, &Framework::AbortCallback ) ),
   mImpl(NULL)
 {
+  bool featureFlag = true;
+  system_info_get_platform_bool( "tizen.org/feature/opengles.version.2_0", &featureFlag );
+
+  if( featureFlag == false )
+  {
+    set_last_result( TIZEN_ERROR_NOT_SUPPORTED );
+  }
+#ifdef DALI_ELDBUS_AVAILABLE
+  // Initialize ElDBus.
+  DALI_LOG_INFO( gDBusLogging, Debug::General, "Starting DBus Initialization\n" );
+  eldbus_init();
+#endif
   InitThreads();
-  mImpl = new Impl(this);
+
+  mImpl = new Impl(this, type);
 }
 
 Framework::~Framework()
@@ -218,21 +592,38 @@ Framework::~Framework()
     Quit();
   }
 
+#ifdef DALI_ELDBUS_AVAILABLE
+  // Shutdown ELDBus.
+  DALI_LOG_INFO( gDBusLogging, Debug::General, "Shutting down DBus\n" );
+  eldbus_shutdown();
+#endif
+
   delete mImpl;
 }
 
+bool Framework::Create()
+{
+  mInitialised = true;
+  mObserver.OnInit();
+  return true;
+}
+
 void Framework::Run()
 {
   mRunning = true;
+  int ret;
 
-  app_efl_main(mArgc, mArgv, &mImpl->mEventCallback, this);
-
+  ret = mImpl->AppMain();
+  if (ret != APP_ERROR_NONE)
+  {
+    DALI_LOG_ERROR("Framework::Run(), ui_app_main() is failed. err = %d\n", ret);
+  }
   mRunning = false;
 }
 
 void Framework::Quit()
 {
-  app_efl_exit();
+  mImpl->AppExit();
 }
 
 bool Framework::IsMainLoopRunning()
@@ -240,9 +631,9 @@ bool Framework::IsMainLoopRunning()
   return mRunning;
 }
 
-void Framework::AddAbortCallback(boost::function<void(void)> callBack)
+void Framework::AddAbortCallback( CallbackBase* callback )
 {
-  mImpl->mAbortCallBack = callBack;
+  mImpl->mAbortCallBack = callback;
 }
 
 std::string Framework::GetBundleName() const
@@ -260,6 +651,25 @@ std::string Framework::GetBundleId() const
   return mBundleId;
 }
 
+std::string Framework::GetResourcePath()
+{
+  std::string resourcePath = "";
+#if defined( TIZEN_PLATFORM_CONFIG_SUPPORTED ) && TIZEN_PLATFORM_CONFIG_SUPPORTED
+  resourcePath = app_get_resource_path();
+#else // For backwards compatibility with older Tizen versions
+
+  // "DALI_APPLICATION_PACKAGE" is used to get the already configured Application package path.
+  const char* environmentVariable = "DALI_APPLICATION_PACKAGE";
+  char* value = getenv( environmentVariable );
+  if ( value != NULL )
+  {
+    resourcePath = value;
+  }
+#endif //TIZEN_PLATFORM_CONFIG_SUPPORTED
+
+  return resourcePath;
+}
+
 void Framework::SetBundleId(const std::string& id)
 {
   mBundleId = id;
@@ -270,7 +680,7 @@ void Framework::AbortCallback( )
   // if an abort call back has been installed run it.
   if (mImpl->mAbortCallBack)
   {
-    mImpl->mAbortCallBack();
+    CallbackBase::Execute( *mImpl->mAbortCallBack );
   }
   else
   {
@@ -278,50 +688,6 @@ void Framework::AbortCallback( )
   }
 }
 
-bool Framework::SlpAppStatusHandler(int type)
-{
-  switch (type)
-  {
-    case APP_CREATE:
-    {
-      mInitialised = true;
-
-      // Connect to abnormal exit signals
-      mAbortHandler.AbortOnSignal( SIGINT );
-      mAbortHandler.AbortOnSignal( SIGQUIT );
-      mAbortHandler.AbortOnSignal( SIGKILL );
-
-      mObserver.OnInit();
-      break;
-    }
-
-    case APP_RESET:
-      mObserver.OnReset();
-      break;
-
-    case APP_RESUME:
-      mObserver.OnResume();
-      break;
-
-    case APP_TERMINATE:
-     mObserver.OnTerminate();
-      break;
-
-    case APP_PAUSE:
-      mObserver.OnPause();
-      break;
-
-    case APP_LANGUAGE_CHANGE:
-      mObserver.OnLanguageChanged();
-      break;
-
-    default:
-      break;
-  }
-
-  return true;
-}
-
 } // namespace Adaptor
 
 } // namespace Internal