dali/internal/adaptor/ubuntu/framework-ubuntu.cpp

   1 /*
   2  * Copyright (c) 2021 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 <dali/internal/adaptor/common/framework.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <X11/Xlib.h>
  23 #include <dali/internal/system/linux/dali-ecore.h>
  24 #include <dali/internal/system/linux/dali-efreet.h>
  25 #include <dali/internal/system/linux/dali-elementary.h>
  26
  27 #include <dali/integration-api/debug.h>
  28
  29 // INTERNAL INCLUDES
  30 #include <dali/internal/system/common/callback-manager.h>
  31
  32 namespace Dali
  33 {
  34 namespace Internal
  35 {
  36 namespace Adaptor
  37 {
  38 namespace
  39 {
  40 /// Application Status Enum
  41 enum
  42 {
  43   APP_CREATE,
  44   APP_TERMINATE,
  45   APP_PAUSE,
  46   APP_RESUME,
  47   APP_RESET,
  48   APP_LANGUAGE_CHANGE,
  49 };
  50
  51 } // Unnamed namespace
  52
  53 /**
  54  * Impl to hide EFL data members
  55  */
  56 struct Framework::Impl
  57 {
  58   // Constructor
  59
  60   Impl(void* data)
  61   : mAbortCallBack(NULL),
  62     mCallbackManager(CallbackManager::New()),
  63     mLanguage("NOT_SUPPORTED"),
  64     mRegion("NOT_SUPPORTED")
  65   {
  66   }
  67
  68   ~Impl()
  69   {
  70     delete mAbortCallBack;
  71
  72     // we're quiting the main loop so
  73     // mCallbackManager->RemoveAllCallBacks() does not need to be called
  74     // to delete our abort handler
  75     delete mCallbackManager;
  76   }
  77
  78   std::string GetLanguage() const
  79   {
  80     return mLanguage;
  81   }
  82
  83   std::string GetRegion() const
  84   {
  85     return mRegion;
  86   }
  87
  88   // Data
  89   CallbackBase*    mAbortCallBack;
  90   CallbackManager* mCallbackManager;
  91   std::string      mLanguage;
  92   std::string      mRegion;
  93
  94   // Static methods
  95
  96   /**
  97    * Called by AppCore on application creation.
  98    */
  99   static bool AppCreate(void* data)
 100   {
 101     return static_cast<Framework*>(data)->AppStatusHandler(APP_CREATE, NULL);
 102   }
 103
 104   /**
 105    * Called by AppCore when the application should terminate.
 106    */
 107   static void AppTerminate(void* data)
 108   {
 109     static_cast<Framework*>(data)->AppStatusHandler(APP_TERMINATE, NULL);
 110   }
 111
 112   /**
 113    * Called by AppCore when the application is paused.
 114    */
 115   static void AppPause(void* data)
 116   {
 117     static_cast<Framework*>(data)->AppStatusHandler(APP_PAUSE, NULL);
 118   }
 119
 120   /**
 121    * Called by AppCore when the application is resumed.
 122    */
 123   static void AppResume(void* data)
 124   {
 125     static_cast<Framework*>(data)->AppStatusHandler(APP_RESUME, NULL);
 126   }
 127
 128   /**
 129    * Called by AppCore when the language changes on the device.
 130    */
 131   static void AppLanguageChange(void* data)
 132   {
 133     static_cast<Framework*>(data)->AppStatusHandler(APP_LANGUAGE_CHANGE, NULL);
 134   }
 135 };
 136
 137 Framework::Framework(Framework::Observer& observer, Framework::TaskObserver& taskObserver, int* argc, char*** argv, Type type, bool useUiThread)
 138 : mObserver(observer),
 139   mTaskObserver(taskObserver),
 140   mInitialised(false),
 141   mPaused(false),
 142   mRunning(false),
 143   mArgc(argc),
 144   mArgv(argv),
 145   mBundleName(""),
 146   mBundleId(""),
 147   mAbortHandler(MakeCallback(this, &Framework::AbortCallback)),
 148   mImpl(NULL)
 149 {
 150   InitThreads();
 151   mImpl = new Impl(this);
 152 }
 153
 154 Framework::~Framework()
 155 {
 156   if(mRunning)
 157   {
 158     Quit();
 159   }
 160
 161   delete mImpl;
 162 }
 163
 164 void Framework::Run()
 165 {
 166   mRunning = true;
 167
 168   efreet_cache_disable();
 169   elm_init(mArgc ? *mArgc : 0, mArgv ? *mArgv : nullptr);
 170
 171   Impl::AppCreate(this);
 172
 173   elm_run();
 174
 175   mRunning = false;
 176 }
 177
 178 void Framework::Quit()
 179 {
 180   Impl::AppTerminate(this);
 181
 182   elm_exit();
 183 }
 184
 185 bool Framework::IsMainLoopRunning()
 186 {
 187   return mRunning;
 188 }
 189
 190 void Framework::AddAbortCallback(CallbackBase* callback)
 191 {
 192   mImpl->mAbortCallBack = callback;
 193 }
 194
 195 std::string Framework::GetBundleName() const
 196 {
 197   return mBundleName;
 198 }
 199
 200 void Framework::SetBundleName(const std::string& name)
 201 {
 202   mBundleName = name;
 203 }
 204
 205 std::string Framework::GetBundleId() const
 206 {
 207   return mBundleId;
 208 }
 209
 210 std::string Framework::GetResourcePath()
 211 {
 212   // "DALI_APPLICATION_PACKAGE" is used by Ubuntu specifically to get the already configured Application package path.
 213   const char* ubuntuEnvironmentVariable = "DALI_APPLICATION_PACKAGE";
 214   char*       value                     = getenv(ubuntuEnvironmentVariable);
 215   std::string resourcePath;
 216   if(value != NULL)
 217   {
 218     resourcePath = value;
 219   }
 220
 221   if(resourcePath.back() != '/')
 222   {
 223     resourcePath += "/";
 224   }
 225
 226   return resourcePath;
 227 }
 228
 229 std::string Framework::GetDataPath()
 230 {
 231   const char* ubuntuEnvironmentVariable = "DALI_APPLICATION_DATA_DIR";
 232   char*       value                     = getenv(ubuntuEnvironmentVariable);
 233   std::string dataPath;
 234   if(value != NULL)
 235   {
 236     dataPath = value;
 237   }
 238
 239   return dataPath;
 240 }
 241
 242 void Framework::SetBundleId(const std::string& id)
 243 {
 244   mBundleId = id;
 245 }
 246
 247 void Framework::AbortCallback()
 248 {
 249   // if an abort call back has been installed run it.
 250   if(mImpl->mAbortCallBack)
 251   {
 252     CallbackBase::Execute(*mImpl->mAbortCallBack);
 253   }
 254   else
 255   {
 256     Quit();
 257   }
 258 }
 259
 260 bool Framework::AppStatusHandler(int type, void* bundleData)
 261 {
 262   switch(type)
 263   {
 264     case APP_CREATE:
 265     {
 266       mInitialised = true;
 267
 268       mObserver.OnInit();
 269       break;
 270     }
 271
 272     case APP_RESET:
 273       mObserver.OnReset();
 274       break;
 275
 276     case APP_RESUME:
 277       mObserver.OnResume();
 278       break;
 279
 280     case APP_TERMINATE:
 281       mObserver.OnTerminate();
 282       break;
 283
 284     case APP_PAUSE:
 285       mObserver.OnPause();
 286       break;
 287
 288     case APP_LANGUAGE_CHANGE:
 289       mObserver.OnLanguageChanged();
 290       break;
 291
 292     default:
 293       break;
 294   }
 295
 296   return true;
 297 }
 298
 299 void Framework::InitThreads()
 300 {
 301   XInitThreads();
 302 }
 303
 304 std::string Framework::GetLanguage() const
 305 {
 306   return mImpl->GetLanguage();
 307 }
 308
 309 std::string Framework::GetRegion() const
 310 {
 311   return mImpl->GetRegion();
 312 }
 313
 314 } // namespace Adaptor
 315
 316 } // namespace Internal
 317
 318 } // namespace Dali