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