dali/internal/adaptor/androidjni/framework-androidjni.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 <dali/devel-api/adaptor-framework/application-devel.h>
  23 #include <dali/integration-api/adaptor-framework/adaptor.h>
  24 #include <dali/integration-api/adaptor-framework/android/android-framework.h>
  25 #include <dali/integration-api/debug.h>
  26 #include <dali/public-api/adaptor-framework/application.h>
  27
  28 // INTERNAL INCLUDES
  29 #include <dali/internal/adaptor/android/android-framework-impl.h>
  30 #include <dali/internal/adaptor/common/application-impl.h>
  31 #include <dali/internal/system/common/callback-manager.h>
  32
  33 using namespace Dali;
  34
  35 namespace Dali
  36 {
  37 namespace Internal
  38 {
  39 namespace Adaptor
  40 {
  41 /**
  42  * Impl to hide android data members
  43  */
  44 struct Framework::Impl
  45 {
  46   // Constructor
  47
  48   Impl(Framework* framework)
  49   : mAbortCallBack(nullptr),
  50     mCallbackManager(CallbackManager::New()),
  51     mLanguage("NOT_SUPPORTED"),
  52     mRegion("NOT_SUPPORTED")
  53   {
  54     AndroidFramework::GetImplementation(AndroidFramework::Get()).SetFramework(framework);
  55   }
  56
  57   ~Impl()
  58   {
  59     AndroidFramework::GetImplementation(AndroidFramework::Get()).SetFramework(nullptr);
  60
  61     delete mAbortCallBack;
  62     mAbortCallBack = nullptr;
  63
  64     // we're quiting the main loop so
  65     // mCallbackManager->RemoveAllCallBacks() does not need to be called
  66     // to delete our abort handler
  67     delete mCallbackManager;
  68     mCallbackManager = nullptr;
  69   }
  70
  71   std::string GetLanguage() const
  72   {
  73     return mLanguage;
  74   }
  75
  76   std::string GetRegion() const
  77   {
  78     return mRegion;
  79   }
  80
  81   CallbackBase*    mAbortCallBack;
  82   CallbackManager* mCallbackManager;
  83   std::string      mLanguage;
  84   std::string      mRegion;
  85 };
  86
  87 Framework::Framework(Framework::Observer& observer, int* argc, char*** argv, Type type)
  88 : mObserver(observer),
  89   mInitialised(false),
  90   mPaused(false),
  91   mRunning(false),
  92   mArgc(argc),
  93   mArgv(argv),
  94   mBundleName(""),
  95   mBundleId(""),
  96   mAbortHandler(MakeCallback(this, &Framework::AbortCallback)),
  97   mImpl(NULL)
  98 {
  99   mImpl = new Impl(this);
 100 }
 101
 102 Framework::~Framework()
 103 {
 104   if(mRunning)
 105   {
 106     Quit();
 107   }
 108
 109   delete mImpl;
 110   mImpl = nullptr;
 111 }
 112
 113 void Framework::Run()
 114 {
 115   AndroidFramework::GetImplementation(AndroidFramework::Get()).SetFramework(this);
 116   mRunning = true;
 117 }
 118
 119 unsigned int Framework::AddIdle(int timeout, void* data, bool (*callback)(void* data))
 120 {
 121   JNIEnv* env    = nullptr;
 122   JavaVM* javaVM = AndroidFramework::Get().GetJVM();
 123   if(javaVM == nullptr || javaVM->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK)
 124   {
 125     DALI_LOG_ERROR("Couldn't get JNI env.");
 126     return -1;
 127   }
 128
 129   jclass clazz = env->FindClass("com/sec/daliview/DaliView");
 130   if(!clazz)
 131   {
 132     DALI_LOG_ERROR("Couldn't find com.sec.daliview.DaliView.");
 133     return -1;
 134   }
 135
 136   jmethodID addIdle = env->GetStaticMethodID(clazz, "addIdle", "(JJJ)I");
 137   if(!addIdle)
 138   {
 139     DALI_LOG_ERROR("Couldn't find com.sec.daliview.DaliView.addIdle.");
 140     return -1;
 141   }
 142
 143   jint id = env->CallStaticIntMethod(clazz, addIdle, reinterpret_cast<jlong>(callback), reinterpret_cast<jlong>(data), static_cast<jlong>(timeout));
 144   return static_cast<unsigned int>(id);
 145 }
 146
 147 void Framework::RemoveIdle(unsigned int id)
 148 {
 149   JNIEnv* env    = nullptr;
 150   JavaVM* javaVM = AndroidFramework::Get().GetJVM();
 151   if(javaVM == nullptr || javaVM->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK)
 152   {
 153     DALI_LOG_ERROR("Couldn't get JNI env.");
 154     return;
 155   }
 156
 157   jclass clazz = env->FindClass("com/sec/daliview/DaliView");
 158   if(!clazz)
 159   {
 160     DALI_LOG_ERROR("Couldn't find com.sec.daliview.DaliView.");
 161     return;
 162   }
 163
 164   jmethodID removeIdle = env->GetStaticMethodID(clazz, "removeIdle", "(I)V");
 165   if(!removeIdle)
 166   {
 167     DALI_LOG_ERROR("Couldn't find com.sec.daliview.DaliView.removeIdle.");
 168     return;
 169   }
 170
 171   env->CallStaticVoidMethod(clazz, removeIdle, static_cast<jint>(id));
 172 }
 173
 174 void Framework::Quit()
 175 {
 176   DALI_LOG_ERROR("Quit does nothing for DaliView!");
 177 }
 178
 179 bool Framework::IsMainLoopRunning()
 180 {
 181   return mRunning;
 182 }
 183
 184 void Framework::AddAbortCallback(CallbackBase* callback)
 185 {
 186   mImpl->mAbortCallBack = callback;
 187 }
 188
 189 std::string Framework::GetBundleName() const
 190 {
 191   return mBundleName;
 192 }
 193
 194 void Framework::SetBundleName(const std::string& name)
 195 {
 196   mBundleName = name;
 197 }
 198
 199 std::string Framework::GetBundleId() const
 200 {
 201   return mBundleId;
 202 }
 203
 204 std::string Framework::GetResourcePath()
 205 {
 206   return DALI_DATA_RO_DIR;
 207 }
 208
 209 std::string Framework::GetDataPath()
 210 {
 211   return "";
 212 }
 213
 214 void Framework::SetBundleId(const std::string& id)
 215 {
 216   mBundleId = id;
 217 }
 218
 219 void Framework::AbortCallback()
 220 {
 221   // if an abort call back has been installed run it.
 222   if(mImpl->mAbortCallBack)
 223   {
 224     CallbackBase::Execute(*mImpl->mAbortCallBack);
 225   }
 226   else
 227   {
 228     Quit();
 229   }
 230 }
 231
 232 bool Framework::AppStatusHandler(int type, void* data)
 233 {
 234   Dali::Adaptor* adaptor = nullptr;
 235   switch(type)
 236   {
 237     case APP_WINDOW_CREATED:
 238       if(!mInitialised)
 239       {
 240         mObserver.OnInit();
 241         mInitialised = true;
 242       }
 243
 244       mObserver.OnSurfaceCreated(data);
 245       break;
 246
 247     case APP_WINDOW_DESTROYED:
 248       mObserver.OnSurfaceDestroyed(data);
 249       break;
 250
 251     case APP_RESET:
 252       mObserver.OnReset();
 253       break;
 254
 255     case APP_RESUME:
 256       mObserver.OnResume();
 257       adaptor = &Dali::Adaptor::Get();
 258       adaptor->Resume();
 259       break;
 260
 261     case APP_PAUSE:
 262       adaptor = &Dali::Adaptor::Get();
 263       adaptor->Pause();
 264       mObserver.OnPause();
 265       break;
 266
 267     case APP_LANGUAGE_CHANGE:
 268       mObserver.OnLanguageChanged();
 269       break;
 270
 271     case APP_DESTROYED:
 272       mObserver.OnTerminate();
 273       mRunning     = false;
 274       mPaused      = false;
 275       mInitialised = false;
 276       break;
 277
 278     default:
 279       break;
 280   }
 281
 282   return true;
 283 }
 284
 285 void Framework::InitThreads()
 286 {
 287 }
 288
 289 std::string Framework::GetLanguage() const
 290 {
 291   return mImpl->GetLanguage();
 292 }
 293
 294 std::string Framework::GetRegion() const
 295 {
 296   return mImpl->GetRegion();
 297 }
 298
 299 } // namespace Adaptor
 300
 301 } // namespace Internal
 302
 303 } // namespace Dali