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 {\r
 803     LOGI("OcPlatform_registerDeviceInfo");\r
 804 \r
 805     std::string deviceName;\r
 806     if (jDeviceName)\r
 807     {\r
 808         deviceName = env->GetStringUTFChars(jDeviceName, NULL);\r
 809     }\r
 810 \r
 811     OCDeviceInfo deviceInfo;\r
 812     try\r
 813     {\r
 814         DuplicateString(&deviceInfo.deviceName, deviceName);\r
 815     }\r
 816     catch (std::exception &e)\r
 817     {\r
 818         ThrowOcException(JNI_EXCEPTION, "Failed to construct device info");\r
 819         return;\r
 820     }\r
 821 \r
 822     try\r
 823     {\r
 824         OCStackResult result = OCPlatform::registerDeviceInfo(deviceInfo);\r
 825 \r
 826         delete deviceInfo.deviceName;\r
 827 \r
 828         if (OC_STACK_OK != result)\r
 829         {\r
 830             ThrowOcException(result, "Failed to register device info");\r
 831             return;\r
 832         }\r
 833     }\r
 834     catch (OCException& e)\r
 835     {\r
 836         LOGE("%s", e.reason().c_str());\r
 837         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
 838     }\r
 839 }\r
 840 \r
 841 /*\r
 842 * Class:     org_iotivity_base_OcPlatform\r
 843 * Method:    unregisterResource0\r
 844 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V\r
 845 */\r
 846 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unregisterResource0\r
 847 (JNIEnv *env, jclass clazz, jobject jResourceHandle)\r
 848 {\r
 849     LOGI("OcPlatform_unregisterResource");\r
 850     if (!jResourceHandle)\r
 851     {\r
 852         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");\r
 853         return;\r
 854     }\r
 855     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
 856         env, jResourceHandle);\r
 857     if (!jniOcResourceHandle) return;\r
 858 \r
 859     try\r
 860     {\r
 861         OCResourceHandle resHandle = jniOcResourceHandle->getOCResourceHandle();\r
 862         OCStackResult result = OCPlatform::unregisterResource(resHandle);\r
 863         if (OC_STACK_OK != result)\r
 864         {\r
 865             ThrowOcException(result, "Failed to unregister resource");\r
 866         }\r
 867     }\r
 868     catch (OCException& e)\r
 869     {\r
 870         LOGE("%s", e.reason().c_str());\r
 871         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
 872     }\r
 873 }\r
 874 \r
 875 /*\r
 876 * Class:     org_iotivity_base_OcPlatform\r
 877 * Method:    bindResource0\r
 878 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V\r
 879 */\r
 880 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResource0\r
 881 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobject jResourceHandle)\r
 882 {\r
 883     LOGI("OcPlatform_bindResource");\r
 884     if (!jResourceCollectionHandle)\r
 885     {\r
 886         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");\r
 887         return;\r
 888     }\r
 889     if (!jResourceHandle)\r
 890     {\r
 891         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");\r
 892         return;\r
 893     }\r
 894     JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
 895         env, jResourceCollectionHandle);\r
 896     if (!jniOcResourceCollectionHandle) return;\r
 897 \r
 898     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
 899         env, jResourceHandle);\r
 900     if (!jniOcResourceHandle) return;\r
 901 \r
 902     try\r
 903     {\r
 904         OCStackResult result = OCPlatform::bindResource(\r
 905             jniOcResourceCollectionHandle->getOCResourceHandle(),\r
 906             jniOcResourceHandle->getOCResourceHandle()\r
 907             );\r
 908 \r
 909         if (OC_STACK_OK != result)\r
 910         {\r
 911             ThrowOcException(result, "Failed to bind resource");\r
 912         }\r
 913     }\r
 914     catch (OCException& e)\r
 915     {\r
 916         LOGE("%s", e.reason().c_str());\r
 917         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
 918     }\r
 919 }\r
 920 \r
 921 /*\r
 922 * Class:     org_iotivity_base_OcPlatform\r
 923 * Method:    bindResources0\r
 924 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V\r
 925 */\r
 926 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResources0\r
 927 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobjectArray jResourceHandleArray)\r
 928 {\r
 929     LOGI("OcPlatform_bindResources");\r
 930 \r
 931     if (!jResourceCollectionHandle)\r
 932     {\r
 933         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");\r
 934         return;\r
 935     }\r
 936     if (!jResourceHandleArray)\r
 937     {\r
 938         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");\r
 939         return;\r
 940     }\r
 941 \r
 942     JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
 943         env, jResourceCollectionHandle);\r
 944     if (!jniOcResourceCollectionHandle) return;\r
 945 \r
 946     std::vector<OCResourceHandle> resourceHandleList;\r
 947     int len = env->GetArrayLength(jResourceHandleArray);\r
 948     for (int i = 0; i < len; ++i)\r
 949     {\r
 950         jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);\r
 951         if (!jResourceHandle)\r
 952         {\r
 953             ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");\r
 954             return;\r
 955         }\r
 956 \r
 957         JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
 958             env, jResourceHandle);\r
 959         if (!jniOcResourceHandle) return;\r
 960 \r
 961         resourceHandleList.push_back(\r
 962             jniOcResourceHandle->getOCResourceHandle());\r
 963     }\r
 964 \r
 965     try\r
 966     {\r
 967         OCStackResult result = OCPlatform::bindResources(\r
 968             jniOcResourceCollectionHandle->getOCResourceHandle(),\r
 969             resourceHandleList\r
 970             );\r
 971 \r
 972         if (OC_STACK_OK != result)\r
 973         {\r
 974             ThrowOcException(result, "Failed to bind resources");\r
 975         }\r
 976     }\r
 977     catch (OCException& e)\r
 978     {\r
 979         LOGE("%s", e.reason().c_str());\r
 980         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
 981     }\r
 982 }\r
 983 \r
 984 /*\r
 985 * Class:     org_iotivity_base_OcPlatform\r
 986 * Method:    unbindResource0\r
 987 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V\r
 988 */\r
 989 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResource0\r
 990 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobject jResourceHandle)\r
 991 {\r
 992     LOGI("OcPlatform_unbindResource");\r
 993     if (!jResourceCollectionHandle)\r
 994     {\r
 995         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");\r
 996         return;\r
 997     }\r
 998     if (!jResourceHandle)\r
 999     {\r
1000         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");\r
1001         return;\r
1002     }\r
1003 \r
1004     JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
1005         env, jResourceCollectionHandle);\r
1006     if (!jniOcResourceCollectionHandle) return;\r
1007 \r
1008     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
1009         env, jResourceHandle);\r
1010     if (!jniOcResourceHandle) return;\r
1011 \r
1012     try\r
1013     {\r
1014         OCStackResult result = OCPlatform::unbindResource(\r
1015             jniOcResourceCollectionHandle->getOCResourceHandle(),\r
1016             jniOcResourceHandle->getOCResourceHandle()\r
1017             );\r
1018 \r
1019         if (OC_STACK_OK != result)\r
1020         {\r
1021             ThrowOcException(result, "Failed to unbind resource");\r
1022         }\r
1023     }\r
1024     catch (OCException& e)\r
1025     {\r
1026         LOGE("%s", e.reason().c_str());\r
1027         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1028     }\r
1029 }\r
1030 \r
1031 /*\r
1032 * Class:     org_iotivity_base_OcPlatform\r
1033 * Method:    unbindResources0\r
1034 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V\r
1035 */\r
1036 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResources0\r
1037 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobjectArray jResourceHandleArray)\r
1038 {\r
1039     LOGI("OcPlatform_unbindResources");\r
1040     if (!jResourceCollectionHandle)\r
1041     {\r
1042         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");\r
1043         return;\r
1044     }\r
1045     if (!jResourceHandleArray)\r
1046     {\r
1047         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");\r
1048         return;\r
1049     }\r
1050 \r
1051     JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
1052         env, jResourceCollectionHandle);\r
1053     if (!jniOcResourceCollectionHandle) return;\r
1054 \r
1055     std::vector<OCResourceHandle> resourceHandleList;\r
1056     int len = env->GetArrayLength(jResourceHandleArray);\r
1057     for (int i = 0; i < len; ++i)\r
1058     {\r
1059         jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);\r
1060         if (!jResourceHandle)\r
1061         {\r
1062             ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");\r
1063             return;\r
1064         }\r
1065 \r
1066         JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
1067             env, jResourceHandle);\r
1068         if (!jniOcResourceHandle) return;\r
1069 \r
1070         resourceHandleList.push_back(\r
1071             jniOcResourceHandle->getOCResourceHandle());\r
1072     }\r
1073 \r
1074     try\r
1075     {\r
1076         OCStackResult result = OCPlatform::unbindResources(\r
1077             jniOcResourceCollectionHandle->getOCResourceHandle(),\r
1078             resourceHandleList\r
1079             );\r
1080 \r
1081         if (OC_STACK_OK != result)\r
1082         {\r
1083             ThrowOcException(result, "Failed to unbind resources");\r
1084         }\r
1085     }\r
1086     catch (OCException& e)\r
1087     {\r
1088         LOGE("%s", e.reason().c_str());\r
1089         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1090     }\r
1091 }\r
1092 \r
1093 /*\r
1094 * Class:     org_iotivity_base_OcPlatform\r
1095 * Method:    bindTypeToResource0\r
1096 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V\r
1097 */\r
1098 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindTypeToResource0\r
1099 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jstring jResourceTypeName)\r
1100 {\r
1101     LOGI("OcPlatform_bindTypeToResource");\r
1102     if (!jResourceHandle)\r
1103     {\r
1104         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");\r
1105         return;\r
1106     }\r
1107     std::string typeName;\r
1108     if (jResourceTypeName)\r
1109     {\r
1110         typeName = env->GetStringUTFChars(jResourceTypeName, NULL);\r
1111     }\r
1112 \r
1113     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
1114         env, jResourceHandle);\r
1115     if (!jniOcResourceHandle) return;\r
1116 \r
1117     try\r
1118     {\r
1119         OCStackResult result = OCPlatform::bindTypeToResource(\r
1120             jniOcResourceHandle->getOCResourceHandle(),\r
1121             typeName\r
1122             );\r
1123 \r
1124         if (OC_STACK_OK != result)\r
1125         {\r
1126             ThrowOcException(result, "Failed to bind type to resource");\r
1127         }\r
1128     }\r
1129     catch (OCException& e)\r
1130     {\r
1131         LOGE("%s", e.reason().c_str());\r
1132         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1133     }\r
1134 }\r
1135 \r
1136 /*\r
1137 * Class:     org_iotivity_base_OcPlatform\r
1138 * Method:    bindInterfaceToResource0\r
1139 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V\r
1140 */\r
1141 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindInterfaceToResource0\r
1142 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jstring jResourceInterfaceName)\r
1143 {\r
1144     LOGI("OcPlatform_bindInterfaceToResource");\r
1145     if (!jResourceHandle)\r
1146     {\r
1147         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");\r
1148         return;\r
1149     }\r
1150     std::string interfaceName;\r
1151     if (jResourceInterfaceName)\r
1152     {\r
1153         interfaceName = env->GetStringUTFChars(jResourceInterfaceName, NULL);\r
1154     }\r
1155 \r
1156     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(\r
1157         env, jResourceHandle);\r
1158     if (!jniOcResourceHandle) return;\r
1159 \r
1160     try\r
1161     {\r
1162         OCStackResult result = OCPlatform::bindInterfaceToResource(\r
1163             jniOcResourceHandle->getOCResourceHandle(),\r
1164             interfaceName\r
1165             );\r
1166 \r
1167         if (OC_STACK_OK != result)\r
1168         {\r
1169             ThrowOcException(result, "Failed to bind interface to resource");\r
1170         }\r
1171     }\r
1172     catch (OCException& e)\r
1173     {\r
1174         LOGE("%s", e.reason().c_str());\r
1175         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1176     }\r
1177 }\r
1178 \r
1179 /*\r
1180 * Class:     org_iotivity_base_OcPlatform\r
1181 * Method:    startPresence0\r
1182 * Signature: (I)V\r
1183 */\r
1184 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_startPresence0\r
1185 (JNIEnv *env, jclass clazz, jint ttl)\r
1186 {\r
1187     LOGI("OcPlatform_startPresence");\r
1188 \r
1189     try\r
1190     {\r
1191         OCStackResult result = OCPlatform::startPresence((unsigned int)ttl);\r
1192 \r
1193         if (OC_STACK_OK != result)\r
1194         {\r
1195             ThrowOcException(result, "Failed to start presence");\r
1196         }\r
1197     }\r
1198     catch (OCException& e)\r
1199     {\r
1200         LOGE("%s", e.reason().c_str());\r
1201         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1202     }\r
1203 }\r
1204 \r
1205 /*\r
1206 * Class:     org_iotivity_base_OcPlatform\r
1207 * Method:    stopPresence0\r
1208 * Signature: ()V\r
1209 */\r
1210 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_stopPresence0\r
1211 (JNIEnv *env, jclass clazz)\r
1212 {\r
1213     LOGI("OcPlatform_stopPresence");\r
1214 \r
1215     try\r
1216     {\r
1217         OCStackResult result = OCPlatform::stopPresence();\r
1218 \r
1219         if (OC_STACK_OK != result)\r
1220         {\r
1221             ThrowOcException(result, "Failed to stop presence");\r
1222         }\r
1223     }\r
1224     catch (OCException& e)\r
1225     {\r
1226         LOGE("%s", e.reason().c_str());\r
1227         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1228     }\r
1229 }\r
1230 \r
1231 /*\r
1232 * Class:     org_iotivity_base_OcPlatform\r
1233 * Method:    subscribePresence0\r
1234 * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;\r
1235 */\r
1236 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence0\r
1237 (JNIEnv *env, jclass clazz, jstring jHost, jint jConnectivityType, jobject jListener)\r
1238 {\r
1239     LOGD("OcPlatform_subscribePresence");\r
1240     std::string host;\r
1241     if (jHost)\r
1242     {\r
1243         host = env->GetStringUTFChars(jHost, NULL);\r
1244     }\r
1245     if (!jListener)\r
1246     {\r
1247         ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");\r
1248         return nullptr;\r
1249     }\r
1250 \r
1251     JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);\r
1252 \r
1253     SubscribeCallback subscribeCallback = [onPresenceListener](OCStackResult result, const unsigned int nonce,\r
1254         const std::string& hostAddress)\r
1255     {\r
1256         onPresenceListener->onPresenceCallback(result, nonce, hostAddress);\r
1257     };\r
1258 \r
1259     OCPlatform::OCPresenceHandle presenceHandle;\r
1260     try\r
1261     {\r
1262         OCStackResult result = OCPlatform::subscribePresence(\r
1263             presenceHandle,\r
1264             host,\r
1265             JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),\r
1266             subscribeCallback);\r
1267 \r
1268         if (OC_STACK_OK != result)\r
1269         {\r
1270             ThrowOcException(result, "subscribe presence has failed");\r
1271         }\r
1272     }\r
1273     catch (OCException& e)\r
1274     {\r
1275         LOGE("%s", e.reason().c_str());\r
1276         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1277         return nullptr;\r
1278     }\r
1279 \r
1280     JniOcPresenceHandle* jniPresenceHandle = new JniOcPresenceHandle(onPresenceListener, presenceHandle);\r
1281     jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);\r
1282     jobject jPresenceHandle = env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);\r
1283     if (!jPresenceHandle)\r
1284     {\r
1285         LOGE("Failed to create OcPresenceHandle");\r
1286         delete jniPresenceHandle;\r
1287     }\r
1288 \r
1289     return jPresenceHandle;\r
1290 }\r
1291 \r
1292 /*\r
1293 * Class:     org_iotivity_base_OcPlatform\r
1294 * Method:    subscribePresence1\r
1295 * Signature: (Ljava/lang/String;Ljava/lang/String;I\r
1296 Lorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;\r
1297 */\r
1298 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence1\r
1299 (JNIEnv *env, jclass clazz, jstring jHost, jstring jResourceType, jint jConnectivityType, jobject jListener)\r
1300 {\r
1301     LOGD("OcPlatform_subscribePresence1");\r
1302     std::string host;\r
1303     if (jHost)\r
1304     {\r
1305         host = env->GetStringUTFChars(jHost, NULL);\r
1306     }\r
1307     std::string resourceType;\r
1308     if (jResourceType)\r
1309     {\r
1310         resourceType = env->GetStringUTFChars(jResourceType, NULL);\r
1311     }\r
1312     if (!jListener)\r
1313     {\r
1314         ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");\r
1315         return nullptr;\r
1316     }\r
1317 \r
1318     JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);\r
1319 \r
1320     SubscribeCallback subscribeCallback = [onPresenceListener](OCStackResult result,\r
1321         const unsigned int nonce, const std::string& hostAddress)\r
1322     {\r
1323         onPresenceListener->onPresenceCallback(result, nonce, hostAddress);\r
1324     };\r
1325 \r
1326     OCPlatform::OCPresenceHandle presenceHandle;\r
1327     try\r
1328     {\r
1329         OCStackResult result = OCPlatform::subscribePresence(\r
1330             presenceHandle,\r
1331             host,\r
1332             resourceType,\r
1333             JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),\r
1334             subscribeCallback);\r
1335 \r
1336         if (OC_STACK_OK != result)\r
1337         {\r
1338             ThrowOcException(result, "subscribe presence has failed");\r
1339         }\r
1340     }\r
1341     catch (OCException& e)\r
1342     {\r
1343         LOGE("%s", e.reason().c_str());\r
1344         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1345         return nullptr;\r
1346     }\r
1347 \r
1348     JniOcPresenceHandle* jniPresenceHandle = new JniOcPresenceHandle(onPresenceListener, presenceHandle);\r
1349     jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);\r
1350     jobject jPresenceHandle = env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);\r
1351     if (!jPresenceHandle)\r
1352     {\r
1353         LOGE("Failed to create OcPresenceHandle");\r
1354         delete jniPresenceHandle;\r
1355     }\r
1356     return jPresenceHandle;\r
1357 }\r
1358 \r
1359 /*\r
1360 * Class:     org_iotivity_base_OcPlatform\r
1361 * Method:    unsubscribePresence0\r
1362 * Signature: (Lorg/iotivity/base/OcPresenceHandle;)V\r
1363 */\r
1364 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unsubscribePresence0\r
1365 (JNIEnv *env, jclass clazz, jobject jPresenceHandle)\r
1366 {\r
1367     LOGD("OcPlatform_unsubscribePresence");\r
1368     if (!jPresenceHandle)\r
1369     {\r
1370         ThrowOcException(OC_STACK_INVALID_PARAM, "presenceHandle cannot be null");\r
1371         return;\r
1372     }\r
1373     JniOcPresenceHandle* jniPresenceHandle = JniOcPresenceHandle::getJniOcPresenceHandlePtr(env, jPresenceHandle);\r
1374     if (!jniPresenceHandle) return;\r
1375 \r
1376     OCPresenceHandle presenceHandle = jniPresenceHandle->getOCPresenceHandle();\r
1377 \r
1378     try\r
1379     {\r
1380         OCStackResult result = OCPlatform::unsubscribePresence(presenceHandle);\r
1381 \r
1382         if (OC_STACK_OK != result)\r
1383         {\r
1384             ThrowOcException(result, "unsubscribe presence has failed");\r
1385             return;\r
1386         }\r
1387         jweak jwOnPresenceListener = jniPresenceHandle->getJniOnPresenceListener()->getJWListener();\r
1388         if (jwOnPresenceListener)\r
1389         {\r
1390             RemoveOnPresenceListener(env, jwOnPresenceListener);\r
1391         }\r
1392     }\r
1393     catch (OCException& e)\r
1394     {\r
1395         LOGE("%s", e.reason().c_str());\r
1396         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1397     }\r
1398 }\r
1399 \r
1400 /*\r
1401 * Class:     org_iotivity_base_OcPlatform\r
1402 * Method:    constructResourceObject0\r
1403 * Signature: (Ljava/lang/String;Ljava/lang/String;IZ[Ljava/lang/String;[Ljava/lang/String;)\r
1404 Lorg/iotivity/base/OcResource;\r
1405 */\r
1406 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_constructResourceObject0\r
1407 (JNIEnv *env, jclass clazz, jstring jHost, jstring jUri, jint jConnectivityType,\r
1408 jboolean jIsObservable, jobjectArray jResourceTypeArray, jobjectArray jInterfaceArray)\r
1409 {\r
1410     LOGD("OcPlatform_constructResourceObject");\r
1411     std::string host;\r
1412     if (jHost)\r
1413     {\r
1414         host = env->GetStringUTFChars(jHost, NULL);\r
1415     }\r
1416     std::string uri;\r
1417     if (jUri)\r
1418     {\r
1419         uri = env->GetStringUTFChars(jUri, NULL);\r
1420     }\r
1421     if (!jResourceTypeArray)\r
1422     {\r
1423         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceTypeList cannot be null");\r
1424         return nullptr;\r
1425     }\r
1426     if (!jInterfaceArray)\r
1427     {\r
1428         ThrowOcException(OC_STACK_INVALID_PARAM, "interfaceList cannot be null");\r
1429         return nullptr;\r
1430     }\r
1431 \r
1432     std::vector<std::string> resourceTypes;\r
1433     JniUtils::convertJavaStrArrToStrVector(env, jResourceTypeArray, resourceTypes);\r
1434 \r
1435     std::vector<std::string> interfaces;\r
1436     JniUtils::convertJavaStrArrToStrVector(env, jInterfaceArray, interfaces);\r
1437 \r
1438     std::shared_ptr<OCResource> resource = OCPlatform::constructResourceObject(\r
1439         host,\r
1440         uri,\r
1441         JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),\r
1442         static_cast<bool>(jIsObservable),\r
1443         resourceTypes,\r
1444         interfaces);\r
1445 \r
1446     if (!resource)\r
1447     {\r
1448         ThrowOcException(OC_STACK_ERROR, "Failed to create OCResource");\r
1449         return nullptr;\r
1450     }\r
1451 \r
1452     JniOcResource *jniOcResource = new JniOcResource(resource);\r
1453     jlong handle = reinterpret_cast<jlong>(jniOcResource);\r
1454 \r
1455     jobject jResource = env->NewObject(g_cls_OcResource, g_mid_OcResource_ctor);\r
1456     if (!jResource)\r
1457     {\r
1458         delete jniOcResource;\r
1459         return nullptr;\r
1460     }\r
1461     SetHandle<JniOcResource>(env, jResource, jniOcResource);\r
1462     if (env->ExceptionCheck())\r
1463     {\r
1464         delete jniOcResource;\r
1465         return nullptr;\r
1466     }\r
1467     return jResource;\r
1468 }\r
1469 \r
1470 /*\r
1471 * Class:     org_iotivity_base_OcPlatform\r
1472 * Method:    sendResponse0\r
1473 * Signature: (Lorg/iotivity/base/OcResourceResponse;)V\r
1474 */\r
1475 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_sendResponse0\r
1476 (JNIEnv *env, jclass clazz, jobject jResourceResponse)\r
1477 {\r
1478     LOGD("OcPlatform_sendResponse");\r
1479     if (!jResourceResponse)\r
1480     {\r
1481         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");\r
1482         return;\r
1483     }\r
1484 \r
1485     JniOcResourceResponse *jniResponse = JniOcResourceResponse::getJniOcResourceResponsePtr(\r
1486         env, jResourceResponse);\r
1487     if (!jniResponse) return;\r
1488 \r
1489     try\r
1490     {\r
1491         OCStackResult result = OCPlatform::sendResponse(jniResponse->getOCResourceResponse());\r
1492 \r
1493         if (OC_STACK_OK != result)\r
1494         {\r
1495             ThrowOcException(result, "failed to send response");\r
1496         }\r
1497     }\r
1498     catch (OCException& e)\r
1499     {\r
1500         LOGE("%s", e.reason().c_str());\r
1501         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());\r
1502     }\r
1503 }