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