service/things-manager/sdk/java/jni/tm/src/jni_things_manager_callbacks.cpp

   1 /******************************************************************
   2  *
   3  * Copyright 2015 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 #include "jni_things_manager_callbacks.h"
  21 #include "JniOcResource.h"
  22 #include "ThingsManager.h"
  23 #include "jni_things_manager_jvm.h"
  24 #include "jni_string.h"
  25
  26 #define LOG_TAG "ThingsManagerCallbacks"
  27
  28 #define METHOD_ONRESOURCE_CALLBACK    "(" TM_JAVA_VECTOR_TYPE")V"
  29 #define METHOD_ONGROUP_FIND_CALLBACK    "(" TM_SERVICE_OCRESOURCE_TYPE")V"
  30 #define METHOD_ONPRESENCE_CALLBACK    "(" TM_JAVA_STRING_TYPE"I)V"
  31 #define METHOD_ONUPDATE_CONF_CALLBACK    "(" TM_JAVA_VECTOR_TYPE TM_SERVICE_OCREPRESENTATION_TYPE"I)V"
  32 #define METHOD_ONGET_CONF_CALLBACK    "(" TM_JAVA_VECTOR_TYPE TM_SERVICE_OCREPRESENTATION_TYPE"I)V"
  33 #define METHOD_ONBOOT_STRAP_CALLBACK    "(" TM_JAVA_VECTOR_TYPE TM_SERVICE_OCREPRESENTATION_TYPE"I)V"
  34 #define METHOD_ONFACTORY_RESET_CALLBACK    "(" TM_JAVA_VECTOR_TYPE TM_SERVICE_OCREPRESENTATION_TYPE"I)V"
  35 #define METHOD_ONREBOOT_CALLBACK    "(" TM_JAVA_VECTOR_TYPE TM_SERVICE_OCREPRESENTATION_TYPE"I)V"
  36 #define METHOD_ONPOST_CALLBACK    "(" TM_JAVA_VECTOR_TYPE TM_SERVICE_OCREPRESENTATION_TYPE"I)V"
  37 #define METHOD_ONPUT_CALLBACK    "(" TM_JAVA_VECTOR_TYPE TM_SERVICE_OCREPRESENTATION_TYPE"I)V"
  38 #define METHOD_ONGET_CALLBACK    "(" TM_JAVA_VECTOR_TYPE TM_SERVICE_OCREPRESENTATION_TYPE"I)V"
  39 #define METHOD_TMCALLBACK_GETINSTANCE    "()" TM_SERVICE_CALLBACK_CLASS_TYPE
  40
  41 jobject OcResourceToJava(JNIEnv *env, jlong resource)
  42 {
  43     jclass resourceClass = GetJClass(TM_SERVICE_OCRESOURCE_PATH);
  44     if (NULL == resourceClass)
  45     {
  46         LOGE("OcResourceToJava : failed to find OCResouce java class!");
  47         return NULL;
  48     }
  49
  50     jmethodID constructor = env->GetMethodID(resourceClass, "<init>", "(J)V");
  51     if (NULL == constructor)
  52     {
  53         LOGE("OcResourceToJava: Failed to get constructor method!");
  54         return NULL;
  55     }
  56
  57     jobject resourceObj = (jobject) env->NewObject(resourceClass, constructor, resource);
  58     if (NULL == resourceObj)
  59     {
  60         LOGE("OcResourceToJava: Failed to create OCResouce java object!");
  61         return NULL;
  62     }
  63
  64     return resourceObj;
  65 }
  66
  67 jobject OcHeaderOptionToJava(JNIEnv *env, OC::HeaderOption::OCHeaderOption headerOption)
  68 {
  69     JString *optionData = new JString(env, headerOption.getOptionData());
  70     if (!optionData)
  71     {
  72         LOGE("OcHeaderOptionToJava : failed to get JString!");
  73         return NULL;
  74     }
  75
  76     jclass headerOptionClass = GetJClass(TM_SERVICE_HEADER_OPTION_PATH);
  77     if (NULL == headerOptionClass)
  78     {
  79         LOGE("OcHeaderOptionToJava : failed to find OCRepresentation java class!");
  80         return NULL;
  81     }
  82
  83     jmethodID constructor = env->GetMethodID(headerOptionClass, "<init>", "(JLjava/lang/String;)V");
  84     if (NULL == constructor)
  85     {
  86         LOGE("OcHeaderOptionToJava: Failed to get constructor method!");
  87         return NULL;
  88     }
  89
  90     jobject headerOptionObj = (jobject) env->NewObject(headerOptionClass, constructor,
  91                               (jlong)headerOption.getOptionID(), optionData);
  92     if (NULL == headerOptionObj)
  93     {
  94         LOGE("OcHeaderOptionToJava: Failed to create OCRepresentation java object!");
  95         return NULL;
  96     }
  97
  98     return headerOptionObj;
  99 }
 100
 101 jobject OcRepresentationToJava(JNIEnv *env, jlong ocRepresentation)
 102 {
 103     jclass ocRepresentationClass = GetJClass(TM_SERVICE_OCREPRESENTATION_PATH);
 104     if (NULL == ocRepresentationClass)
 105     {
 106         LOGE("OcRepresentationToJava : failed to find OCRepresentation java class!");
 107         return NULL;
 108     }
 109
 110     jmethodID constructor = env->GetMethodID(ocRepresentationClass, "<init>", "(J)V");
 111     if (NULL == constructor)
 112     {
 113         LOGE("OcRepresentationToJava: Failed to get constructor method!");
 114         return NULL;
 115     }
 116
 117     jobject ocRepresentationObj = (jobject) env->NewObject(ocRepresentationClass, constructor,
 118                                   ocRepresentation);
 119     if (NULL == ocRepresentationObj)
 120     {
 121         LOGE("OcRepresentationToJava: Failed to create OCRepresentation java object!");
 122         return NULL;
 123     }
 124
 125     return ocRepresentationObj;
 126 }
 127
 128 void ThingsManagerCallbacks::onFoundCandidateResource(
 129     std::vector< std::shared_ptr<OC::OCResource>> resources)
 130 {
 131     LOGI("findCandidateResource : Enter");
 132
 133     if (resources.size() == 0)
 134     {
 135         LOGE("findCandidateResource : found resources zero");
 136         return;
 137     }
 138
 139     JNIEnv *env = ThingsManagerJVM::getEnv();
 140     if (env == NULL)
 141     {
 142         LOGE("findCandidateResource : Getting JNIEnv failed");
 143         return;
 144     }
 145
 146     // Get ThingsManagerCallback class reference
 147     jclass thingsManagerCallbacks = GetJClass(TM_SERVICE_CALLBACK_CLASS_PATH);
 148     if (NULL == thingsManagerCallbacks)
 149     {
 150         LOGE("findCandidateResource : GetJClass TMServiceCallbackInterface failed");
 151         ThingsManagerJVM::releaseEnv();
 152         return;
 153     }
 154
 155     // Get the ThingsManagerCallback class instance
 156     jobject jobjectCallback = GetJObjectInstance(TM_SERVICE_CALLBACK_CLASS_PATH);
 157     if (NULL == jobjectCallback)
 158     {
 159         LOGE("getInstance( %s) failed!", TM_SERVICE_CALLBACK_CLASS_PATH);
 160         ThingsManagerJVM::releaseEnv();
 161         return;
 162     }
 163
 164     // Get onResourceCallback method reference
 165     jmethodID method_id = env->GetMethodID(thingsManagerCallbacks,
 166                                            "onResourceCallback", METHOD_ONRESOURCE_CALLBACK);
 167     if (NULL == method_id)
 168     {
 169         LOGE("findCandidateResource: onResourceCallback : GetMethodID failed");
 170         ThingsManagerJVM::releaseEnv();
 171         return;
 172     }
 173
 174     if ((env)->ExceptionCheck())
 175     {
 176         LOGE("findCandidateResource : ExceptionCheck failed");
 177         ThingsManagerJVM::releaseEnv();
 178         return;
 179     }
 180
 181     jclass vectorCls = env->FindClass(TM_JAVA_VECTOR_CLASS_PATH);
 182     if (!vectorCls)
 183     {
 184         LOGE("findCandidateResource: failed to get %s class reference", TM_JAVA_VECTOR_CLASS_PATH);
 185         ThingsManagerJVM::releaseEnv();
 186         return;
 187     }
 188
 189     jmethodID constr = env->GetMethodID(vectorCls, "<init>", "()V");
 190     if (!constr)
 191     {
 192         LOGE("findCandidateResource: failed to get %s constructor", TM_JAVA_VECTOR_CLASS_PATH);
 193         ThingsManagerJVM::releaseEnv();
 194         return;
 195     }
 196
 197     jobject vectorObj = env->NewObject(vectorCls, constr);
 198     if (!vectorObj)
 199     {
 200         LOGE("findCandidateResource: failed to create a %s object", TM_JAVA_VECTOR_CLASS_PATH);
 201         ThingsManagerJVM::releaseEnv();
 202         return;
 203     }
 204
 205     jmethodID addElement = env->GetMethodID(vectorCls, "addElement", "(Ljava/lang/Object;)V");
 206     if (NULL == addElement)
 207     {
 208         LOGE("findCandidateResource: failed to create a addElement method");
 209         ThingsManagerJVM::releaseEnv();
 210         return;
 211     }
 212
 213     // Convert to java OCResource object
 214     for (int i = 0; i < resources.size(); i++)
 215     {
 216         JniOcResource *jniOcResource = new JniOcResource(resources[i]);
 217         if (!jniOcResource)
 218         {
 219             LOGE("findCandidateResource: failed to create a JniOcResource");
 220             ThingsManagerJVM::releaseEnv();
 221             return;
 222         }
 223
 224         jobject resource = OcResourceToJava(env, reinterpret_cast<jlong>(jniOcResource));
 225         env->CallVoidMethod(vectorObj, addElement, resource);
 226     }
 227
 228     env->CallVoidMethod(jobjectCallback, method_id, vectorObj);
 229
 230     if ((env)->ExceptionCheck())
 231     {
 232         LOGE("findCandidateResource : CallVoidMethod failed");
 233         ThingsManagerJVM::releaseEnv();
 234         return;
 235     }
 236
 237     ThingsManagerJVM::releaseEnv();
 238     LOGI("findCandidateResource : Exit");
 239 }
 240
 241 void ThingsManagerCallbacks::onFoundGroup(std::shared_ptr<OC::OCResource> groupResource)
 242 {
 243     LOGI("FindGroup : Enter");
 244
 245     if (NULL == groupResource.get())
 246     {
 247         LOGE("FindGroup : Invalid received GroupResource!");
 248         return;
 249     }
 250
 251     JNIEnv *env = ThingsManagerJVM::getEnv();
 252     if (env == NULL)
 253     {
 254         LOGE("FindGroup : Getting JNIEnv failed");
 255         return;
 256     }
 257
 258     // Get ThingsManagerCallback class reference
 259     jclass thingsManagerCallbacks = GetJClass(TM_SERVICE_CALLBACK_CLASS_PATH);
 260     if (NULL == thingsManagerCallbacks)
 261     {
 262         LOGE("FindGroup : GetJClass TMServiceCallbackInterface failed");
 263         ThingsManagerJVM::releaseEnv();
 264         return;
 265     }
 266
 267     // Get the ThingsManagerCallback class instance
 268     jobject jobjectCallback = GetJObjectInstance(TM_SERVICE_CALLBACK_CLASS_PATH);
 269     if (NULL == jobjectCallback)
 270     {
 271         LOGE("FindGroup: getInstance( %s) failed!", TM_SERVICE_CALLBACK_CLASS_PATH);
 272         ThingsManagerJVM::releaseEnv();
 273         return;
 274     }
 275
 276     // Get onGroupFindCallback method reference
 277     jmethodID method_id = env->GetMethodID(thingsManagerCallbacks,
 278                                            "onGroupFindCallback",
 279                                            METHOD_ONGROUP_FIND_CALLBACK);
 280     if (NULL == method_id)
 281     {
 282         LOGE("FindGroup : GetMethodID failed");
 283         ThingsManagerJVM::releaseEnv();
 284         return;
 285     }
 286
 287     if ((env)->ExceptionCheck())
 288     {
 289         LOGE("FindGroup : ExceptionCheck failed");
 290         ThingsManagerJVM::releaseEnv();
 291         return;
 292     }
 293
 294     JniOcResource *jniOcResource = new JniOcResource(groupResource);
 295     if (!jniOcResource)
 296     {
 297         LOGE("FindGroup : groupResource is invalid!");
 298         ThingsManagerJVM::releaseEnv();
 299         return;
 300     }
 301
 302     jobject resource = OcResourceToJava(env, reinterpret_cast<jlong>(jniOcResource));
 303
 304     env->CallVoidMethod(jobjectCallback, method_id, resource);
 305
 306     if ((env)->ExceptionCheck())
 307     {
 308         LOGE("FindGroup : CallVoidMethod failed");
 309         ThingsManagerJVM::releaseEnv();
 310         return;
 311     }
 312
 313     ThingsManagerJVM::releaseEnv();
 314     LOGI("FindGroup : Exit");
 315 }
 316
 317 void ThingsManagerCallbacks::onSubscribePresence(std::string resource, OCStackResult result)
 318 {
 319     LOGI("SubscribePresence : Entry");
 320
 321     JNIEnv *env = ThingsManagerJVM::getEnv();
 322     if (env == NULL)
 323     {
 324         LOGE("SubscribePresence : Getting JNIEnv failed");
 325         return;
 326     }
 327
 328     // Get ThingsManagerCallback class reference
 329     jclass thingsManagerCallbacks = GetJClass(TM_SERVICE_CALLBACK_CLASS_PATH);
 330     if (NULL == thingsManagerCallbacks)
 331     {
 332         LOGE("findCandidateResource : GetJClass TMServiceCallbackInterface failed");
 333         ThingsManagerJVM::releaseEnv();
 334         return;
 335     }
 336
 337     // Get getInstance method reference
 338     jmethodID getinstance_method_id = env->GetStaticMethodID(thingsManagerCallbacks,
 339                                       "getInstance", METHOD_TMCALLBACK_GETINSTANCE);
 340     if (NULL == getinstance_method_id)
 341     {
 342         LOGE("getInstance : GetMethodID failed");
 343         ThingsManagerJVM::releaseEnv();
 344         return;
 345     }
 346
 347     // Get the ThingsManagerCallback class instance
 348     jobject jobjectCallback = env->CallStaticObjectMethod(thingsManagerCallbacks,
 349                               getinstance_method_id);
 350     if (NULL == jobjectCallback)
 351     {
 352         LOGE("getInstance( %s) failed!", TM_SERVICE_CALLBACK_CLASS_PATH);
 353         ThingsManagerJVM::releaseEnv();
 354         return;
 355     }
 356
 357     jmethodID method_id = env->GetMethodID(thingsManagerCallbacks,
 358                                            "onPresenceCallback",
 359                                            METHOD_ONPRESENCE_CALLBACK);
 360     if (NULL == method_id)
 361     {
 362         LOGE("SubscribePresence : GetMethodID failed");
 363         ThingsManagerJVM::releaseEnv();
 364         return;
 365     }
 366
 367     if ((env)->ExceptionCheck())
 368     {
 369         LOGE("SubscribePresence : ExceptionCheck failed");
 370         ThingsManagerJVM::releaseEnv();
 371         return;
 372     }
 373
 374     JString *jresource = new JString(env, resource);
 375     if (jresource == NULL)
 376     {
 377         LOGE("resource value is invalid");
 378         ThingsManagerJVM::releaseEnv();
 379         return;
 380     }
 381
 382     env->CallVoidMethod(jobjectCallback, method_id, jresource->getObject(), (jint)result);
 383
 384     delete jresource;
 385
 386     if ((env)->ExceptionCheck())
 387     {
 388         LOGE("SubscribePresence : CallVoidMethod failed");
 389         ThingsManagerJVM::releaseEnv();
 390         return;
 391     }
 392
 393     LOGI("SubscribePresence : Exit");
 394
 395 //METHOD_FAILURE:
 396     ThingsManagerJVM::releaseEnv();
 397 }
 398
 399 void ThingsManagerCallbacks::onUpdateConfigurationsResponse(const OC::HeaderOptions &headerOptions,
 400         const OC::OCRepresentation &rep, const int eCode)
 401 {
 402     LOGI("UpdateConfigurations : Enter");
 403
 404     ThingsManagerCallbacks::invokeCallback(headerOptions, rep, eCode, "onUpdateConfigurationsCallback",
 405                                            METHOD_ONUPDATE_CONF_CALLBACK);
 406
 407     LOGI("UpdateConfigurations : Exit");
 408 }
 409
 410 void ThingsManagerCallbacks::onGetConfigurationsResponse(const OC::HeaderOptions &headerOptions,
 411         const OC::OCRepresentation &rep, const int eCode)
 412 {
 413     LOGI("GetConfigurations : Enter");
 414
 415     ThingsManagerCallbacks::invokeCallback(headerOptions, rep, eCode, "onGetConfigurationsCallback",
 416                                            METHOD_ONGET_CONF_CALLBACK);
 417
 418     LOGI("GetConfigurations : Exit");
 419 }
 420
 421 void ThingsManagerCallbacks::onBootStrapResponse(const OC::HeaderOptions &headerOptions,
 422         const OC::OCRepresentation &rep, const int eCode)
 423 {
 424     LOGI("BootStrap : Enter");
 425
 426     ThingsManagerCallbacks::invokeCallback(headerOptions, rep, eCode, "onBootStrapCallback",
 427                                            METHOD_ONBOOT_STRAP_CALLBACK);
 428
 429     LOGI("BootStrap : Exit");
 430 }
 431
 432 void ThingsManagerCallbacks::onRebootResponse(const OC::HeaderOptions &headerOptions,
 433         const OC::OCRepresentation &rep, const int eCode)
 434 {
 435     LOGI("OnReboot : Enter");
 436
 437     ThingsManagerCallbacks::invokeCallback(headerOptions, rep, eCode, "onRebootCallback",
 438                                            METHOD_ONREBOOT_CALLBACK);
 439
 440     LOGI("OnReboot : Exit");
 441 }
 442
 443 void ThingsManagerCallbacks::onFactoryResetResponse(const OC::HeaderOptions &headerOptions,
 444         const OC::OCRepresentation &rep, const int eCode)
 445 {
 446     LOGI("OnFactoryReset : Enter");
 447
 448     ThingsManagerCallbacks::invokeCallback(headerOptions, rep, eCode, "onFactoryResetCallback",
 449                                            METHOD_ONFACTORY_RESET_CALLBACK);
 450
 451     LOGI("OnFactoryReset : Exit");
 452 }
 453
 454 void ThingsManagerCallbacks::onPostResponse(const OC::HeaderOptions &headerOptions,
 455         const OC::OCRepresentation &rep, const int eCode)
 456 {
 457     LOGI("PostResponse : Enter");
 458
 459     ThingsManagerCallbacks::invokeCallback(headerOptions, rep, eCode, "onPostResponseCallback",
 460                                            METHOD_ONPOST_CALLBACK);
 461
 462     LOGI("PostResponse : Exit");
 463 }
 464
 465 void ThingsManagerCallbacks::onPutResponse(const OC::HeaderOptions &headerOptions,
 466         const OC::OCRepresentation &rep, const int eCode)
 467 {
 468     LOGI("OnPutResponse : Enter");
 469
 470     ThingsManagerCallbacks::invokeCallback(headerOptions, rep, eCode, "onPutResponseCallback",
 471                                            METHOD_ONPUT_CALLBACK);
 472
 473     LOGI("OnPutResponse : Exit");
 474 }
 475
 476
 477 void ThingsManagerCallbacks::onGetResponse(const OC::HeaderOptions &headerOptions,
 478         const OC::OCRepresentation &rep, const int eCode)
 479 {
 480     LOGI("OnGetResponse : Enter");
 481
 482     ThingsManagerCallbacks::invokeCallback(headerOptions, rep, eCode, "onGetResponseCallback",
 483                                            METHOD_ONGET_CALLBACK);
 484
 485     LOGI("OnGetResponse : Exit");
 486 }
 487
 488 void ThingsManagerCallbacks::invokeCallback(const OC::HeaderOptions &headerOptions,
 489         const OC::OCRepresentation &rep, const int eCode, const char  *callbackName,
 490         const char *signature)
 491 {
 492     LOGI("InvokeCallback : Enter %s", callbackName);
 493
 494     JNIEnv *env = ThingsManagerJVM::getEnv();
 495     if (env == NULL)
 496     {
 497         LOGE("InvokeCallback : Getting JNIEnv failed");
 498         return;
 499     }
 500
 501     // Get ThingsManagerCallback class reference
 502     jclass thingsManagerCallbacks = GetJClass(TM_SERVICE_CALLBACK_CLASS_PATH);
 503     if (NULL == thingsManagerCallbacks)
 504     {
 505         LOGE("InvokeCallback : GetJClass TMServiceCallbackInterface failed");
 506         ThingsManagerJVM::releaseEnv();
 507         return;
 508     }
 509
 510     // Get the ThingsManagerCallback class instance
 511     jobject jobjectCallback = GetJObjectInstance(TM_SERVICE_CALLBACK_CLASS_PATH);
 512     if (NULL == jobjectCallback)
 513     {
 514         LOGE("InvokeCallback: getInstance( %s) failed!", TM_SERVICE_CALLBACK_CLASS_PATH);
 515         ThingsManagerJVM::releaseEnv();
 516         return;
 517     }
 518
 519     jmethodID method_id = env->GetMethodID(thingsManagerCallbacks, callbackName, signature);
 520     if (!method_id)
 521     {
 522         LOGE("InvokeCallback : GetMethodID failed");
 523         ThingsManagerJVM::releaseEnv();
 524         return;
 525     }
 526
 527     if ((env)->ExceptionCheck())
 528     {
 529         LOGE("InvokeCallback : ExceptionCheck failed");
 530         ThingsManagerJVM::releaseEnv();
 531         return;
 532     }
 533
 534     // Convert vector<OC:HeaderOption::OCHeaderOption> to java type
 535     jclass vectorCls = env->FindClass(TM_JAVA_VECTOR_CLASS_PATH);
 536     if (!vectorCls)
 537     {
 538         LOGE("InvokeCallback: failed to get %s class reference", TM_JAVA_VECTOR_CLASS_PATH);
 539         ThingsManagerJVM::releaseEnv();
 540         return;
 541     }
 542
 543     jmethodID constr = env->GetMethodID(vectorCls, "<init>", "()V");
 544     if (!constr)
 545     {
 546         LOGE("InvokeCallback: failed to get %s constructor", TM_JAVA_VECTOR_CLASS_PATH);
 547         ThingsManagerJVM::releaseEnv();
 548         return;
 549     }
 550
 551     jobject vectorObj = env->NewObject(vectorCls, constr);
 552     if (!vectorObj)
 553     {
 554         LOGE("InvokeCallback: failed to create a %s object", TM_JAVA_VECTOR_CLASS_PATH);
 555         ThingsManagerJVM::releaseEnv();
 556         return;
 557     }
 558
 559     jmethodID addElement = env->GetMethodID(vectorCls, "addElement", "(Ljava/lang/Object;)V");
 560     if (NULL == addElement)
 561     {
 562         LOGE("InvokeCallback: failed to create a addElement method");
 563         ThingsManagerJVM::releaseEnv();
 564         return;
 565     }
 566
 567     jobject headerOptionTemp;
 568     for (int i = 0; i < headerOptions.size(); i++)
 569     {
 570         headerOptionTemp = OcHeaderOptionToJava(env, headerOptions[i]);
 571         env->CallVoidMethod(vectorObj, addElement, headerOptionTemp);
 572     }
 573
 574     // Convert OCRepresentation to java type
 575     jobject jrepresentation = OcRepresentationToJava(env, (jlong) reinterpret_cast<jlong>(&rep));
 576     if (!jrepresentation)
 577     {
 578         LOGE("InvokeCallback : cannot create OCRepresentation class");
 579         ThingsManagerJVM::releaseEnv();
 580         return;
 581     }
 582
 583     env->CallVoidMethod(jobjectCallback, method_id, vectorObj, jrepresentation, (jint)eCode);
 584
 585     if ((env)->ExceptionCheck())
 586     {
 587         LOGE("InvokeCallback : CallVoidMethod failed");
 588         ThingsManagerJVM::releaseEnv();
 589         return;
 590     }
 591
 592     ThingsManagerJVM::releaseEnv();
 593     LOGI("InvokeCallback : Exit %s", callbackName);
 594 }