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