android/android_api/base/jni/JniOnDeleteListener.cpp

   1 /*
   2 * //******************************************************************
   3 * //
   4 * // Copyright 2015 Intel Corporation.
   5 * //
   6 * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   7 * //
   8 * // Licensed under the Apache License, Version 2.0 (the "License");
   9 * // you may not use this file except in compliance with the License.
  10 * // You may obtain a copy of the License at
  11 * //
  12 * //      http://www.apache.org/licenses/LICENSE-2.0
  13 * //
  14 * // Unless required by applicable law or agreed to in writing, software
  15 * // distributed under the License is distributed on an "AS IS" BASIS,
  16 * // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17 * // See the License for the specific language governing permissions and
  18 * // limitations under the License.
  19 * //
  20 * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  21 */
  22
  23 #include "JniOnDeleteListener.h"
  24 #include "JniOcResource.h"
  25 #include "JniUtils.h"
  26 #ifdef WITH_CLOUD
  27 #include "JniOcAccountManager.h"
  28 #endif
  29
  30 JniOnDeleteListener::JniOnDeleteListener(JNIEnv *env, jobject jListener, JniOcResource* owner)
  31     : m_ownerResource(owner)
  32 {
  33     m_jwListener = env->NewWeakGlobalRef(jListener);
  34 #ifdef WITH_CLOUD
  35     m_ownerAccountManager = nullptr;
  36 #endif
  37 }
  38
  39 #ifdef WITH_CLOUD
  40 JniOnDeleteListener::JniOnDeleteListener(JNIEnv *env, jobject jListener, JniOcAccountManager* owner)
  41     : m_ownerAccountManager(owner)
  42 {
  43     m_jwListener = env->NewWeakGlobalRef(jListener);
  44     m_ownerResource = nullptr;
  45 }
  46 #endif
  47
  48 JniOnDeleteListener::~JniOnDeleteListener()
  49 {
  50     if (m_jwListener)
  51     {
  52         jint ret = JNI_ERR;
  53         JNIEnv *env = GetJNIEnv(ret);
  54         if (nullptr == env)
  55         {
  56             return;
  57         }
  58         env->DeleteWeakGlobalRef(m_jwListener);
  59         m_jwListener = nullptr;
  60
  61         if (JNI_EDETACHED == ret)
  62         {
  63             g_jvm->DetachCurrentThread();
  64         }
  65     }
  66 }
  67
  68 void JniOnDeleteListener::onDeleteCallback(const HeaderOptions& headerOptions, const int eCode)
  69 {
  70     jint envRet = JNI_ERR;
  71     JNIEnv *env = GetJNIEnv(envRet);
  72     if (nullptr == env)
  73     {
  74         return;
  75     }
  76
  77     jobject jListener = env->NewLocalRef(m_jwListener);
  78     if (!jListener)
  79     {
  80         checkExAndRemoveListener(env);
  81         if (JNI_EDETACHED == envRet)
  82         {
  83             g_jvm->DetachCurrentThread();
  84         }
  85         return;
  86     }
  87     jclass clsL = env->GetObjectClass(jListener);
  88     if (!clsL)
  89     {
  90         checkExAndRemoveListener(env);
  91         if (JNI_EDETACHED == envRet)
  92         {
  93             g_jvm->DetachCurrentThread();
  94         }
  95         return;
  96     }
  97
  98     if (OC_STACK_RESOURCE_DELETED != eCode)
  99     {
 100         jobject ex = GetOcException(eCode, "stack error in onDeleteCallback");
 101         if (!ex)
 102         {
 103             checkExAndRemoveListener(env);
 104             if (JNI_EDETACHED == envRet)
 105             {
 106                 g_jvm->DetachCurrentThread();
 107             }
 108             return;
 109         }
 110         jmethodID midL = env->GetMethodID(clsL, "onDeleteFailed", "(Ljava/lang/Throwable;)V");
 111         if (!midL)
 112         {
 113             checkExAndRemoveListener(env);
 114             if (JNI_EDETACHED == envRet)
 115             {
 116                 g_jvm->DetachCurrentThread();
 117             }
 118             return;
 119         }
 120         env->CallVoidMethod(jListener, midL, ex);
 121     }
 122     else
 123     {
 124         jobject jHeaderOptionList = JniUtils::convertHeaderOptionsVectorToJavaList(env, headerOptions);
 125         if (!jHeaderOptionList)
 126         {
 127             checkExAndRemoveListener(env);
 128             if (JNI_EDETACHED == envRet)
 129             {
 130                 g_jvm->DetachCurrentThread();
 131             }
 132             return;
 133         }
 134
 135         jmethodID midL = env->GetMethodID(clsL, "onDeleteCompleted", "(Ljava/util/List;)V");
 136         if (!midL)
 137         {
 138             checkExAndRemoveListener(env);
 139             if (JNI_EDETACHED == envRet)
 140             {
 141                 g_jvm->DetachCurrentThread();
 142             }
 143             return;
 144         }
 145         env->CallVoidMethod(jListener, midL, jHeaderOptionList);
 146     }
 147
 148     checkExAndRemoveListener(env);
 149     if (JNI_EDETACHED == envRet)
 150     {
 151         g_jvm->DetachCurrentThread();
 152     }
 153 }
 154
 155 void JniOnDeleteListener::checkExAndRemoveListener(JNIEnv* env)
 156 {
 157     if (env->ExceptionCheck())
 158     {
 159         jthrowable ex = env->ExceptionOccurred();
 160         env->ExceptionClear();
 161 #ifndef WITH_CLOUD
 162         m_ownerResource->removeOnDeleteListener(env, m_jwListener);
 163 #else
 164         if (nullptr != m_ownerResource)
 165         {
 166             m_ownerResource->removeOnDeleteListener(env, m_jwListener);
 167         }
 168         if (nullptr != m_ownerAccountManager)
 169         {
 170             m_ownerAccountManager->removeOnDeleteListener(env, m_jwListener);
 171         }
 172 #endif
 173         env->Throw((jthrowable)ex);
 174     }
 175     else
 176     {
 177 #ifndef WITH_CLOUD
 178         m_ownerResource->removeOnDeleteListener(env, m_jwListener);
 179 #else
 180         if (nullptr != m_ownerResource)
 181         {
 182             m_ownerResource->removeOnDeleteListener(env, m_jwListener);
 183         }
 184         if (nullptr != m_ownerAccountManager)
 185         {
 186             m_ownerAccountManager->removeOnDeleteListener(env, m_jwListener);
 187         }
 188 #endif
 189     }
 190 }