adaptors/tizen/framework-tizen-3.cpp

   1 /*
   2  * Copyright (c) 2017 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
  26 #include <system_info.h>
  27 #include <app_control_internal.h>
  28 #include <bundle_internal.h>
  29
  30 // CONDITIONAL INCLUDES
  31 #ifdef APPCORE_WATCH_AVAILABLE
  32 #include <appcore-watch/watch_app.h>
  33 #endif
  34 #ifdef DALI_ELDBUS_AVAILABLE
  35 #include <Eldbus.h>
  36 #endif // DALI_ELDBUS_AVAILABLE
  37
  38 #if defined( TIZEN_PLATFORM_CONFIG_SUPPORTED ) && TIZEN_PLATFORM_CONFIG_SUPPORTED
  39 #include <tzplatform_config.h>
  40 #endif // TIZEN_PLATFORM_CONFIG_SUPPORTED
  41
  42 #include <dali/integration-api/debug.h>
  43
  44 // INTERNAL INCLUDES
  45 #include <callback-manager.h>
  46
  47 namespace Dali
  48 {
  49
  50 namespace Internal
  51 {
  52
  53 namespace Adaptor
  54 {
  55
  56 #if defined(DEBUG_ENABLED)
  57 namespace
  58 {
  59 Integration::Log::Filter* gDBusLogging = Integration::Log::Filter::New( Debug::NoLogging, false, "LOG_ADAPTOR_EVENTS_DBUS" );
  60 } // anonymous namespace
  61 #endif
  62
  63 /**
  64  * Impl to hide EFL data members
  65  */
  66 struct Framework::Impl
  67 {
  68 // Constructor
  69   Impl(void* data, Type type )
  70   : mAbortCallBack( NULL ),
  71     mCallbackManager( NULL ),
  72     mEventCallback()
  73 #ifdef APPCORE_WATCH_AVAILABLE
  74     , mWatchCallback()
  75 #endif
  76   {
  77     mFramework = static_cast<Framework*>(data);
  78
  79 #ifndef APPCORE_WATCH_AVAILABLE
  80     if ( type == WATCH )
  81     {
  82       throw Dali::DaliException( "", "Watch Application is not supported." );
  83     }
  84 #endif
  85     mApplicationType = type;
  86     mCallbackManager = CallbackManager::New();
  87   }
  88
  89   ~Impl()
  90   {
  91     delete mAbortCallBack;
  92
  93     // we're quiting the main loop so
  94     // mCallbackManager->RemoveAllCallBacks() does not need to be called
  95     // to delete our abort handler
  96     delete mCallbackManager;
  97   }
  98
  99   int AppMain()
 100   {
 101     int ret;
 102
 103     if (mApplicationType == NORMAL)
 104     {
 105       ret = AppNormalMain();
 106     }
 107     else
 108     {
 109       ret = AppWatchMain();
 110     }
 111     return ret;
 112   }
 113
 114   void AppExit()
 115   {
 116     if (mApplicationType == NORMAL)
 117     {
 118       AppNormalExit();
 119     }
 120     else
 121     {
 122       AppWatchExit();
 123     }
 124   }
 125
 126
 127   // Data
 128   Type mApplicationType;
 129   CallbackBase* mAbortCallBack;
 130   CallbackManager *mCallbackManager;
 131
 132   Framework* mFramework;
 133   app_event_handler_h handlers[5];
 134   ui_app_lifecycle_callback_s mEventCallback;
 135 #ifdef APPCORE_WATCH_AVAILABLE
 136   watch_app_lifecycle_callback_s mWatchCallback;
 137 #endif
 138
 139   static bool AppCreate(void *data)
 140   {
 141     return static_cast<Framework*>(data)->Create();
 142   }
 143
 144   static void AppTerminate(void *data)
 145   {
 146     Observer *observer = &static_cast<Framework*>(data)->mObserver;
 147
 148     observer->OnTerminate();
 149   }
 150
 151   static void AppPause(void *data)
 152   {
 153     Observer *observer = &static_cast<Framework*>(data)->mObserver;
 154
 155     observer->OnPause();
 156   }
 157
 158   static void AppResume(void *data)
 159   {
 160     Observer *observer = &static_cast<Framework*>(data)->mObserver;
 161
 162     observer->OnResume();
 163   }
 164
 165   static void ProcessBundle(Framework* framework, bundle *bundleData)
 166   {
 167     if(bundleData == NULL)
 168     {
 169       return;
 170     }
 171
 172     // get bundle name
 173     char* bundleName = const_cast<char*>(bundle_get_val(bundleData, "name"));
 174     if(bundleName != NULL)
 175     {
 176       framework->SetBundleName(bundleName);
 177     }
 178
 179     // get bundle id
 180     char* bundleId = const_cast<char*>(bundle_get_val(bundleData, "id"));
 181     if(bundleId != NULL)
 182     {
 183       framework->SetBundleId(bundleId);
 184     }
 185   }
 186
 187   /**
 188    * Called by AppCore when the application is launched from another module (e.g. homescreen).
 189    * @param[in] b the bundle data which the launcher module sent
 190    */
 191   static void AppControl(app_control_h app_control, void *data)
 192   {
 193     Framework* framework = static_cast<Framework*>(data);
 194     Observer *observer = &framework->mObserver;
 195     bundle *bundleData = NULL;
 196
 197     app_control_to_bundle(app_control, &bundleData);
 198     ProcessBundle(framework, bundleData);
 199
 200     observer->OnReset();
 201     observer->OnAppControl(app_control);
 202   }
 203
 204   int AppNormalMain()
 205   {
 206     int ret;
 207
 208     mEventCallback.create = AppCreate;
 209     mEventCallback.terminate = AppTerminate;
 210     mEventCallback.pause = AppPause;
 211     mEventCallback.resume = AppResume;
 212     mEventCallback.app_control = AppControl;
 213
 214     ui_app_add_event_handler(&handlers[APP_EVENT_LOW_BATTERY], APP_EVENT_LOW_BATTERY, AppBatteryLow, mFramework);
 215     ui_app_add_event_handler(&handlers[APP_EVENT_LOW_MEMORY], APP_EVENT_LOW_MEMORY, AppMemoryLow, mFramework);
 216     ui_app_add_event_handler(&handlers[APP_EVENT_DEVICE_ORIENTATION_CHANGED], APP_EVENT_DEVICE_ORIENTATION_CHANGED, AppDeviceRotated, mFramework);
 217     ui_app_add_event_handler(&handlers[APP_EVENT_LANGUAGE_CHANGED], APP_EVENT_LANGUAGE_CHANGED, AppLanguageChanged, mFramework);
 218     ui_app_add_event_handler(&handlers[APP_EVENT_REGION_FORMAT_CHANGED], APP_EVENT_REGION_FORMAT_CHANGED, AppRegionChanged, mFramework);
 219
 220     ret = ui_app_main(*mFramework->mArgc, *mFramework->mArgv, &mEventCallback, mFramework);
 221
 222     return ret;
 223   }
 224
 225   void AppNormalExit()
 226   {
 227       ui_app_exit();
 228   }
 229
 230 #ifdef APPCORE_WATCH_AVAILABLE
 231   static bool AppCreateWatch(int width, int height, void *data)
 232   {
 233     return static_cast<Framework*>(data)->Create();
 234   }
 235
 236   static void AppTimeTick(watch_time_h time, void *data)
 237   {
 238     Observer *observer = &static_cast<Framework*>(data)->mObserver;
 239     WatchTime curTime(time);
 240
 241     observer->OnTimeTick(curTime);
 242   }
 243
 244   static void AppAmbientTick(watch_time_h time, void *data)
 245   {
 246     Observer *observer = &static_cast<Framework*>(data)->mObserver;
 247     WatchTime curTime(time);
 248
 249     observer->OnAmbientTick(curTime);
 250   }
 251
 252   static void AppAmbientChanged(bool ambient, void *data)
 253   {
 254     Observer *observer = &static_cast<Framework*>(data)->mObserver;
 255
 256     observer->OnAmbientChanged(ambient);
 257   }
 258 #endif
 259
 260   int AppWatchMain()
 261   {
 262     int ret = true;
 263
 264 #ifdef APPCORE_WATCH_AVAILABLE
 265     mWatchCallback.create = AppCreateWatch;
 266     mWatchCallback.app_control = AppControl;
 267     mWatchCallback.terminate = AppTerminate;
 268     mWatchCallback.pause = AppPause;
 269     mWatchCallback.resume = AppResume;
 270     mWatchCallback.time_tick = AppTimeTick;
 271     mWatchCallback.ambient_tick = AppAmbientTick;
 272     mWatchCallback.ambient_changed = AppAmbientChanged;
 273
 274     watch_app_add_event_handler(&handlers[APP_EVENT_LOW_BATTERY], APP_EVENT_LOW_BATTERY, AppBatteryLow, mFramework);
 275     watch_app_add_event_handler(&handlers[APP_EVENT_LOW_MEMORY], APP_EVENT_LOW_MEMORY, AppMemoryLow, mFramework);
 276     watch_app_add_event_handler(&handlers[APP_EVENT_LANGUAGE_CHANGED], APP_EVENT_LANGUAGE_CHANGED, AppLanguageChanged, mFramework);
 277     watch_app_add_event_handler(&handlers[APP_EVENT_REGION_FORMAT_CHANGED], APP_EVENT_REGION_FORMAT_CHANGED, AppRegionChanged, mFramework);
 278
 279     ret = watch_app_main(*mFramework->mArgc, *mFramework->mArgv, &mWatchCallback, mFramework);
 280 #endif
 281     return ret;
 282   }
 283
 284   void AppWatchExit()
 285   {
 286 #ifdef APPCORE_WATCH_AVAILABLE
 287     watch_app_exit();
 288 #endif
 289   }
 290
 291   static void AppLanguageChanged(app_event_info_h event, void *data)
 292   {
 293     Observer *observer = &static_cast<Framework*>(data)->mObserver;
 294     observer->OnLanguageChanged("");
 295   }
 296
 297   static void AppDeviceRotated(app_event_info_h event_info, void *data)
 298   {
 299   }
 300
 301   static void AppRegionChanged(app_event_info_h event, void *data)
 302   {
 303     Observer *observer = &static_cast<Framework*>(data)->mObserver;
 304     observer->OnRegionChanged("");
 305   }
 306
 307   static void AppBatteryLow(app_event_info_h event, void *data)
 308   {
 309     Observer *observer = &static_cast<Framework*>(data)->mObserver;
 310     observer->OnBatteryLow(Dali::DevelApplication::BatteryStatus::NORMAL);
 311   }
 312
 313   static void AppMemoryLow(app_event_info_h event, void *data)
 314   {
 315     Observer *observer = &static_cast<Framework*>(data)->mObserver;
 316     observer->OnMemoryLow(Dali::DevelApplication::MemoryStatus::NORMAL);
 317   }
 318
 319 private:
 320   // Undefined
 321   Impl( const Impl& impl );
 322
 323   // Undefined
 324   Impl& operator=( const Impl& impl );
 325 };
 326
 327 Framework::Framework( Framework::Observer& observer, int *argc, char ***argv, Type type )
 328 : mObserver(observer),
 329   mInitialised(false),
 330   mRunning(false),
 331   mArgc(argc),
 332   mArgv(argv),
 333   mBundleName(""),
 334   mBundleId(""),
 335   mAbortHandler( MakeCallback( this, &Framework::AbortCallback ) ),
 336   mImpl(NULL)
 337 {
 338   bool featureFlag = true;
 339   system_info_get_platform_bool( "tizen.org/feature/opengles.version.2_0", &featureFlag );
 340
 341   if( featureFlag == false )
 342   {
 343     set_last_result( TIZEN_ERROR_NOT_SUPPORTED );
 344   }
 345 #ifdef DALI_ELDBUS_AVAILABLE
 346   // Initialize ElDBus.
 347   DALI_LOG_INFO( gDBusLogging, Debug::General, "Starting DBus Initialization\n" );
 348   eldbus_init();
 349 #endif
 350   InitThreads();
 351
 352   mImpl = new Impl(this, type);
 353 }
 354
 355 Framework::~Framework()
 356 {
 357   if (mRunning)
 358   {
 359     Quit();
 360   }
 361
 362 #ifdef DALI_ELDBUS_AVAILABLE
 363   // Shutdown ELDBus.
 364   DALI_LOG_INFO( gDBusLogging, Debug::General, "Shutting down DBus\n" );
 365   eldbus_shutdown();
 366 #endif
 367
 368   delete mImpl;
 369 }
 370
 371 bool Framework::Create()
 372 {
 373   mInitialised = true;
 374   mObserver.OnInit();
 375   return true;
 376 }
 377
 378 void Framework::Run()
 379 {
 380   mRunning = true;
 381   int ret;
 382
 383   ret = mImpl->AppMain();
 384   if (ret != APP_ERROR_NONE)
 385   {
 386     DALI_LOG_ERROR("Framework::Run(), ui_app_main() is failed. err = %d\n", ret);
 387   }
 388   mRunning = false;
 389 }
 390
 391 void Framework::Quit()
 392 {
 393   mImpl->AppExit();
 394 }
 395
 396 bool Framework::IsMainLoopRunning()
 397 {
 398   return mRunning;
 399 }
 400
 401 void Framework::AddAbortCallback( CallbackBase* callback )
 402 {
 403   mImpl->mAbortCallBack = callback;
 404 }
 405
 406 std::string Framework::GetBundleName() const
 407 {
 408   return mBundleName;
 409 }
 410
 411 void Framework::SetBundleName(const std::string& name)
 412 {
 413   mBundleName = name;
 414 }
 415
 416 std::string Framework::GetBundleId() const
 417 {
 418   return mBundleId;
 419 }
 420
 421 std::string Framework::GetResourcePath()
 422 {
 423   std::string resourcePath = "";
 424 #if defined( TIZEN_PLATFORM_CONFIG_SUPPORTED ) && TIZEN_PLATFORM_CONFIG_SUPPORTED
 425   resourcePath = app_get_resource_path();
 426 #else // For backwards compatibility with older Tizen versions
 427
 428   // "DALI_APPLICATION_PACKAGE" is used to get the already configured Application package path.
 429   const char* environmentVariable = "DALI_APPLICATION_PACKAGE";
 430   char* value = getenv( environmentVariable );
 431   if ( value != NULL )
 432   {
 433     resourcePath = value;
 434   }
 435 #endif //TIZEN_PLATFORM_CONFIG_SUPPORTED
 436
 437   return resourcePath;
 438 }
 439
 440 void Framework::SetBundleId(const std::string& id)
 441 {
 442   mBundleId = id;
 443 }
 444
 445 void Framework::AbortCallback( )
 446 {
 447   // if an abort call back has been installed run it.
 448   if (mImpl->mAbortCallBack)
 449   {
 450     CallbackBase::Execute( *mImpl->mAbortCallBack );
 451   }
 452   else
 453   {
 454     Quit();
 455   }
 456 }
 457
 458 } // namespace Adaptor
 459
 460 } // namespace Internal
 461
 462 } // namespace Dali