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