adaptors/tizen/framework-tizen.cpp

   1 /*
   2  * Copyright (c) 2014 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 "framework.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <app.h>
  23 #include <bundle.h>
  24 #include <Ecore.h>
  25 #include <boost/bind.hpp>
  26
  27 #include <dali/integration-api/debug.h>
  28
  29 // INTERNAL INCLUDES
  30 #include <callback-manager.h>
  31
  32 namespace Dali
  33 {
  34
  35 namespace Internal
  36 {
  37
  38 namespace Adaptor
  39 {
  40
  41 namespace
  42 {
  43
  44 /// Application Status Enum
  45 enum
  46 {
  47   APP_CREATE,
  48   APP_TERMINATE,
  49   APP_PAUSE,
  50   APP_RESUME,
  51   APP_RESET,
  52   APP_LANGUAGE_CHANGE,
  53 };
  54
  55 } // Unnamed namespace
  56
  57 /**
  58  * Impl to hide EFL data members
  59  */
  60 struct Framework::Impl
  61 {
  62   // Constructor
  63
  64   Impl(void* data)
  65   {
  66     mEventCallback.create = AppCreate;
  67     mEventCallback.terminate = AppTerminate;
  68     mEventCallback.pause = AppPause;
  69     mEventCallback.resume = AppResume;
  70 #if defined(TIZEN_SDK_2_3)
  71     mEventCallback.app_control = AppControl;
  72 #else
  73     mEventCallback.service = AppService;
  74 #endif
  75     mEventCallback.low_memory = NULL;
  76     mEventCallback.low_battery = NULL;
  77     mEventCallback.device_orientation = DeviceRotated;
  78     mEventCallback.language_changed = AppLanguageChange;
  79     mEventCallback.region_format_changed = NULL;
  80
  81     mCallbackManager = CallbackManager::New();
  82   }
  83
  84   ~Impl()
  85   {
  86     // we're quiting the main loop so
  87     // mCallbackManager->RemoveAllCallBacks() does not need to be called
  88     // to delete our abort handler
  89     delete mCallbackManager;
  90   }
  91
  92   // Data
  93
  94   boost::function<void(void)> mAbortCallBack;
  95   app_event_callback_s mEventCallback;
  96   CallbackManager *mCallbackManager;
  97   // Static methods
  98
  99   /**
 100    * Called by AppCore on application creation.
 101    */
 102   static bool AppCreate(void *data)
 103   {
 104     return static_cast<Framework*>(data)->SlpAppStatusHandler(APP_CREATE);
 105   }
 106
 107   /**
 108    * Called by AppCore when the application should terminate.
 109    */
 110   static void AppTerminate(void *data)
 111   {
 112     static_cast<Framework*>(data)->SlpAppStatusHandler(APP_TERMINATE);
 113   }
 114
 115   /**
 116    * Called by AppCore when the application is paused.
 117    */
 118   static void AppPause(void *data)
 119   {
 120     static_cast<Framework*>(data)->SlpAppStatusHandler(APP_PAUSE);
 121   }
 122
 123   /**
 124    * Called by AppCore when the application is resumed.
 125    */
 126   static void AppResume(void *data)
 127   {
 128     static_cast<Framework*>(data)->SlpAppStatusHandler(APP_RESUME);
 129   }
 130
 131   /**
 132    * Called by AppCore when the application is launched from another module (e.g. homescreen).
 133    * @param[in] b the bundle data which the launcher module sent
 134    */
 135
 136 #if defined(TIZEN_SDK_2_3)
 137   static void AppControl(app_control_h app_control, void *data)
 138 #else
 139   static void AppService(service_h service, void *data)
 140 #endif
 141   {
 142     Framework* framework = static_cast<Framework*>(data);
 143
 144     if(framework)
 145     {
 146       bundle *bundleData = NULL;
 147 #if defined(TIZEN_SDK_2_3)
 148       app_control_to_bundle(app_control, &bundleData);
 149 #else
 150       service_to_bundle(service, &bundleData);
 151 #endif
 152
 153       if(bundleData)
 154       {
 155         // get bundle name
 156         char* bundleName = const_cast<char*>(bundle_get_val(bundleData, "name"));
 157         if(bundleName != NULL)
 158         {
 159           framework->SetBundleName(bundleName);
 160         }
 161
 162         // get bundle id
 163         char* bundleId = const_cast<char*>(bundle_get_val(bundleData, "id"));
 164         if(bundleId != NULL)
 165         {
 166           framework->SetBundleId(bundleId);
 167         }
 168       }
 169       framework->SlpAppStatusHandler(APP_RESET);
 170     }
 171   }
 172
 173   /**
 174    * Called by AppCore when the language changes on the device.
 175    */
 176   static void AppLanguageChange(void* data)
 177   {
 178     static_cast<Framework*>(data)->SlpAppStatusHandler(APP_LANGUAGE_CHANGE);
 179   }
 180
 181   static void DeviceRotated(app_device_orientation_e orientation, void *user_data)
 182   {
 183     switch(orientation)
 184     {
 185       case APP_DEVICE_ORIENTATION_0:
 186         break;
 187       case APP_DEVICE_ORIENTATION_90:
 188         break;
 189       case APP_DEVICE_ORIENTATION_180:
 190         break;
 191       case APP_DEVICE_ORIENTATION_270:
 192         break;
 193     }
 194   }
 195
 196 };
 197
 198 Framework::Framework(Framework::Observer& observer, int *argc, char ***argv, const std::string& name)
 199 : mObserver(observer),
 200   mInitialised(false),
 201   mRunning(false),
 202   mArgc(argc),
 203   mArgv(argv),
 204   mName(name),
 205   mBundleName(""),
 206   mBundleId(""),
 207   mAbortHandler(boost::bind(&Framework::AbortCallback, this)),
 208   mImpl(NULL)
 209 {
 210   InitThreads();
 211   mImpl = new Impl(this);
 212 }
 213
 214 Framework::~Framework()
 215 {
 216   if (mRunning)
 217   {
 218     Quit();
 219   }
 220
 221   delete mImpl;
 222 }
 223
 224 void Framework::Run()
 225 {
 226   mRunning = true;
 227
 228   app_efl_main(mArgc, mArgv, &mImpl->mEventCallback, this);
 229
 230   mRunning = false;
 231 }
 232
 233 void Framework::Quit()
 234 {
 235   app_efl_exit();
 236 }
 237
 238 bool Framework::IsMainLoopRunning()
 239 {
 240   return mRunning;
 241 }
 242
 243 void Framework::AddAbortCallback(boost::function<void(void)> callBack)
 244 {
 245   mImpl->mAbortCallBack = callBack;
 246 }
 247
 248 std::string Framework::GetBundleName() const
 249 {
 250   return mBundleName;
 251 }
 252
 253 void Framework::SetBundleName(const std::string& name)
 254 {
 255   mBundleName = name;
 256 }
 257
 258 std::string Framework::GetBundleId() const
 259 {
 260   return mBundleId;
 261 }
 262
 263 void Framework::SetBundleId(const std::string& id)
 264 {
 265   mBundleId = id;
 266 }
 267
 268 void Framework::AbortCallback( )
 269 {
 270   // if an abort call back has been installed run it.
 271   if (mImpl->mAbortCallBack)
 272   {
 273     mImpl->mAbortCallBack();
 274   }
 275   else
 276   {
 277     Quit();
 278   }
 279 }
 280
 281 bool Framework::SlpAppStatusHandler(int type)
 282 {
 283   switch (type)
 284   {
 285     case APP_CREATE:
 286     {
 287       mInitialised = true;
 288
 289       // Connect to abnormal exit signals
 290       mAbortHandler.AbortOnSignal( SIGINT );
 291       mAbortHandler.AbortOnSignal( SIGQUIT );
 292       mAbortHandler.AbortOnSignal( SIGKILL );
 293
 294       mObserver.OnInit();
 295       break;
 296     }
 297
 298     case APP_RESET:
 299       mObserver.OnReset();
 300       break;
 301
 302     case APP_RESUME:
 303       mObserver.OnResume();
 304       break;
 305
 306     case APP_TERMINATE:
 307      mObserver.OnTerminate();
 308       break;
 309
 310     case APP_PAUSE:
 311       mObserver.OnPause();
 312       break;
 313
 314     case APP_LANGUAGE_CHANGE:
 315       mObserver.OnLanguageChanged();
 316       break;
 317
 318     default:
 319       break;
 320   }
 321
 322   return true;
 323 }
 324
 325 } // namespace Adaptor
 326
 327 } // namespace Internal
 328
 329 } // namespace Dali