android/android_api/base/jni/JniOcPlatform.cpp

   1 /*\r
   2 * //******************************************************************\r
   3 * //\r
   4 * // Copyright 2015 Intel Corporation.\r
   5 * //\r
   6 * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\r
   7 * //\r
   8 * // Licensed under the Apache License, Version 2.0 (the "License");\r
   9 * // you may not use this file except in compliance with the License.\r
  10 * // You may obtain a copy of the License at\r
  11 * //\r
  12 * //      http://www.apache.org/licenses/LICENSE-2.0\r
  13 * //\r
  14 * // Unless required by applicable law or agreed to in writing, software\r
  15 * // distributed under the License is distributed on an "AS IS" BASIS,\r
  16 * // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  17 * // See the License for the specific language governing permissions and\r
  18 * // limitations under the License.\r
  19 * //\r
  20 * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\r
  21 */\r
  22 #include "JniOcPlatform.h"\r
  23 #include "OCPlatform.h"\r
  24 #include "JniOcResource.h"\r
  25 #include "JniOcResourceHandle.h"\r
  26 #include "JniOcPresenceHandle.h"\r
  27 #include "JniOcResourceResponse.h"\r
  28 #include "JniUtils.h"\r
  29 \r
  30 using namespace OC;\r
  31 \r
  32 JniOnResourceFoundListener* AddOnResourceFoundListener(JNIEnv* env, jobject jListener)\r
  33 {\r
  34     JniOnResourceFoundListener *onResourceFoundListener = NULL;\r
  35 \r
  36     resourceFoundMapLock.lock();\r
  37 \r
  38     for (auto it = onResourceFoundListenerMap.begin(); it != onResourceFoundListenerMap.end(); ++it)\r
  39     {\r
  40         if (env->IsSameObject(jListener, it->first))\r
  41         {\r
  42             auto refPair = it->second;\r
  43             onResourceFoundListener = refPair.first;\r
  44             refPair.second++;\r
  45             it->second = refPair;\r
  46             onResourceFoundListenerMap.insert(*it);\r
  47             LOGD("OnResourceFoundListener: ref. count incremented");\r
  48             break;\r
  49         }\r
  50     }\r
  51 \r
  52     if (!onResourceFoundListener)\r
  53     {\r
  54         onResourceFoundListener = new JniOnResourceFoundListener(env, jListener, RemoveOnResourceFoundListener);\r
  55         jobject jgListener = env->NewGlobalRef(jListener);\r
  56 \r
  57         onResourceFoundListenerMap.insert(std::pair < jobject, std::pair < JniOnResourceFoundListener*,\r
  58             int >> (jgListener, std::pair<JniOnResourceFoundListener*, int>(onResourceFoundListener, 1)));\r
  59         LOGD("OnResourceFoundListener: new listener");\r
  60     }\r
  61     resourceFoundMapLock.unlock();\r
  62     return onResourceFoundListener;\r
  63 }\r
  64 \r
  65 void RemoveOnResourceFoundListener(JNIEnv* env, jobject jListener)\r
  66 {\r
  67     resourceFoundMapLock.lock();\r
  68 \r
  69     for (auto it = onResourceFoundListenerMap.begin(); it != onResourceFoundListenerMap.end(); ++it)\r
  70     {\r
  71         if (env->IsSameObject(jListener, it->first))\r
  72         {\r
  73             auto refPair = it->second;\r
  74             if (refPair.second > 1)\r
  75             {\r
  76                 refPair.second--;\r
  77                 it->second = refPair;\r
  78                 onResourceFoundListenerMap.insert(*it);\r
  79                 LOGI("OnResourceFoundListener: ref. count decremented");\r
  80             }\r
  81             else\r
  82             {\r
  83                 env->DeleteGlobalRef(it->first);\r
  84                 JniOnResourceFoundListener* listener = refPair.first;\r
  85                 delete listener;\r
  86                 onResourceFoundListenerMap.erase(it);\r
  87                 LOGI("OnResourceFoundListener removed");\r
  88             }\r
  89             break;\r
  90         }\r
  91     }\r
  92     resourceFoundMapLock.unlock();\r
  93 }\r
  94 \r
  95 JniOnDeviceInfoListener* AddOnDeviceInfoListener(JNIEnv* env, jobject jListener)\r
  96 {\r
  97     JniOnDeviceInfoListener *onDeviceInfoListener = NULL;\r
  98 \r
  99     deviceInfoMapLock.lock();\r
 100 \r
 101     for (auto it = onDeviceInfoListenerMap.begin(); it != onDeviceInfoListenerMap.end(); ++it)\r
 102     {\r
 103         if (env->IsSameObject(jListener, it->first))\r
 104         {\r
 105             auto refPair = it->second;\r
 106             onDeviceInfoListener = refPair.first;\r
 107             refPair.second++;\r
 108             it->second = refPair;\r
 109             onDeviceInfoListenerMap.insert(*it);\r
 110             LOGD("OnDeviceInfoListener: ref. count incremented");\r
 111             break;\r
 112         }\r
 113     }\r
 114 \r
 115     if (!onDeviceInfoListener)\r
 116     {\r
 117         onDeviceInfoListener = new JniOnDeviceInfoListener(env, jListener, RemoveOnDeviceInfoListener);\r
 118         jobject jgListener = env->NewGlobalRef(jListener);\r
 119 \r
 120         onDeviceInfoListenerMap.insert(std::pair < jobject, std::pair < JniOnDeviceInfoListener*,\r
 121             int >> (jgListener, std::pair<JniOnDeviceInfoListener*, int>(onDeviceInfoListener, 1)));\r
 122         LOGI("OnDeviceInfoListener: new listener");\r
 123     }\r
 124 \r
 125     deviceInfoMapLock.unlock();\r
 126     return onDeviceInfoListener;\r
 127 }\r
 128 \r
 129 void RemoveOnDeviceInfoListener(JNIEnv* env, jobject jListener)\r
 130 {\r
 131     deviceInfoMapLock.lock();\r
 132     bool isFound = false;\r
 133     for (auto it = onDeviceInfoListenerMap.begin(); it != onDeviceInfoListenerMap.end(); ++it)\r
 134     {\r
 135         if (env->IsSameObject(jListener, it->first))\r
 136         {\r
 137             auto refPair = it->second;\r
 138             if (refPair.second > 1)\r
 139             {\r
 140                 refPair.second--;\r
 141                 it->second = refPair;\r
 142                 onDeviceInfoListenerMap.insert(*it);\r
 143                 LOGI("OnDeviceInfoListener: ref. count decremented");\r
 144             }\r
 145             else\r
 146             {\r
 147                 env->DeleteGlobalRef(it->first);\r
 148                 JniOnDeviceInfoListener* listener = refPair.first;\r
 149                 delete listener;\r
 150                 onDeviceInfoListenerMap.erase(it);\r
 151 \r
 152                 LOGI("OnDeviceInfoListener removed");\r
 153             }\r
 154 \r
 155             isFound = true;\r
 156             break;\r
 157         }\r
 158     }\r
 159 \r
 160     if (!isFound)\r
 161     {\r
 162         ThrowOcException(JNI_EXCEPTION, "OnDeviceInfoListenet not found");\r
 163     }\r
 164     deviceInfoMapLock.unlock();\r
 165 }\r
 166 \r
 167 JniOnPresenceListener* AddOnPresenceListener(JNIEnv* env, jobject jListener)\r
 168 {\r
 169     JniOnPresenceListener *onPresenceListener = NULL;\r
 170 \r
 171     presenceMapLock.lock();\r
 172 \r
 173     for (auto it = onPresenceListenerMap.begin(); it != onPresenceListenerMap.end(); ++it)\r
 174     {\r
 175         if (env->IsSameObject(jListener, it->first))\r
 176         {\r
 177             auto refPair = it->second;\r
 178             onPresenceListener = refPair.first;\r
 179             refPair.second++;\r
 180             it->second = refPair;\r
 181             onPresenceListenerMap.insert(*it);\r
 182             LOGD("OnPresenceListener: ref. count incremented");\r
 183             break;\r
 184         }\r
 185     }\r
 186     if (!onPresenceListener)\r
 187     {\r
 188         onPresenceListener = new JniOnPresenceListener(env, jListener, RemoveOnPresenceListener);\r
 189         jobject jgListener = env->NewGlobalRef(jListener);\r
 190         onPresenceListenerMap.insert(std::pair < jobject, std::pair < JniOnPresenceListener*,\r
 191             int >> (jgListener, std::pair<JniOnPresenceListener*, int>(onPresenceListener, 1)));\r
 192         LOGI("OnPresenceListener: new listener");\r
 193     }\r
 194     presenceMapLock.unlock();\r
 195     return onPresenceListener;\r
 196 }\r
 197 \r
 198 void RemoveOnPresenceListener(JNIEnv* env, jobject jListener)\r
 199 {\r
 200     presenceMapLock.lock();\r
 201     bool isFound = false;\r
 202     for (auto it = onPresenceListenerMap.begin(); it != onPresenceListenerMap.end(); ++it)\r
 203     {\r
 204         if (env->IsSameObject(jListener, it->first))\r
 205         {\r
 206             auto refPair = it->second;\r
 207             if (refPair.second > 1)\r
 208             {\r
 209                 refPair.second--;\r
 210                 it->second = refPair;\r
 211                 onPresenceListenerMap.insert(*it);\r
 212                 LOGI("OnPresenceListener: ref. count decremented");\r
 213             }\r
 214             else\r
 215             {\r
 216                 env->DeleteGlobalRef(it->first);\r
 217                 JniOnPresenceListener* listener = refPair.first;\r
 218                 delete listener;\r
 219                 onPresenceListenerMap.erase(it);\r
 220                 LOGI("OnPresenceListener is removed");\r
 221             }\r
 222             isFound = true;\r
 223             break;\r
 224         }\r
 225     }\r
 226     if (!isFound)\r
 227     {\r
 228         ThrowOcException(JNI_EXCEPTION, "OnPresenceListener not found");\r
 229     }\r
 230     presenceMapLock.unlock();\r
 231 }\r
 232 \r
 233 /*\r
 234 * Class:     org_iotivity_base_OcPlatform\r
 235 * Method:    configure\r
 236 * Signature: (IILjava/lang/String;II)V\r
 237 */\r
 238 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_configure\r
 239 (JNIEnv *env, jclass clazz, jint jServiceType, jint jModeType, jstring jIpAddress, jint jPort, jint jQOS)\r
 240 {\r
 241     LOGI("OcPlatform_configure");\r
 242 \r
 243     std::string ipAddress;\r
 244     if (jIpAddress)\r
 245     {\r
 246         ipAddress = env->GetStringUTFChars(jIpAddress, NULL);\r
 247     }\r
 248     uint16_t port;\r
 249     if (jPort > 0)\r
 250     {\r
 251         port = static_cast<uint16_t>(jPort);\r
 252     }\r
 253     PlatformConfig cfg{\r
 254         JniUtils::getServiceType(env, jServiceType),\r
 255         JniUtils::getModeType(env, jModeType),\r
 256         ipAddress,\r
 257         port,\r
 258         JniUtils::getQOS(env, static_cast<int>(jQOS))\r
 259     };\r
 260 \r
 261     OCPlatform::Configure(cfg);\r
 262 }\r
 263 \r
 264 /*\r
 265 * Class:     org_iotivity_base_OcPlatform\r
 266 * Method:    notifyAllObservers0\r
 267 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V\r
 268 */\r
 269 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyAllObservers0\r
 270 (JNIEnv *env, jclass clazz, jobject jResourceHandle)\r
 271 {\r
 272     LOGI("OcPlatform_notifyAllObservers");\r
 273     if (!jResourceHandle)\r
 274     {\r
 275         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");\r
 276         return;\r
 277     }\r
 278 \r
 279     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
 280         env, jResourceHandle);\r
 281     if (!jniOcResourceHandle) return;\r
 282 \r
 283     try\r
 284     {\r
 285         OCStackResult result = OCPlatform::notifyAllObservers(jniOcResourceHandle->getOCResourceHandle());\r
 286 \r
 287         if (OC_STACK_OK != result)\r
 288         {\r
 289             ThrowOcException(result, "Failed to notify all observers");\r
 290             return;\r
 291         }\r
 292     }\r
 293     catch (OCException& e)\r
 294     {\r
 295         LOGE("%s", e.reason().c_str());\r
 296         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
 297     }\r
 298 }\r
 299 \r
 300 /*\r
 301 * Class:     org_iotivity_base_OcPlatform\r
 302 * Method:    notifyAllObservers1\r
 303 * Signature: (Lorg/iotivity/base/OcResourceHandle;I)V\r
 304 */\r
 305 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyAllObservers1\r
 306 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jint jQoS)\r
 307 {\r
 308     LOGI("OcPlatform_notifyAllObservers1");\r
 309 \r
 310     if (!jResourceHandle)\r
 311     {\r
 312         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");\r
 313         return;\r
 314     }\r
 315 \r
 316     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
 317         env, jResourceHandle);\r
 318     if (!jniOcResourceHandle) return;\r
 319 \r
 320     try{\r
 321         OCStackResult result = OCPlatform::notifyAllObservers(\r
 322             jniOcResourceHandle->getOCResourceHandle(),\r
 323             JniUtils::getQOS(env, static_cast<int>(jQoS)));\r
 324 \r
 325         if (OC_STACK_OK != result)\r
 326         {\r
 327             ThrowOcException(result, "Failed to notify all observers");\r
 328             return;\r
 329         }\r
 330     }\r
 331     catch (OCException& e)\r
 332     {\r
 333         LOGE("%s", e.reason().c_str());\r
 334         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
 335     }\r
 336 }\r
 337 \r
 338 /*\r
 339 * Class:     org_iotivity_base_OcPlatform\r
 340 * Method:    notifyListOfObservers2\r
 341 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Ljava/lang/Byte;Lorg/iotivity/base/OcResourceResponse;)V\r
 342 */\r
 343 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyListOfObservers2\r
 344 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jbyteArray jObservationIdArr, jobject jResourceResponse)\r
 345 {\r
 346     LOGD("OcPlatform_notifyListOfObservers2");\r
 347     if (!jResourceHandle)\r
 348     {\r
 349         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");\r
 350         return;\r
 351     }\r
 352     if (!jObservationIdArr)\r
 353     {\r
 354         ThrowOcException(OC_STACK_INVALID_PARAM, "observationIdList cannot be null");\r
 355         return;\r
 356     }\r
 357     if (!jResourceResponse)\r
 358     {\r
 359         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");\r
 360         return;\r
 361     }\r
 362 \r
 363     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
 364         env, jResourceHandle);\r
 365     if (!jniOcResourceHandle) return;\r
 366 \r
 367     JniOcResourceResponse* jniOcResourceResponse = JniOcResourceResponse::getJniOcResourceResponsePtr(\r
 368         env, jResourceResponse);\r
 369     if (!jniOcResourceResponse) return;\r
 370 \r
 371     int len = env->GetArrayLength(jObservationIdArr);\r
 372     uint8_t* bArr = (uint8_t*)env->GetByteArrayElements(jObservationIdArr, 0);\r
 373 \r
 374     ObservationIds observationIds;\r
 375     for (int i = 0; i < len; ++i)\r
 376     {\r
 377         observationIds.push_back(bArr[i]);\r
 378     }\r
 379 \r
 380     env->ReleaseByteArrayElements(jObservationIdArr, (jbyte*)bArr, 0);\r
 381 \r
 382     try{\r
 383         OCStackResult result = OCPlatform::notifyListOfObservers(\r
 384             jniOcResourceHandle->getOCResourceHandle(),\r
 385             observationIds,\r
 386             jniOcResourceResponse->getOCResourceResponse());\r
 387 \r
 388         if (OC_STACK_OK != result)\r
 389         {\r
 390             ThrowOcException(result, "Failed to notify all observers");\r
 391         }\r
 392     }\r
 393     catch (OCException& e)\r
 394     {\r
 395         LOGE("%s", e.reason().c_str());\r
 396         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
 397     }\r
 398 }\r
 399 \r
 400 /*\r
 401 * Class:     org_iotivity_base_OcPlatform\r
 402 * Method:    notifyListOfObservers3\r
 403 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Ljava/lang/Byte;Lorg/iotivity/base/OcResourceResponse;I)V\r
 404 */\r
 405 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyListOfObservers3\r
 406 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jbyteArray jObservationIdArr, jobject jResourceResponse, jint jQoS)\r
 407 {\r
 408     LOGD("OcPlatform_notifyListOfObservers3");\r
 409     if (!jResourceHandle)\r
 410     {\r
 411         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");\r
 412         return;\r
 413     }\r
 414     if (!jObservationIdArr)\r
 415     {\r
 416         ThrowOcException(OC_STACK_INVALID_PARAM, "observationIdList cannot be null");\r
 417         return;\r
 418     }\r
 419     if (!jResourceResponse)\r
 420     {\r
 421         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");\r
 422         return;\r
 423     }\r
 424 \r
 425     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
 426         env, jResourceHandle);\r
 427     if (!jniOcResourceHandle) return;\r
 428 \r
 429     JniOcResourceResponse* jniOcResourceResponse = JniOcResourceResponse::getJniOcResourceResponsePtr(\r
 430         env, jResourceResponse);\r
 431     if (!jniOcResourceResponse) return;\r
 432 \r
 433     int len = env->GetArrayLength(jObservationIdArr);\r
 434     uint8_t* bArr = (uint8_t*)env->GetByteArrayElements(jObservationIdArr, 0);\r
 435 \r
 436     ObservationIds observationIds;\r
 437     for (int i = 0; i < len; ++i)\r
 438     {\r
 439         observationIds.push_back(bArr[i]);\r
 440     }\r
 441 \r
 442     env->ReleaseByteArrayElements(jObservationIdArr, (jbyte*)bArr, 0);\r
 443 \r
 444     try{\r
 445         OCStackResult result = OCPlatform::notifyListOfObservers(\r
 446             jniOcResourceHandle->getOCResourceHandle(),\r
 447             observationIds,\r
 448             jniOcResourceResponse->getOCResourceResponse(),\r
 449             JniUtils::getQOS(env, static_cast<int>(jQoS)));\r
 450 \r
 451         if (OC_STACK_OK != result)\r
 452         {\r
 453             ThrowOcException(result, "Failed to notify all observers");\r
 454         }\r
 455     }\r
 456     catch (OCException& e)\r
 457     {\r
 458         LOGE("%s", e.reason().c_str());\r
 459         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
 460     }\r
 461 }\r
 462 \r
 463 /*\r
 464 * Class:     org_iotivity_base_OcPlatform\r
 465 * Method:    findResource0\r
 466 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnResourceFoundListener;)V\r
 467 */\r
 468 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findResource0\r
 469 (JNIEnv *env, jclass clazz, jstring jHost, jstring jResourceUri, jint jConnectivityType, jobject jListener)\r
 470 {\r
 471     LOGD("OcPlatform_findResource");\r
 472     std::string host;\r
 473     if (jHost)\r
 474     {\r
 475         host = env->GetStringUTFChars(jHost, NULL);\r
 476     }\r
 477     std::string resourceUri;\r
 478     if (jResourceUri)\r
 479     {\r
 480         resourceUri = env->GetStringUTFChars(jResourceUri, NULL);\r
 481     }\r
 482     if (!jListener)\r
 483     {\r
 484         ThrowOcException(OC_STACK_INVALID_PARAM, "onResourceFoundListener cannot be null");\r
 485         return;\r
 486     }\r
 487 \r
 488     JniOnResourceFoundListener *onResFoundListener = AddOnResourceFoundListener(env, jListener);\r
 489 \r
 490     FindCallback findCallback = [onResFoundListener](std::shared_ptr<OCResource> resource)\r
 491     {\r
 492         onResFoundListener->foundResourceCallback(resource);\r
 493     };\r
 494 \r
 495     try\r
 496     {\r
 497         OCStackResult result = OCPlatform::findResource(\r
 498             host,\r
 499             resourceUri,\r
 500             JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),\r
 501             findCallback);\r
 502 \r
 503         if (OC_STACK_OK != result)\r
 504         {\r
 505             ThrowOcException(result, "Find resource has failed");\r
 506             return;\r
 507         }\r
 508     }\r
 509     catch (OCException& e)\r
 510     {\r
 511         LOGE("%s", e.reason().c_str());\r
 512         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
 513     }\r
 514 }\r
 515 \r
 516 /*\r
 517 * Class:     org_iotivity_base_OcPlatform\r
 518 * Method:    findResource1\r
 519 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnResourceFoundListener;I)V\r
 520 */\r
 521 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findResource1\r
 522 (JNIEnv *env, jclass clazz, jstring jHost, jstring jResourceUri, jint jConnectivityType, jobject jListener, jint jQoS)\r
 523 {\r
 524     LOGD("OcPlatform_findResource");\r
 525     std::string host;\r
 526     if (jHost)\r
 527     {\r
 528         host = env->GetStringUTFChars(jHost, NULL);\r
 529     }\r
 530     std::string resourceUri;\r
 531     if (jResourceUri)\r
 532     {\r
 533         resourceUri = env->GetStringUTFChars(jResourceUri, NULL);\r
 534     }\r
 535     if (!jListener)\r
 536     {\r
 537         ThrowOcException(OC_STACK_INVALID_PARAM, "onResourceFoundListener cannot be null");\r
 538         return;\r
 539     }\r
 540     JniOnResourceFoundListener *onResFoundListener = AddOnResourceFoundListener(env, jListener);\r
 541 \r
 542     FindCallback findCallback = [onResFoundListener](std::shared_ptr<OCResource> resource)\r
 543     {\r
 544         onResFoundListener->foundResourceCallback(resource);\r
 545     };\r
 546 \r
 547     try\r
 548     {\r
 549         OCStackResult result = OCPlatform::findResource(\r
 550             host,\r
 551             resourceUri,\r
 552             JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),\r
 553             findCallback,\r
 554             JniUtils::getQOS(env, static_cast<int>(jQoS)));\r
 555 \r
 556         if (OC_STACK_OK != result)\r
 557         {\r
 558             ThrowOcException(result, "Find resource has failed");\r
 559             return;\r
 560         }\r
 561     }\r
 562     catch (OCException& e)\r
 563     {\r
 564         LOGE("%s", e.reason().c_str());\r
 565         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
 566     }\r
 567 }\r
 568 \r
 569 /*\r
 570 * Class:     org_iotivity_base_OcPlatform\r
 571 * Method:    getDeviceInfo0\r
 572 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeviceFoundListener;)V\r
 573 */\r
 574 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDeviceInfo0\r
 575 (JNIEnv *env, jclass clazz, jstring jHost, jstring jResourceUri, jint jConnectivityType, jobject jListener)\r
 576 {\r
 577     LOGD("OcPlatform_getDeviceInfo0");\r
 578     std::string host;\r
 579     if (jHost)\r
 580     {\r
 581         host = env->GetStringUTFChars(jHost, NULL);\r
 582     }\r
 583     std::string resourceUri;\r
 584     if (jResourceUri)\r
 585     {\r
 586         resourceUri = env->GetStringUTFChars(jResourceUri, NULL);\r
 587     }\r
 588     if (!jListener)\r
 589     {\r
 590         ThrowOcException(OC_STACK_INVALID_PARAM, "onDeviceFoundListener cannot be null");\r
 591         return;\r
 592     }\r
 593     JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);\r
 594 \r
 595     FindDeviceCallback findDeviceCallback = [onDeviceInfoListener](const OCRepresentation& ocRepresentation)\r
 596     {\r
 597         onDeviceInfoListener->foundDeviceCallback(ocRepresentation);\r
 598     };\r
 599 \r
 600     try\r
 601     {\r
 602         OCStackResult result = OCPlatform::getDeviceInfo(\r
 603             host,\r
 604             resourceUri,\r
 605             JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),\r
 606             findDeviceCallback);\r
 607 \r
 608         if (OC_STACK_OK != result)\r
 609         {\r
 610             ThrowOcException(result, "Find device has failed");\r
 611         }\r
 612     }\r
 613     catch (OCException& e)\r
 614     {\r
 615         LOGE("%s", e.reason().c_str());\r
 616         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
 617     }\r
 618 }\r
 619 \r
 620 /*\r
 621 * Class:     org_iotivity_base_OcPlatform\r
 622 * Method:    getDeviceInfo1\r
 623 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeviceFoundListener;I)V\r
 624 */\r
 625 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDeviceInfo1\r
 626 (JNIEnv *env, jclass clazz, jstring jHost, jstring jResourceUri, jint jConnectivityType, jobject jListener, jint jQoS)\r
 627 {\r
 628     LOGD("OcPlatform_getDeviceInfo1");\r
 629     std::string host;\r
 630     if (jHost)\r
 631     {\r
 632         host = env->GetStringUTFChars(jHost, NULL);\r
 633     }\r
 634     std::string resourceUri;\r
 635     if (jResourceUri)\r
 636     {\r
 637         resourceUri = env->GetStringUTFChars(jResourceUri, NULL);\r
 638     }\r
 639     if (!jListener)\r
 640     {\r
 641         ThrowOcException(OC_STACK_INVALID_PARAM, "onDeviceFoundListener cannot be null");\r
 642         return;\r
 643     }\r
 644     JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);\r
 645 \r
 646     FindDeviceCallback findDeviceCallback = [onDeviceInfoListener](const OCRepresentation& ocRepresentation)\r
 647     {\r
 648         onDeviceInfoListener->foundDeviceCallback(ocRepresentation);\r
 649     };\r
 650 \r
 651     try\r
 652     {\r
 653         OCStackResult result = OCPlatform::getDeviceInfo(\r
 654             host,\r
 655             resourceUri,\r
 656             JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),\r
 657             findDeviceCallback,\r
 658             JniUtils::getQOS(env, static_cast<int>(jQoS)));\r
 659 \r
 660         if (OC_STACK_OK != result)\r
 661         {\r
 662             ThrowOcException(result, "Find device has failed");\r
 663         }\r
 664     }\r
 665     catch (OCException& e)\r
 666     {\r
 667         LOGE("%s", e.reason().c_str());\r
 668         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
 669     }\r
 670 }\r
 671 \r
 672 /*\r
 673 * Class:     org_iotivity_base_OcPlatform\r
 674 * Method:    registerResource0\r
 675 * Signature: (Lorg/iotivity/base/OcResource;)Lorg/iotivity/base/OcResourceHandle;\r
 676 */\r
 677 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_registerResource0\r
 678 (JNIEnv *env, jclass clazz, jobject jResource)\r
 679 {\r
 680     LOGD("OcPlatform_registerResource");\r
 681     if (!jResource)\r
 682     {\r
 683         ThrowOcException(OC_STACK_INVALID_PARAM, "Resource cannot be null");\r
 684         return nullptr;\r
 685     }\r
 686     JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, jResource);\r
 687     if (!resource) return nullptr;\r
 688 \r
 689     OCResourceHandle resourceHandle;\r
 690     try\r
 691     {\r
 692         OCStackResult result = OCPlatform::registerResource(\r
 693             resourceHandle,\r
 694             resource->getOCResource());\r
 695 \r
 696         if (OC_STACK_OK != result)\r
 697         {\r
 698             ThrowOcException(result, "register resource");\r
 699         }\r
 700     }\r
 701     catch (OCException& e)\r
 702     {\r
 703         LOGE("%s", e.reason().c_str());\r
 704         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
 705         return nullptr;\r
 706     }\r
 707 \r
 708     JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);\r
 709     jlong handle = reinterpret_cast<jlong>(jniHandle);\r
 710     jobject jResourceHandle = env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);\r
 711     if (!jResourceHandle)\r
 712     {\r
 713         LOGE("Failed to create OcResourceHandle");\r
 714         delete jniHandle;\r
 715     }\r
 716     return jResourceHandle;\r
 717 }\r
 718 \r
 719 /*\r
 720 * Class:     org_iotivity_base_OcPlatform\r
 721 * Method:    registerResource1\r
 722 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcPlatform/EntityHandler;I)Lorg/iotivity/base/OcResourceHandle;\r
 723 */\r
 724 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_registerResource1\r
 725 (JNIEnv *env, jclass clazz, jstring jResourceUri, jstring jResourceTypeName, jstring jResourceInterface,\r
 726 jobject jListener, jint jResourceProperty)\r
 727 {\r
 728     LOGI("OcPlatform_registerResource1");\r
 729     std::string resourceUri;\r
 730     if (jResourceUri)\r
 731     {\r
 732         resourceUri = env->GetStringUTFChars(jResourceUri, NULL);\r
 733     }\r
 734     std::string resourceTypeName;\r
 735     if (jResourceTypeName)\r
 736     {\r
 737         resourceTypeName = env->GetStringUTFChars(jResourceTypeName, NULL);\r
 738     }\r
 739     std::string resourceInterface;\r
 740     if (jResourceInterface)\r
 741     {\r
 742         resourceInterface = env->GetStringUTFChars(jResourceInterface, NULL);\r
 743     }\r
 744     if (!jListener)\r
 745     {\r
 746         ThrowOcException(OC_STACK_INVALID_PARAM, "entityHandler cannot be null");\r
 747         return nullptr;\r
 748     }\r
 749     JniEntityHandler* entityHandler = new JniEntityHandler(env, jListener);\r
 750     EntityHandler handleEntityCallback = [entityHandler](const std::shared_ptr<OCResourceRequest> request) ->\r
 751         OCEntityHandlerResult{\r
 752         return entityHandler->handleEntity(request);\r
 753     };\r
 754 \r
 755     OCResourceHandle resourceHandle;\r
 756     try\r
 757     {\r
 758         OCStackResult result = OCPlatform::registerResource(\r
 759             resourceHandle,\r
 760             resourceUri,\r
 761             resourceTypeName,\r
 762             resourceInterface,\r
 763             handleEntityCallback,\r
 764             static_cast<int>(jResourceProperty));\r
 765 \r
 766         if (OC_STACK_OK != result)\r
 767         {\r
 768             delete entityHandler;\r
 769             ThrowOcException(result, "register resource");\r
 770             return nullptr;\r
 771         }\r
 772     }\r
 773     catch (OCException& e)\r
 774     {\r
 775         LOGE("%s", e.reason().c_str());\r
 776         delete entityHandler;\r
 777         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
 778         return nullptr;\r
 779     }\r
 780 \r
 781     JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);\r
 782     jlong handle = reinterpret_cast<jlong>(jniHandle);\r
 783     jobject jResourceHandle = env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);\r
 784     if (!jResourceHandle)\r
 785     {\r
 786         LOGE("Failed to create OcResourceHandle");\r
 787         delete jniHandle;\r
 788     }\r
 789 \r
 790     return jResourceHandle;\r
 791 }\r
 792 \r
 793 /*\r
 794 * Class:     org_iotivity_base_OcPlatform\r
 795 * Method:    registerDeviceInfo0\r
 796 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V\r
 797 */\r
 798 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_registerDeviceInfo0\r
 799 (JNIEnv *env,\r
 800 jclass clazz,\r
 801 jstring jDeviceName,\r
 802 jstring jHostName,\r
 803 jstring jDeviceUUID,\r
 804 jstring jContentType,\r
 805 jstring jVersion,\r
 806 jstring jManufacturerName,\r
 807 jstring jManufacturerUrl,\r
 808 jstring jModelNumber,\r
 809 jstring jDateOfManufacture,\r
 810 jstring jPlatformVersion,\r
 811 jstring jFirmwareVersion,\r
 812 jstring jSupportUrl)\r
 813 {\r
 814     LOGI("OcPlatform_registerDeviceInfo");\r
 815 \r
 816     std::string deviceName;\r
 817     if (jDeviceName)\r
 818     {\r
 819         deviceName = env->GetStringUTFChars(jDeviceName, NULL);\r
 820     }\r
 821     std::string hostName;\r
 822     if (jHostName)\r
 823     {\r
 824         hostName = env->GetStringUTFChars(jHostName, NULL);\r
 825     }\r
 826     std::string deviceUUID;\r
 827     if (jDeviceUUID)\r
 828     {\r
 829         deviceUUID = env->GetStringUTFChars(jDeviceUUID, NULL);\r
 830     }\r
 831     std::string contentType;\r
 832     if (jContentType)\r
 833     {\r
 834         contentType = env->GetStringUTFChars(jContentType, NULL);\r
 835     }\r
 836     std::string version;\r
 837     if (jVersion)\r
 838     {\r
 839         version = env->GetStringUTFChars(jVersion, NULL);\r
 840     }\r
 841     std::string manufacturerName;\r
 842     if (jManufacturerName)\r
 843     {\r
 844         manufacturerName = env->GetStringUTFChars(jManufacturerName, NULL);\r
 845     }\r
 846     std::string manufacturerUrl;\r
 847     if (jManufacturerUrl)\r
 848     {\r
 849         manufacturerUrl = env->GetStringUTFChars(jManufacturerUrl, NULL);\r
 850     }\r
 851     std::string modelNumber;\r
 852     if (jModelNumber)\r
 853     {\r
 854         modelNumber = env->GetStringUTFChars(jModelNumber, NULL);\r
 855     }\r
 856     std::string dateOfManufacture;\r
 857     if (jDateOfManufacture)\r
 858     {\r
 859         dateOfManufacture = env->GetStringUTFChars(jDateOfManufacture, NULL);\r
 860     }\r
 861     std::string platformVersion;\r
 862     if (jPlatformVersion)\r
 863     {\r
 864         platformVersion = env->GetStringUTFChars(jPlatformVersion, NULL);\r
 865     }\r
 866     std::string firmwareVersion;\r
 867     if (jFirmwareVersion)\r
 868     {\r
 869         firmwareVersion = env->GetStringUTFChars(jFirmwareVersion, NULL);\r
 870     }\r
 871     std::string supportUrl;\r
 872     if (jSupportUrl)\r
 873     {\r
 874         supportUrl = env->GetStringUTFChars(jSupportUrl, NULL);\r
 875     }\r
 876 \r
 877     OCDeviceInfo deviceInfo;\r
 878     try\r
 879     {\r
 880         DuplicateString(&deviceInfo.contentType, contentType);\r
 881         DuplicateString(&deviceInfo.dateOfManufacture, dateOfManufacture);\r
 882         DuplicateString(&deviceInfo.deviceName, deviceName);\r
 883         DuplicateString(&deviceInfo.deviceUUID, deviceUUID);\r
 884         DuplicateString(&deviceInfo.firmwareVersion, firmwareVersion);\r
 885         DuplicateString(&deviceInfo.hostName, hostName);\r
 886         DuplicateString(&deviceInfo.manufacturerName, manufacturerName);\r
 887         DuplicateString(&deviceInfo.manufacturerUrl, manufacturerUrl);\r
 888         DuplicateString(&deviceInfo.modelNumber, modelNumber);\r
 889         DuplicateString(&deviceInfo.platformVersion, platformVersion);\r
 890         DuplicateString(&deviceInfo.supportUrl, supportUrl);\r
 891         DuplicateString(&deviceInfo.version, version);\r
 892     }\r
 893     catch (std::exception &e)\r
 894     {\r
 895         ThrowOcException(JNI_EXCEPTION, "Failed to register device info");\r
 896         return;\r
 897     }\r
 898 \r
 899     try\r
 900     {\r
 901         OCStackResult result = OCPlatform::registerDeviceInfo(deviceInfo);\r
 902 \r
 903         delete deviceInfo.contentType;\r
 904         delete deviceInfo.dateOfManufacture;\r
 905         delete deviceInfo.deviceName;\r
 906         delete deviceInfo.deviceUUID;\r
 907         delete deviceInfo.firmwareVersion;\r
 908         delete deviceInfo.hostName;\r
 909         delete deviceInfo.manufacturerName;\r
 910         delete deviceInfo.manufacturerUrl;\r
 911         delete deviceInfo.modelNumber;\r
 912         delete deviceInfo.platformVersion;\r
 913         delete deviceInfo.supportUrl;\r
 914         delete deviceInfo.version;\r
 915 \r
 916         if (OC_STACK_OK != result)\r
 917         {\r
 918             ThrowOcException(result, "Failed to register device info");\r
 919             return;\r
 920         }\r
 921     }\r
 922     catch (OCException& e)\r
 923     {\r
 924         LOGE("%s", e.reason().c_str());\r
 925         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
 926     }\r
 927 }\r
 928 \r
 929 /*\r
 930 * Class:     org_iotivity_base_OcPlatform\r
 931 * Method:    unregisterResource0\r
 932 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V\r
 933 */\r
 934 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unregisterResource0\r
 935 (JNIEnv *env, jclass clazz, jobject jResourceHandle)\r
 936 {\r
 937     LOGI("OcPlatform_unregisterResource");\r
 938     if (!jResourceHandle)\r
 939     {\r
 940         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");\r
 941         return;\r
 942     }\r
 943     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
 944         env, jResourceHandle);\r
 945     if (!jniOcResourceHandle) return;\r
 946 \r
 947     try\r
 948     {\r
 949         OCResourceHandle resHandle = jniOcResourceHandle->getOCResourceHandle();\r
 950         OCStackResult result = OCPlatform::unregisterResource(resHandle);\r
 951         if (OC_STACK_OK != result)\r
 952         {\r
 953             ThrowOcException(result, "Failed to unregister resource");\r
 954         }\r
 955     }\r
 956     catch (OCException& e)\r
 957     {\r
 958         LOGE("%s", e.reason().c_str());\r
 959         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
 960     }\r
 961 }\r
 962 \r
 963 /*\r
 964 * Class:     org_iotivity_base_OcPlatform\r
 965 * Method:    bindResource0\r
 966 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V\r
 967 */\r
 968 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResource0\r
 969 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobject jResourceHandle)\r
 970 {\r
 971     LOGI("OcPlatform_bindResource");\r
 972     if (!jResourceCollectionHandle)\r
 973     {\r
 974         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");\r
 975         return;\r
 976     }\r
 977     if (!jResourceHandle)\r
 978     {\r
 979         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");\r
 980         return;\r
 981     }\r
 982     JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
 983         env, jResourceCollectionHandle);\r
 984     if (!jniOcResourceCollectionHandle) return;\r
 985 \r
 986     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
 987         env, jResourceHandle);\r
 988     if (!jniOcResourceHandle) return;\r
 989 \r
 990     try\r
 991     {\r
 992         OCStackResult result = OCPlatform::bindResource(\r
 993             jniOcResourceCollectionHandle->getOCResourceHandle(),\r
 994             jniOcResourceHandle->getOCResourceHandle()\r
 995             );\r
 996 \r
 997         if (OC_STACK_OK != result)\r
 998         {\r
 999             ThrowOcException(result, "Failed to bind resource");\r
1000         }\r
1001     }\r
1002     catch (OCException& e)\r
1003     {\r
1004         LOGE("%s", e.reason().c_str());\r
1005         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1006     }\r
1007 }\r
1008 \r
1009 /*\r
1010 * Class:     org_iotivity_base_OcPlatform\r
1011 * Method:    bindResources0\r
1012 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V\r
1013 */\r
1014 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResources0\r
1015 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobjectArray jResourceHandleArray)\r
1016 {\r
1017     LOGI("OcPlatform_bindResources");\r
1018 \r
1019     if (!jResourceCollectionHandle)\r
1020     {\r
1021         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");\r
1022         return;\r
1023     }\r
1024     if (!jResourceHandleArray)\r
1025     {\r
1026         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");\r
1027         return;\r
1028     }\r
1029 \r
1030     JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
1031         env, jResourceCollectionHandle);\r
1032     if (!jniOcResourceCollectionHandle) return;\r
1033 \r
1034     std::vector<OCResourceHandle> resourceHandleList;\r
1035     int len = env->GetArrayLength(jResourceHandleArray);\r
1036     for (int i = 0; i < len; ++i)\r
1037     {\r
1038         jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);\r
1039         if (!jResourceHandle)\r
1040         {\r
1041             ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");\r
1042             return;\r
1043         }\r
1044 \r
1045         JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
1046             env, jResourceHandle);\r
1047         if (!jniOcResourceHandle) return;\r
1048 \r
1049         resourceHandleList.push_back(\r
1050             jniOcResourceHandle->getOCResourceHandle());\r
1051     }\r
1052 \r
1053     try\r
1054     {\r
1055         OCStackResult result = OCPlatform::bindResources(\r
1056             jniOcResourceCollectionHandle->getOCResourceHandle(),\r
1057             resourceHandleList\r
1058             );\r
1059 \r
1060         if (OC_STACK_OK != result)\r
1061         {\r
1062             ThrowOcException(result, "Failed to bind resources");\r
1063         }\r
1064     }\r
1065     catch (OCException& e)\r
1066     {\r
1067         LOGE("%s", e.reason().c_str());\r
1068         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1069     }\r
1070 }\r
1071 \r
1072 /*\r
1073 * Class:     org_iotivity_base_OcPlatform\r
1074 * Method:    unbindResource0\r
1075 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V\r
1076 */\r
1077 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResource0\r
1078 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobject jResourceHandle)\r
1079 {\r
1080     LOGI("OcPlatform_unbindResource");\r
1081     if (!jResourceCollectionHandle)\r
1082     {\r
1083         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");\r
1084         return;\r
1085     }\r
1086     if (!jResourceHandle)\r
1087     {\r
1088         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");\r
1089         return;\r
1090     }\r
1091 \r
1092     JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
1093         env, jResourceCollectionHandle);\r
1094     if (!jniOcResourceCollectionHandle) return;\r
1095 \r
1096     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
1097         env, jResourceHandle);\r
1098     if (!jniOcResourceHandle) return;\r
1099 \r
1100     try\r
1101     {\r
1102         OCStackResult result = OCPlatform::unbindResource(\r
1103             jniOcResourceCollectionHandle->getOCResourceHandle(),\r
1104             jniOcResourceHandle->getOCResourceHandle()\r
1105             );\r
1106 \r
1107         if (OC_STACK_OK != result)\r
1108         {\r
1109             ThrowOcException(result, "Failed to unbind resource");\r
1110         }\r
1111     }\r
1112     catch (OCException& e)\r
1113     {\r
1114         LOGE("%s", e.reason().c_str());\r
1115         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1116     }\r
1117 }\r
1118 \r
1119 /*\r
1120 * Class:     org_iotivity_base_OcPlatform\r
1121 * Method:    unbindResources0\r
1122 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V\r
1123 */\r
1124 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResources0\r
1125 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobjectArray jResourceHandleArray)\r
1126 {\r
1127     LOGI("OcPlatform_unbindResources");\r
1128     if (!jResourceCollectionHandle)\r
1129     {\r
1130         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");\r
1131         return;\r
1132     }\r
1133     if (!jResourceHandleArray)\r
1134     {\r
1135         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");\r
1136         return;\r
1137     }\r
1138 \r
1139     JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
1140         env, jResourceCollectionHandle);\r
1141     if (!jniOcResourceCollectionHandle) return;\r
1142 \r
1143     std::vector<OCResourceHandle> resourceHandleList;\r
1144     int len = env->GetArrayLength(jResourceHandleArray);\r
1145     for (int i = 0; i < len; ++i)\r
1146     {\r
1147         jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);\r
1148         if (!jResourceHandle)\r
1149         {\r
1150             ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");\r
1151             return;\r
1152         }\r
1153 \r
1154         JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
1155             env, jResourceHandle);\r
1156         if (!jniOcResourceHandle) return;\r
1157 \r
1158         resourceHandleList.push_back(\r
1159             jniOcResourceHandle->getOCResourceHandle());\r
1160     }\r
1161 \r
1162     try\r
1163     {\r
1164         OCStackResult result = OCPlatform::unbindResources(\r
1165             jniOcResourceCollectionHandle->getOCResourceHandle(),\r
1166             resourceHandleList\r
1167             );\r
1168 \r
1169         if (OC_STACK_OK != result)\r
1170         {\r
1171             ThrowOcException(result, "Failed to unbind resources");\r
1172         }\r
1173     }\r
1174     catch (OCException& e)\r
1175     {\r
1176         LOGE("%s", e.reason().c_str());\r
1177         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1178     }\r
1179 }\r
1180 \r
1181 /*\r
1182 * Class:     org_iotivity_base_OcPlatform\r
1183 * Method:    bindTypeToResource0\r
1184 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V\r
1185 */\r
1186 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindTypeToResource0\r
1187 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jstring jResourceTypeName)\r
1188 {\r
1189     LOGI("OcPlatform_bindTypeToResource");\r
1190     if (!jResourceHandle)\r
1191     {\r
1192         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");\r
1193         return;\r
1194     }\r
1195     std::string typeName;\r
1196     if (jResourceTypeName)\r
1197     {\r
1198         typeName = env->GetStringUTFChars(jResourceTypeName, NULL);\r
1199     }\r
1200 \r
1201     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
1202         env, jResourceHandle);\r
1203     if (!jniOcResourceHandle) return;\r
1204 \r
1205     try\r
1206     {\r
1207         OCStackResult result = OCPlatform::bindTypeToResource(\r
1208             jniOcResourceHandle->getOCResourceHandle(),\r
1209             typeName\r
1210             );\r
1211 \r
1212         if (OC_STACK_OK != result)\r
1213         {\r
1214             ThrowOcException(result, "Failed to bind type to resource");\r
1215         }\r
1216     }\r
1217     catch (OCException& e)\r
1218     {\r
1219         LOGE("%s", e.reason().c_str());\r
1220         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1221     }\r
1222 }\r
1223 \r
1224 /*\r
1225 * Class:     org_iotivity_base_OcPlatform\r
1226 * Method:    bindInterfaceToResource0\r
1227 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V\r
1228 */\r
1229 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindInterfaceToResource0\r
1230 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jstring jResourceInterfaceName)\r
1231 {\r
1232     LOGI("OcPlatform_bindInterfaceToResource");\r
1233     if (!jResourceHandle)\r
1234     {\r
1235         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");\r
1236         return;\r
1237     }\r
1238     std::string interfaceName;\r
1239     if (jResourceInterfaceName)\r
1240     {\r
1241         interfaceName = env->GetStringUTFChars(jResourceInterfaceName, NULL);\r
1242     }\r
1243 \r
1244     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
1245         env, jResourceHandle);\r
1246     if (!jniOcResourceHandle) return;\r
1247 \r
1248     try\r
1249     {\r
1250         OCStackResult result = OCPlatform::bindInterfaceToResource(\r
1251             jniOcResourceHandle->getOCResourceHandle(),\r
1252             interfaceName\r
1253             );\r
1254 \r
1255         if (OC_STACK_OK != result)\r
1256         {\r
1257             ThrowOcException(result, "Failed to bind interface to resource");\r
1258         }\r
1259     }\r
1260     catch (OCException& e)\r
1261     {\r
1262         LOGE("%s", e.reason().c_str());\r
1263         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1264     }\r
1265 }\r
1266 \r
1267 /*\r
1268 * Class:     org_iotivity_base_OcPlatform\r
1269 * Method:    startPresence0\r
1270 * Signature: (I)V\r
1271 */\r
1272 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_startPresence0\r
1273 (JNIEnv *env, jclass clazz, jint ttl)\r
1274 {\r
1275     LOGI("OcPlatform_startPresence");\r
1276 \r
1277     try\r
1278     {\r
1279         OCStackResult result = OCPlatform::startPresence((unsigned int)ttl);\r
1280 \r
1281         if (OC_STACK_OK != result)\r
1282         {\r
1283             ThrowOcException(result, "Failed to start presence");\r
1284         }\r
1285     }\r
1286     catch (OCException& e)\r
1287     {\r
1288         LOGE("%s", e.reason().c_str());\r
1289         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1290     }\r
1291 }\r
1292 \r
1293 /*\r
1294 * Class:     org_iotivity_base_OcPlatform\r
1295 * Method:    stopPresence0\r
1296 * Signature: ()V\r
1297 */\r
1298 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_stopPresence0\r
1299 (JNIEnv *env, jclass clazz)\r
1300 {\r
1301     LOGI("OcPlatform_stopPresence");\r
1302 \r
1303     try\r
1304     {\r
1305         OCStackResult result = OCPlatform::stopPresence();\r
1306 \r
1307         if (OC_STACK_OK != result)\r
1308         {\r
1309             ThrowOcException(result, "Failed to stop presence");\r
1310         }\r
1311     }\r
1312     catch (OCException& e)\r
1313     {\r
1314         LOGE("%s", e.reason().c_str());\r
1315         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1316     }\r
1317 }\r
1318 \r
1319 /*\r
1320 * Class:     org_iotivity_base_OcPlatform\r
1321 * Method:    subscribePresence0\r
1322 * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;\r
1323 */\r
1324 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence0\r
1325 (JNIEnv *env, jclass clazz, jstring jHost, jint jConnectivityType, jobject jListener)\r
1326 {\r
1327     LOGD("OcPlatform_subscribePresence");\r
1328     std::string host;\r
1329     if (jHost)\r
1330     {\r
1331         host = env->GetStringUTFChars(jHost, NULL);\r
1332     }\r
1333     if (!jListener)\r
1334     {\r
1335         ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");\r
1336         return nullptr;\r
1337     }\r
1338 \r
1339     JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);\r
1340 \r
1341     SubscribeCallback subscribeCallback = [onPresenceListener](OCStackResult result, const unsigned int nonce,\r
1342         const std::string& hostAddress)\r
1343     {\r
1344         onPresenceListener->onPresenceCallback(result, nonce, hostAddress);\r
1345     };\r
1346 \r
1347     OCPlatform::OCPresenceHandle presenceHandle;\r
1348     try\r
1349     {\r
1350         OCStackResult result = OCPlatform::subscribePresence(\r
1351             presenceHandle,\r
1352             host,\r
1353             JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),\r
1354             subscribeCallback);\r
1355 \r
1356         if (OC_STACK_OK != result)\r
1357         {\r
1358             ThrowOcException(result, "subscribe presence has failed");\r
1359         }\r
1360     }\r
1361     catch (OCException& e)\r
1362     {\r
1363         LOGE("%s", e.reason().c_str());\r
1364         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1365         return nullptr;\r
1366     }\r
1367 \r
1368     JniOcPresenceHandle* jniPresenceHandle = new JniOcPresenceHandle(onPresenceListener, presenceHandle);\r
1369     jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);\r
1370     jobject jPresenceHandle = env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);\r
1371     if (!jPresenceHandle)\r
1372     {\r
1373         LOGE("Failed to create OcPresenceHandle");\r
1374         delete jniPresenceHandle;\r
1375     }\r
1376 \r
1377     return jPresenceHandle;\r
1378 }\r
1379 \r
1380 /*\r
1381 * Class:     org_iotivity_base_OcPlatform\r
1382 * Method:    subscribePresence1\r
1383 * Signature: (Ljava/lang/String;Ljava/lang/String;I\r
1384 Lorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;\r
1385 */\r
1386 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence1\r
1387 (JNIEnv *env, jclass clazz, jstring jHost, jstring jResourceType, jint jConnectivityType, jobject jListener)\r
1388 {\r
1389     LOGD("OcPlatform_subscribePresence1");\r
1390     std::string host;\r
1391     if (jHost)\r
1392     {\r
1393         host = env->GetStringUTFChars(jHost, NULL);\r
1394     }\r
1395     std::string resourceType;\r
1396     if (jResourceType)\r
1397     {\r
1398         resourceType = env->GetStringUTFChars(jResourceType, NULL);\r
1399     }\r
1400     if (!jListener)\r
1401     {\r
1402         ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");\r
1403         return nullptr;\r
1404     }\r
1405 \r
1406     JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);\r
1407 \r
1408     SubscribeCallback subscribeCallback = [onPresenceListener](OCStackResult result,\r
1409         const unsigned int nonce, const std::string& hostAddress)\r
1410     {\r
1411         onPresenceListener->onPresenceCallback(result, nonce, hostAddress);\r
1412     };\r
1413 \r
1414     OCPlatform::OCPresenceHandle presenceHandle;\r
1415     try\r
1416     {\r
1417         OCStackResult result = OCPlatform::subscribePresence(\r
1418             presenceHandle,\r
1419             host,\r
1420             resourceType,\r
1421             JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),\r
1422             subscribeCallback);\r
1423 \r
1424         if (OC_STACK_OK != result)\r
1425         {\r
1426             ThrowOcException(result, "subscribe presence has failed");\r
1427         }\r
1428     }\r
1429     catch (OCException& e)\r
1430     {\r
1431         LOGE("%s", e.reason().c_str());\r
1432         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1433         return nullptr;\r
1434     }\r
1435 \r
1436     JniOcPresenceHandle* jniPresenceHandle = new JniOcPresenceHandle(onPresenceListener, presenceHandle);\r
1437     jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);\r
1438     jobject jPresenceHandle = env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);\r
1439     if (!jPresenceHandle)\r
1440     {\r
1441         LOGE("Failed to create OcPresenceHandle");\r
1442         delete jniPresenceHandle;\r
1443     }\r
1444     return jPresenceHandle;\r
1445 }\r
1446 \r
1447 /*\r
1448 * Class:     org_iotivity_base_OcPlatform\r
1449 * Method:    unsubscribePresence0\r
1450 * Signature: (Lorg/iotivity/base/OcPresenceHandle;)V\r
1451 */\r
1452 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unsubscribePresence0\r
1453 (JNIEnv *env, jclass clazz, jobject jPresenceHandle)\r
1454 {\r
1455     LOGD("OcPlatform_unsubscribePresence");\r
1456     if (!jPresenceHandle)\r
1457     {\r
1458         ThrowOcException(OC_STACK_INVALID_PARAM, "presenceHandle cannot be null");\r
1459         return;\r
1460     }\r
1461     JniOcPresenceHandle* jniPresenceHandle = JniOcPresenceHandle::getJniOcPresenceHandlePtr(env, jPresenceHandle);\r
1462     if (!jniPresenceHandle) return;\r
1463 \r
1464     OCPresenceHandle presenceHandle = jniPresenceHandle->getOCPresenceHandle();\r
1465 \r
1466     try\r
1467     {\r
1468         OCStackResult result = OCPlatform::unsubscribePresence(presenceHandle);\r
1469 \r
1470         if (OC_STACK_OK != result)\r
1471         {\r
1472             ThrowOcException(result, "unsubscribe presence has failed");\r
1473             return;\r
1474         }\r
1475         jweak jwOnPresenceListener = jniPresenceHandle->getJniOnPresenceListener()->getJWListener();\r
1476         if (jwOnPresenceListener)\r
1477         {\r
1478             RemoveOnPresenceListener(env, jwOnPresenceListener);\r
1479         }\r
1480     }\r
1481     catch (OCException& e)\r
1482     {\r
1483         LOGE("%s", e.reason().c_str());\r
1484         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1485     }\r
1486 }\r
1487 \r
1488 /*\r
1489 * Class:     org_iotivity_base_OcPlatform\r
1490 * Method:    constructResourceObject0\r
1491 * Signature: (Ljava/lang/String;Ljava/lang/String;IZ[Ljava/lang/String;[Ljava/lang/String;)\r
1492 Lorg/iotivity/base/OcResource;\r
1493 */\r
1494 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_constructResourceObject0\r
1495 (JNIEnv *env, jclass clazz, jstring jHost, jstring jUri, jint jConnectivityType,\r
1496 jboolean jIsObservable, jobjectArray jResourceTypeArray, jobjectArray jInterfaceArray)\r
1497 {\r
1498     LOGD("OcPlatform_constructResourceObject");\r
1499     std::string host;\r
1500     if (jHost)\r
1501     {\r
1502         host = env->GetStringUTFChars(jHost, NULL);\r
1503     }\r
1504     std::string uri;\r
1505     if (jUri)\r
1506     {\r
1507         uri = env->GetStringUTFChars(jUri, NULL);\r
1508     }\r
1509     if (!jResourceTypeArray)\r
1510     {\r
1511         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceTypeList cannot be null");\r
1512         return nullptr;\r
1513     }\r
1514     if (!jInterfaceArray)\r
1515     {\r
1516         ThrowOcException(OC_STACK_INVALID_PARAM, "interfaceList cannot be null");\r
1517         return nullptr;\r
1518     }\r
1519 \r
1520     std::vector<std::string> resourceTypes;\r
1521     JniUtils::convertJavaStrArrToStrVector(env, jResourceTypeArray, resourceTypes);\r
1522 \r
1523     std::vector<std::string> interfaces;\r
1524     JniUtils::convertJavaStrArrToStrVector(env, jInterfaceArray, interfaces);\r
1525 \r
1526     std::shared_ptr<OCResource> resource = OCPlatform::constructResourceObject(\r
1527         host,\r
1528         uri,\r
1529         JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),\r
1530         static_cast<bool>(jIsObservable),\r
1531         resourceTypes,\r
1532         interfaces);\r
1533 \r
1534     if (!resource)\r
1535     {\r
1536         ThrowOcException(OC_STACK_ERROR, "Failed to create OCResource");\r
1537         return nullptr;\r
1538     }\r
1539 \r
1540     JniOcResource *jniOcResource = new JniOcResource(resource);\r
1541     jlong handle = reinterpret_cast<jlong>(jniOcResource);\r
1542 \r
1543     jobject jResource = env->NewObject(g_cls_OcResource, g_mid_OcResource_ctor);\r
1544     if (!jResource)\r
1545     {\r
1546         delete jniOcResource;\r
1547         return nullptr;\r
1548     }\r
1549     SetHandle<JniOcResource>(env, jResource, jniOcResource);\r
1550     if (env->ExceptionCheck())\r
1551     {\r
1552         delete jniOcResource;\r
1553         return nullptr;\r
1554     }\r
1555     return jResource;\r
1556 }\r
1557 \r
1558 /*\r
1559 * Class:     org_iotivity_base_OcPlatform\r
1560 * Method:    sendResponse0\r
1561 * Signature: (Lorg/iotivity/base/OcResourceResponse;)V\r
1562 */\r
1563 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_sendResponse0\r
1564 (JNIEnv *env, jclass clazz, jobject jResourceResponse)\r
1565 {\r
1566     LOGD("OcPlatform_sendResponse");\r
1567     if (!jResourceResponse)\r
1568     {\r
1569         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");\r
1570         return;\r
1571     }\r
1572 \r
1573     JniOcResourceResponse *jniResponse = JniOcResourceResponse::getJniOcResourceResponsePtr(\r
1574         env, jResourceResponse);\r
1575     if (!jniResponse) return;\r
1576 \r
1577     try\r
1578     {\r
1579         OCStackResult result = OCPlatform::sendResponse(jniResponse->getOCResourceResponse());\r
1580 \r
1581         if (OC_STACK_OK != result)\r
1582         {\r
1583             ThrowOcException(result, "failed to send response");\r
1584         }\r
1585     }\r
1586     catch (OCException& e)\r
1587     {\r
1588         LOGE("%s", e.reason().c_str());\r
1589         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1590     }\r
1591 }