android/android_api/base/jni/JniOnMQTopicFoundListener.cpp

   1 /* ****************************************************************
   2  *
   3  * Copyright 2016 Samsung Electronics All Rights Reserved.
   4  *
   5  *
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  ******************************************************************/
  20
  21 #include "JniOnMQTopicFoundListener.h"
  22 #include "JniOcResource.h"
  23 #include "JniOcRepresentation.h"
  24 #include "JniUtils.h"
  25
  26 JniOnMQTopicFoundListener::JniOnMQTopicFoundListener(JNIEnv *env, jobject jListener,
  27                                                      RemoveListenerCallback removeListener)
  28     : m_removeListener(removeListener)
  29 {
  30     m_jwListener = env->NewWeakGlobalRef(jListener);
  31 }
  32
  33 JniOnMQTopicFoundListener::~JniOnMQTopicFoundListener()
  34 {
  35     if (m_jwListener)
  36     {
  37         jint ret = JNI_ERR;
  38         JNIEnv *env = GetJNIEnv(ret);
  39         if (nullptr == env)
  40         {
  41             return;
  42         }
  43
  44         env->DeleteWeakGlobalRef(m_jwListener);
  45         m_jwListener = nullptr;
  46
  47         if (JNI_EDETACHED == ret)
  48         {
  49             g_jvm->DetachCurrentThread();
  50         }
  51     }
  52 }
  53
  54 void JniOnMQTopicFoundListener::foundTopicCallback(const int eCode, const std::string& uri,
  55                                                    std::shared_ptr<OC::OCResource> resource)
  56 {
  57     jint ret = JNI_ERR;
  58     JNIEnv *env = GetJNIEnv(ret);
  59     if (nullptr == env)
  60     {
  61         return;
  62     }
  63
  64     jobject jListener = env->NewLocalRef(m_jwListener);
  65     if (!jListener)
  66     {
  67         checkExAndRemoveListener(env);
  68         if (JNI_EDETACHED == ret)
  69         {
  70             g_jvm->DetachCurrentThread();
  71         }
  72         return;
  73     }
  74
  75     jclass clsL = env->GetObjectClass(jListener);
  76     if (!clsL)
  77     {
  78         env->DeleteLocalRef(jListener);
  79         checkExAndRemoveListener(env);
  80         if (JNI_EDETACHED == ret)
  81         {
  82             g_jvm->DetachCurrentThread();
  83         }
  84         return;
  85     }
  86
  87     if (OC_STACK_OK != eCode)
  88     {
  89         jobject ex = GetOcException(eCode, "stack error");
  90         if (!ex)
  91         {
  92             goto JNI_EXIT;
  93         }
  94         jmethodID midL = env->GetMethodID(clsL, "onDiscoveryTopicFailed",
  95                                           "(Ljava/lang/Throwable;Ljava/lang/String;)V");
  96         if (!midL)
  97         {
  98             goto JNI_EXIT;
  99         }
 100
 101         env->CallVoidMethod(jListener, midL, ex, env->NewStringUTF(uri.c_str()));
 102     }
 103     else
 104     {
 105
 106         jobject jResource = env->NewObject(g_cls_OcResource, g_mid_OcResource_ctor);
 107         if (!jResource)
 108         {
 109             goto JNI_EXIT;
 110         }
 111
 112         JniOcResource *jniOcResource = new JniOcResource(resource);
 113         SetHandle<JniOcResource>(env, jResource, jniOcResource);
 114         if (env->ExceptionCheck())
 115         {
 116             delete jniOcResource;
 117             env->DeleteLocalRef(jResource);
 118             goto JNI_EXIT;
 119         }
 120
 121         jmethodID midL = env->GetMethodID(clsL, "onTopicDiscoveried", "(Lorg/iotivity/base/OcResource;)V");
 122         if (!midL)
 123         {
 124             delete jniOcResource;
 125             env->DeleteLocalRef(jResource);
 126             goto JNI_EXIT;
 127         }
 128         env->CallVoidMethod(jListener, midL, jResource);
 129         if (env->ExceptionCheck())
 130         {
 131             LOGE("Java exception is thrown");
 132             delete jniOcResource;
 133             env->DeleteLocalRef(jResource);
 134             goto JNI_EXIT;
 135         }
 136     }
 137
 138     env->DeleteLocalRef(clsL);
 139     env->DeleteLocalRef(jListener);
 140     if (JNI_EDETACHED == ret)
 141     {
 142         g_jvm->DetachCurrentThread();
 143     }
 144     return;
 145
 146 JNI_EXIT:
 147     env->DeleteLocalRef(clsL);
 148     env->DeleteLocalRef(jListener);
 149     checkExAndRemoveListener(env);
 150     if (JNI_EDETACHED == ret)
 151     {
 152         g_jvm->DetachCurrentThread();
 153     }
 154 }
 155
 156 void JniOnMQTopicFoundListener::createdTopicCallback(const int eCode, const std::string& uri,
 157                                                      std::shared_ptr<OC::OCResource> resource)
 158 {
 159     jint envRet = JNI_ERR;
 160     JNIEnv *env = GetJNIEnv(envRet);
 161     if (nullptr == env)
 162     {
 163         return;
 164     }
 165
 166     jobject jListener = env->NewLocalRef(m_jwListener);
 167     if (!jListener)
 168     {
 169         checkExAndRemoveListener(env);
 170         if (JNI_EDETACHED == envRet)
 171         {
 172             g_jvm->DetachCurrentThread();
 173         }
 174         return;
 175     }
 176
 177     jclass clsL = env->GetObjectClass(jListener);
 178     if (!clsL)
 179     {
 180         env->DeleteLocalRef(jListener);
 181         checkExAndRemoveListener(env);
 182         if (JNI_EDETACHED == envRet)
 183         {
 184             g_jvm->DetachCurrentThread();
 185         }
 186         return;
 187     }
 188
 189     if (OC_STACK_OK != eCode && OC_STACK_RESOURCE_CREATED != eCode &&
 190             OC_STACK_RESOURCE_CHANGED != eCode)
 191     {
 192         jobject ex = GetOcException(eCode, "stack error");
 193         if (!ex)
 194         {
 195             goto JNI_EXIT;
 196         }
 197         jmethodID midL = env->GetMethodID(clsL, "onCreateTopicFailed",
 198                                           "(Ljava/lang/Throwable;Ljava/lang/String;)V");
 199         if (!midL)
 200         {
 201             goto JNI_EXIT;
 202         }
 203
 204         env->CallVoidMethod(jListener, midL, ex, env->NewStringUTF(uri.c_str()));
 205     }
 206     else
 207     {
 208         // create Resource object
 209         jobject jResource = env->NewObject(g_cls_OcResource, g_mid_OcResource_ctor);
 210         if (!jResource)
 211         {
 212             goto JNI_EXIT;
 213         }
 214
 215         JniOcResource *jniOcResource = new JniOcResource(resource);
 216         SetHandle<JniOcResource>(env, jResource, jniOcResource);
 217         if (env->ExceptionCheck())
 218         {
 219             delete jniOcResource;
 220             env->DeleteLocalRef(jResource);
 221             goto JNI_EXIT;
 222         }
 223
 224         jmethodID midL = env->GetMethodID(clsL, "onTopicResourceCreated",
 225             "(Lorg/iotivity/base/OcResource;)V");
 226         if (!midL)
 227         {
 228             delete jniOcResource;
 229             env->DeleteLocalRef(jResource);
 230             goto JNI_EXIT;
 231         }
 232
 233         env->CallVoidMethod(jListener, midL, jResource);
 234         if (env->ExceptionCheck())
 235         {
 236             LOGE("Java exception is thrown");
 237             env->DeleteLocalRef(jResource);
 238             delete jniOcResource;
 239         }
 240     }
 241
 242 JNI_EXIT:
 243     env->DeleteLocalRef(clsL);
 244     env->DeleteLocalRef(jListener);
 245     checkExAndRemoveListener(env);
 246     if (JNI_EDETACHED == envRet)
 247     {
 248         g_jvm->DetachCurrentThread();
 249     }
 250 }
 251
 252 void JniOnMQTopicFoundListener::checkExAndRemoveListener(JNIEnv* env)
 253 {
 254     if (env->ExceptionCheck())
 255     {
 256         jthrowable ex = env->ExceptionOccurred();
 257         env->ExceptionClear();
 258         m_removeListener(env, m_jwListener);
 259         env->Throw((jthrowable)ex);
 260     }
 261     else
 262     {
 263         m_removeListener(env, m_jwListener);
 264     }
 265 }