android/android_api/base/jni/JniOcSecureResource.cpp

   1 /*
   2 * //******************************************************************
   3 * //
   4 * // Copyright 2015 Samsung Electronics All Rights Reserved.
   5 * //
   6 * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   7 * //
   8 * // Licensed under the Apache License, Version 2.0 (the "License");
   9 * // you may not use this file except in compliance with the License.
  10 * // You may obtain a copy of the License at
  11 * //
  12 * //      http://www.apache.org/licenses/LICENSE-2.0
  13 * //
  14 * // Unless required by applicable law or agreed to in writing, software
  15 * // distributed under the License is distributed on an "AS IS" BASIS,
  16 * // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17 * // See the License for the specific language governing permissions and
  18 * // limitations under the License.
  19 * //
  20 * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  21 */
  22
  23 #include "JniOcSecureResource.h"
  24 #include "JniSecureUtils.h"
  25 #include "aclresource.h"
  26 #include "oic_malloc.h"
  27 #include "oic_string.h"
  28 namespace PH = std::placeholders;
  29
  30 JniOcSecureResource::JniOcSecureResource(std::shared_ptr<OCSecureResource> device)
  31     : m_sharedSecureResource(device)
  32 {}
  33
  34 JniOcSecureResource::~JniOcSecureResource()
  35 {
  36     LOGD("~JniOcSecureResource()");
  37     m_sharedSecureResource = nullptr;
  38 }
  39
  40 std::string JniOcSecureResource::getIpAddr()
  41 {
  42     return m_sharedSecureResource->getDevAddr();
  43 }
  44
  45 std::string JniOcSecureResource::getDeviceID()
  46 {
  47     return m_sharedSecureResource->getDeviceID();
  48 }
  49
  50 int JniOcSecureResource::getDeviceStatus()
  51 {
  52     return m_sharedSecureResource->getDeviceStatus();
  53 }
  54
  55 bool JniOcSecureResource::getOwnedStatus()
  56 {
  57     return m_sharedSecureResource->getOwnedStatus();
  58 }
  59
  60 OCSecureResource* JniOcSecureResource::getDevicePtr()
  61 {
  62     return m_sharedSecureResource.get();
  63 }
  64
  65 JniOcSecureResource* JniOcSecureResource::getJniOcSecureResourcePtr(JNIEnv *env, jobject thiz)
  66 {
  67     JniOcSecureResource *secureResource = GetHandle<JniOcSecureResource>(env, thiz);
  68     if (env->ExceptionCheck())
  69     {
  70         LOGE("Failed to get native handle from OcSecureResource");
  71     }
  72     if (!secureResource)
  73     {
  74         ThrowOcException(JNI_NO_NATIVE_POINTER, "");
  75     }
  76     return secureResource;
  77 }
  78
  79 JniProvisionResultListner* JniOcSecureResource::AddProvisionResultListener(JNIEnv* env,
  80         jobject jListener)
  81 {
  82     JniProvisionResultListner *resultListener = NULL;
  83     resultMapLock.lock();
  84
  85     for (auto it = resultMap.begin(); it != resultMap.end(); ++it)
  86     {
  87         if (env->IsSameObject(jListener, it->first))
  88         {
  89             auto refPair = it->second;
  90             resultListener = refPair.first;
  91             refPair.second++;
  92             it->second = refPair;
  93             resultMap.insert(*it);
  94             LOGD("Provision resultListener: ref. count incremented");
  95             break;
  96         }
  97     }
  98     if (!resultListener)
  99     {
 100         resultListener = new JniProvisionResultListner(env, jListener,
 101             RemoveCallback(std::bind(&JniOcSecureResource::RemoveProvisionResultListener,
 102                     this, PH::_1, PH::_2)));
 103         jobject jgListener = env->NewGlobalRef(jListener);
 104
 105         resultMap.insert(std::pair < jobject, std::pair < JniProvisionResultListner*,
 106                 int >> (jgListener, std::pair<JniProvisionResultListner*, int>(resultListener, 1)));
 107         LOGD("Provision resultListener: new listener");
 108     }
 109     resultMapLock.unlock();
 110     return resultListener;
 111 }
 112
 113 void JniOcSecureResource::RemoveProvisionResultListener(JNIEnv* env, jobject jListener)
 114 {
 115     resultMapLock.lock();
 116
 117     for (auto it = resultMap.begin(); it != resultMap.end(); ++it)
 118     {
 119         if (env->IsSameObject(jListener, it->first))
 120         {
 121             auto refPair = it->second;
 122             if (refPair.second > 1)
 123             {
 124                 refPair.second--;
 125                 it->second = refPair;
 126                 resultMap.insert(*it);
 127                 LOGI("Provision resultListener: ref. count decremented");
 128             }
 129             else
 130             {
 131                 env->DeleteGlobalRef(it->first);
 132                 JniProvisionResultListner* listener = refPair.first;
 133                 delete listener;
 134                 resultMap.erase(it);
 135                 LOGI("Provision resultListener removed");
 136             }
 137             break;
 138         }
 139     }
 140     resultMapLock.unlock();
 141 }
 142
 143 OCStackResult JniOcSecureResource::doOwnershipTransfer(JNIEnv* env, jobject jListener)
 144 {
 145     JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
 146
 147     ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
 148     {
 149         resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::OWNERSHIPTRANSFER);
 150     };
 151
 152     return m_sharedSecureResource->doOwnershipTransfer(resultCallback);
 153 }
 154
 155 OCStackResult JniOcSecureResource::getLinkedDevices(JNIEnv *env, UuidList_t &uuidList)
 156 {
 157     return m_sharedSecureResource->getLinkedDevices(uuidList);
 158 }
 159
 160 OCStackResult JniOcSecureResource::removeDevice(JNIEnv* env, jint timeout, jobject jListener)
 161 {
 162     JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
 163
 164     ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
 165     {
 166         resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::REMOVEDEVICE);
 167     };
 168
 169     return m_sharedSecureResource->removeDevice((int)timeout, resultCallback);
 170 }
 171
 172 OCStackResult JniOcSecureResource::unlinkDevices(JNIEnv* env, jobject _device2, jobject jListener)
 173 {
 174     JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
 175
 176     ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
 177     {
 178         resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::UNLINKDEVICES);
 179     };
 180
 181     JniOcSecureResource *device2 = JniOcSecureResource::getJniOcSecureResourcePtr(env, _device2);
 182     if (!device2)
 183     {
 184         return OC_STACK_ERROR;
 185     }
 186
 187     return m_sharedSecureResource->unlinkDevices(*device2->getDevicePtr(), resultCallback);
 188 }
 189
 190 OCStackResult JniOcSecureResource::provisionCredentials(JNIEnv* env, jint type, jint keySize,
 191         jobject _device2, jobject jListener)
 192 {
 193     JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
 194
 195     ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
 196     {
 197         resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::PROVISIONCREDENTIALS);
 198     };
 199
 200     JniOcSecureResource *device2 = JniOcSecureResource::getJniOcSecureResourcePtr(env, _device2);
 201     if (!device2)
 202     {
 203         return OC_STACK_ERROR;
 204     }
 205
 206     Credential cred((OicSecCredType_t)type, keySize);
 207
 208     return m_sharedSecureResource->provisionCredentials(cred, *device2->getDevicePtr(),
 209             resultCallback);
 210 }
 211
 212 OCStackResult JniOcSecureResource::provisionACL(JNIEnv* env, jobject _acl, jobject jListener)
 213 {
 214     OCStackResult ret;
 215     JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
 216     OicSecAcl_t *acl = (OicSecAcl_t*)OICCalloc(1, sizeof(OicSecAcl_t));
 217
 218     if (!acl)
 219     {
 220         return OC_STACK_NO_MEMORY;
 221     }
 222
 223     if (OC_STACK_OK != JniSecureUtils::convertJavaACLToOCAcl(env, _acl, acl))
 224     {
 225         JniSecureUtils::FreeACLList(acl);
 226         return OC_STACK_ERROR;
 227     }
 228
 229     ResultCallBack resultCallback = [acl, resultListener](PMResultList_t *result, int hasError)
 230     {
 231         JniSecureUtils::FreeACLList(acl);
 232         resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::PROVISIONACL);
 233     };
 234     ret = m_sharedSecureResource->provisionACL(acl, resultCallback);
 235
 236     if (ret != OC_STACK_OK)
 237     {
 238         JniSecureUtils::FreeACLList(acl);
 239     }
 240     return ret;
 241 }
 242
 243 OCStackResult JniOcSecureResource::provisionDirectPairing(JNIEnv* env, jobjectArray jpdacls,
 244         jobject jListener, std::string pin, std::vector<int> prms, int edp)
 245 {
 246     OCStackResult ret;
 247     JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
 248
 249     jsize len = env->GetArrayLength(jpdacls);
 250
 251     OicSecPconf_t *pconf = nullptr;
 252     OicSecPdAcl_t *head = nullptr;
 253
 254     for (jsize i = 0; i < len; ++i)
 255     {
 256         OicSecPdAcl_t *pdacl = new OicSecPdAcl_t;
 257         if (!pdacl)
 258         {
 259             return OC_STACK_NO_MEMORY;
 260         }
 261
 262         memset(pdacl, 0, sizeof(OicSecPdAcl_t));
 263         pdacl->next = nullptr;
 264
 265         jobject jpdacl  = env->GetObjectArrayElement(jpdacls, i);
 266
 267         if (OC_STACK_OK != JniSecureUtils::convertJavaPdACLToOCAcl(env, jpdacl, pdacl))
 268         {
 269             delete pdacl;
 270             return OC_STACK_ERROR;
 271         }
 272
 273         pdacl->next = head;
 274         head = pdacl;
 275     }
 276
 277     pconf = new OicSecPconf_t;
 278     memset(pconf, 0, sizeof(OicSecPconf_t));
 279     pconf->edp = edp;
 280     pconf->prmLen = prms.size();
 281     pconf->prm = new OicSecPrm_t[pconf->prmLen];
 282     pconf->pddevLen = 0;
 283
 284     for (int i = 0 ; i < prms.size(); i++)
 285         pconf->prm[i] = (OicSecPrm_t)prms[i];
 286
 287     memcpy(pconf->pin.val, pin.c_str(), DP_PIN_LENGTH);
 288     pconf->pdacls = head;
 289
 290     ResultCallBack resultCallback = [head, resultListener, pconf, prms]
 291         (PMResultList_t *result, int hasError)
 292         {
 293             OicSecPdAcl_t *tmp1, *tmp2;
 294             tmp1 = head;
 295             while (tmp1)
 296             {
 297                 tmp2 = tmp1->next;
 298                 delete tmp1;
 299                 tmp1 = tmp2;
 300             }
 301
 302             delete pconf->prm;
 303             delete pconf;
 304             resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::PROVISIONDIRECTPAIRING);
 305         };
 306
 307     ret = m_sharedSecureResource->provisionDirectPairing(pconf, resultCallback);
 308
 309     if (ret != OC_STACK_OK)
 310     {
 311         OicSecPdAcl_t *tmp1, *tmp2;
 312         tmp1 = head;
 313         while (tmp1)
 314         {
 315             tmp2 = tmp1->next;
 316             delete tmp1;
 317             tmp1 = tmp2;
 318         }
 319
 320         delete pconf->prm;
 321         delete pconf;
 322     }
 323     return ret;
 324 }
 325
 326 OCStackResult JniOcSecureResource::provisionPairwiseDevices(JNIEnv* env, jint type, jint keySize,
 327         jobject _acl1, jobject _device2, jobject _acl2, jobject jListener)
 328 {
 329     OCStackResult ret;
 330
 331     JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
 332     JniOcSecureResource *device2 = JniOcSecureResource::getJniOcSecureResourcePtr(env, _device2);
 333     if (!device2)
 334     {
 335         return OC_STACK_ERROR;
 336     }
 337
 338     Credential cred((OicSecCredType_t)type, keySize);
 339
 340     OicSecAcl_t *acl1 = nullptr;
 341     OicSecAcl_t *acl2 = nullptr;
 342
 343     if (_acl1)
 344     {
 345         acl1 = (OicSecAcl_t*)OICCalloc(1, sizeof(OicSecAcl_t));
 346         if (!acl1)
 347         {
 348             return OC_STACK_NO_MEMORY;
 349         }
 350
 351         if (OC_STACK_OK != JniSecureUtils::convertJavaACLToOCAcl(env, _acl1, acl1))
 352         {
 353             JniSecureUtils::FreeACLList(acl1);
 354             return OC_STACK_ERROR;
 355         }
 356     }
 357
 358     if (_acl2)
 359     {
 360         acl2 = (OicSecAcl_t*)OICCalloc(1, sizeof(OicSecAcl_t));
 361         if (!acl2)
 362         {
 363             JniSecureUtils::FreeACLList(acl1);
 364             return OC_STACK_NO_MEMORY;
 365         }
 366
 367         if (OC_STACK_OK != JniSecureUtils::convertJavaACLToOCAcl(env, _acl2, acl2))
 368         {
 369             JniSecureUtils::FreeACLList(acl1);
 370             JniSecureUtils::FreeACLList(acl2);
 371             return OC_STACK_ERROR;
 372         }
 373     }
 374
 375     ResultCallBack resultCallback = [acl1, acl2, resultListener](PMResultList_t *result,
 376             int hasError)
 377     {
 378         JniSecureUtils::FreeACLList(acl1);
 379         JniSecureUtils::FreeACLList(acl2);
 380         resultListener->ProvisionResultCallback(result, hasError,
 381                 ListenerFunc::PROVISIONPAIRWISEDEVICES);
 382     };
 383
 384     ret = m_sharedSecureResource->provisionPairwiseDevices(cred, acl1,
 385             *device2->getDevicePtr(), acl2, resultCallback);
 386     if (ret != OC_STACK_OK)
 387     {
 388         JniSecureUtils::FreeACLList(acl1);
 389         JniSecureUtils::FreeACLList(acl2);
 390     }
 391     return ret;
 392 }
 393
 394 /*
 395  * Class:     org_iotivity_base_OcSecureResource
 396  * Method:    doOwnershipTransfer
 397  * Signature: (Lorg/iotivity/base/OcSecureResource/doOwnershipTransferListener;)V
 398  */
 399 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_doOwnershipTransfer
 400 (JNIEnv *env, jobject thiz, jobject jListener)
 401 {
 402     LOGD("OcSecureResource_doOwnershipTransfer");
 403     if (!jListener)
 404     {
 405         ThrowOcException(OC_STACK_INVALID_PARAM, "provisionResultListener cannot be null");
 406         return;
 407     }
 408
 409     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 410     if (!secureResource)
 411     {
 412         return;
 413     }
 414
 415     try
 416     {
 417         OCStackResult result = secureResource->doOwnershipTransfer(env, jListener);
 418         if (OC_STACK_OK != result)
 419         {
 420             ThrowOcException(result, "OcSecureResource_doOwnershipTransfer");
 421             return;
 422         }
 423     }
 424     catch (OCException& e)
 425     {
 426         LOGE("%s", e.reason().c_str());
 427         ThrowOcException(e.code(), e.reason().c_str());
 428     }
 429 }
 430
 431 /*
 432  * Class:     org_iotivity_base_OcSecureResource
 433  * Method:    removeDevice
 434  * Signature: (ILorg/iotivity/base/OcSecureResource/removeDevice;)V
 435  */
 436 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_removeDevice
 437 (JNIEnv *env, jobject thiz, jint timeout, jobject jListener)
 438 {
 439     LOGD("OcSecureResource_removeDevice");
 440     if (timeout < 0)
 441     {
 442         ThrowOcException(OC_STACK_INVALID_PARAM, "Timeout value cannot be negative");
 443         return;
 444     }
 445
 446     if (!jListener)
 447     {
 448         ThrowOcException(OC_STACK_INVALID_PARAM, "provisionResultListener cannot be null");
 449         return;
 450     }
 451
 452     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 453     if (!secureResource)
 454     {
 455         return;
 456     }
 457
 458     try
 459     {
 460         OCStackResult result = secureResource->removeDevice(env, timeout, jListener);
 461         if (OC_STACK_OK != result)
 462         {
 463             ThrowOcException(result, "OcSecureResource_removeDevice");
 464             return;
 465         }
 466     }
 467     catch (OCException& e)
 468     {
 469         LOGE("%s", e.reason().c_str());
 470         ThrowOcException(e.code(), e.reason().c_str());
 471     }
 472 }
 473
 474 /*
 475  * Class:     org_iotivity_base_OcSecureResource
 476  * Method:    unlinkDevices
 477  * Signature: (Lorg/iotivity/base/OcSecureResource/unlinkDevices;)V
 478  */
 479 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_unlinkDevices
 480 (JNIEnv *env, jobject thiz, jobject device2, jobject jListener)
 481 {
 482     LOGD("OcSecureResource_unlinkDevices");
 483     if (!jListener || !device2)
 484     {
 485         ThrowOcException(OC_STACK_INVALID_PARAM, "provisionResultListener or device2 cannot be null");
 486         return;
 487     }
 488
 489     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 490     if (!secureResource)
 491     {
 492         return;
 493     }
 494
 495     try
 496     {
 497         OCStackResult result = secureResource->unlinkDevices(env, device2, jListener);
 498         if (OC_STACK_OK != result)
 499         {
 500             ThrowOcException(result, "OcSecureResource_unlinkDevices");
 501             return;
 502         }
 503     }
 504     catch (OCException& e)
 505     {
 506         LOGE("%s", e.reason().c_str());
 507         ThrowOcException(e.code(), e.reason().c_str());
 508     }
 509 }
 510
 511 /*
 512  * Class:     org_iotivity_base_OcSecureResource
 513  * Method:    provisionCredentials1
 514  * Signature: (Lorg/iotivity/base/OcSecureResource/provisionCredentials;)V
 515  */
 516 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionCredentials1
 517 (JNIEnv *env, jobject thiz, jint type, jint keySize, jobject device2, jobject jListener)
 518 {
 519     LOGD("OcSecureResource_provisionCredentials");
 520     if (!jListener || !device2)
 521     {
 522         ThrowOcException(OC_STACK_INVALID_PARAM, "provisionResultListener or device2 cannot be null");
 523         return;
 524     }
 525
 526     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 527     if (!secureResource)
 528     {
 529         return;
 530     }
 531
 532     try
 533     {
 534         OCStackResult result = secureResource->provisionCredentials(env, type, keySize, device2,
 535                 jListener);
 536         if (OC_STACK_OK != result)
 537         {
 538             ThrowOcException(result, "OcSecureResource_provisionCredentials");
 539             return;
 540         }
 541     }
 542     catch (OCException& e)
 543     {
 544         LOGE("%s", e.reason().c_str());
 545         ThrowOcException(e.code(), e.reason().c_str());
 546     }
 547 }
 548
 549 /*
 550  * Class:     org_iotivity_base_OcSecureResource
 551  * Method:    provisionACL
 552  * Signature: (Lorg/iotivity/base/OcSecureResource/provisionACL;)V
 553  */
 554 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionACL
 555 (JNIEnv *env, jobject thiz, jobject acl, jobject jListener)
 556 {
 557     LOGD("OcSecureResource_provisionACL");
 558     if (!jListener || !acl)
 559     {
 560         ThrowOcException(OC_STACK_INVALID_PARAM, "provisionResultListener or acl cannot be null");
 561         return;
 562     }
 563
 564     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 565     if (!secureResource)
 566     {
 567         return;
 568     }
 569
 570     try
 571     {
 572         OCStackResult result = secureResource->provisionACL(env, acl, jListener);
 573         if (OC_STACK_OK != result)
 574         {
 575             ThrowOcException(result, "OcSecureResource_provisionACL");
 576             return;
 577         }
 578     }
 579     catch (OCException& e)
 580     {
 581         LOGE("%s", e.reason().c_str());
 582         ThrowOcException(e.code(), e.reason().c_str());
 583     }
 584 }
 585
 586 /*
 587  * Class:     org_iotivity_base_OcSecureResource
 588  * Method:    provisionPairwiseDevices1
 589  * Signature: (Lorg/iotivity/base/OcSecureResource/provisionPairwiseDevices;)V
 590  */
 591 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionPairwiseDevices1
 592 (JNIEnv *env, jobject thiz, jint type, jint keySize, jobject acl1, jobject device2,
 593         jobject acl2, jobject jListener)
 594 {
 595     LOGD("OcSecureResource_provisionPairwiseDevices");
 596     if (!jListener || !device2)
 597     {
 598         ThrowOcException(OC_STACK_INVALID_PARAM, "Invalid Parameters");
 599         return;
 600     }
 601
 602     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 603     if (!secureResource)
 604     {
 605         return;
 606     }
 607
 608     try
 609     {
 610         OCStackResult result = secureResource->provisionPairwiseDevices(env, type, keySize,
 611                 acl1, device2, acl2, jListener);
 612         if (OC_STACK_OK != result)
 613         {
 614             ThrowOcException(result, "OcSecureResource_provisionPairwiseDevices");
 615             return;
 616         }
 617     }
 618     catch (OCException& e)
 619     {
 620         LOGE("%s", e.reason().c_str());
 621         ThrowOcException(e.code(), e.reason().c_str());
 622     }
 623 }
 624
 625 /*
 626  * Class:     org_iotivity_base_OcSecureResource
 627  * Method:    provisionDirectPairing
 628  * Signature: (Ljava/lang/String;[Lorg/iotivity/base/OicSecPdAcl;ILorg/iotivity/base/OcSecureResource/ProvisionDirectPairingListener;I)V
 629  */
 630 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionDirectPairing
 631 (JNIEnv *env, jobject thiz, jstring jpin, jobjectArray pdacls, jintArray jprmType,
 632     jint jedp, jobject jListener)
 633 {
 634     LOGD("OcSecureResource_provisionDirectPairing");
 635     if (!jListener || !pdacls || !jpin || ! jprmType)
 636     {
 637         ThrowOcException(OC_STACK_INVALID_PARAM, "Invalid Parameters");
 638         return;
 639     }
 640     std::string pin = env->GetStringUTFChars(jpin, nullptr);
 641
 642     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 643     if (!secureResource)
 644     {
 645         return;
 646     }
 647
 648     const jsize len = env->GetArrayLength(jprmType);
 649     jint* ints = env->GetIntArrayElements(jprmType, nullptr);
 650     std::vector<int> value;
 651     for (jsize i = 0; i < len; ++i)
 652     {
 653         value.push_back(static_cast<int>(ints[i]));
 654     }
 655     env->ReleaseIntArrayElements(jprmType, ints, JNI_ABORT);
 656
 657     try
 658     {
 659         OCStackResult result = secureResource->provisionDirectPairing(env, pdacls, jListener,
 660                 pin, value, static_cast<int>(jedp));
 661         if (OC_STACK_OK != result)
 662         {
 663             ThrowOcException(result, "OcSecureResource_provisionDirectPairing");
 664             return;
 665         }
 666     }
 667     catch (OCException& e)
 668     {
 669         LOGE("%s", e.reason().c_str());
 670         ThrowOcException(e.code(), e.reason().c_str());
 671     }
 672 }
 673
 674 /*
 675  * Class:     org_iotivity_base_OcSecureResource
 676  * Method:    getLinkedDevices
 677  * Signature: ()Ljava/util/List;
 678  */
 679 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcSecureResource_getLinkedDevices
 680 (JNIEnv *env, jobject thiz)
 681 {
 682     LOGD("OcSecureResource_getLinkedDevices");
 683     UuidList_t uuidList;
 684
 685     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 686     if (!secureResource)
 687     {
 688         return nullptr;
 689     }
 690
 691     try
 692     {
 693         OCStackResult result = secureResource->getLinkedDevices(env, uuidList);
 694         if (OC_STACK_OK != result)
 695         {
 696             ThrowOcException(result, "OcSecureResource_getLinkedDevices");
 697             return nullptr;
 698         }
 699         return JniSecureUtils::convertUUIDVectorToJavaStrList(env, uuidList);
 700     }
 701     catch (OCException& e)
 702     {
 703         LOGE("%s", e.reason().c_str());
 704         ThrowOcException(e.code(), e.reason().c_str());
 705         return nullptr;
 706     }
 707 }
 708
 709 /*
 710  * Class:     org_iotivity_base_OcSecureResource
 711  * Method:    getIpAddr
 712  * Signature: ()Ljava/lang/String;
 713  */
 714 JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcSecureResource_getIpAddr
 715   (JNIEnv *env, jobject thiz)
 716 {
 717     LOGD("OcSecureResource_getIpAddr");
 718     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 719     if (!secureResource)
 720     {
 721         return nullptr;
 722     }
 723
 724     return env->NewStringUTF(secureResource->getIpAddr().c_str());
 725 }
 726
 727 /*
 728  * Class:     org_iotivity_base_OcSecureResource
 729  * Method:    getDeviceID
 730  * Signature: ()Ljava/lang/String;
 731  */
 732 JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcSecureResource_getDeviceID
 733   (JNIEnv *env , jobject thiz)
 734 {
 735     LOGD("OcSecureResource_getDeviceID");
 736     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 737     if (!secureResource)
 738     {
 739         return nullptr;
 740     }
 741
 742     return env->NewStringUTF(secureResource->getDeviceID().c_str());
 743 }
 744
 745 /*
 746  * Class:     org_iotivity_base_OcSecureResource
 747  * Method:    deviceStatus
 748  * Signature: ()I
 749  */
 750 JNIEXPORT jint JNICALL Java_org_iotivity_base_OcSecureResource_deviceStatus
 751   (JNIEnv *env, jobject thiz)
 752 {
 753     LOGD("OcSecureResource_deviceStatus");
 754     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 755     if (!secureResource)
 756     {
 757         return -1;
 758     }
 759
 760     return secureResource->getDeviceStatus();
 761 }
 762
 763 /*
 764  * Class:     org_iotivity_base_OcSecureResource
 765  * Method:    ownedStatus
 766  * Signature: ()I
 767  */
 768 JNIEXPORT jint JNICALL Java_org_iotivity_base_OcSecureResource_ownedStatus
 769   (JNIEnv *env, jobject thiz)
 770 {
 771     LOGD("OcSecureResource_ownedStatus");
 772     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 773     if (!secureResource)
 774     {
 775         return -1;
 776     }
 777
 778     return secureResource->getOwnedStatus();
 779 }
 780
 781 /*
 782  * Class:     org_iotivity_base_OcSecureResource
 783  * Method:    dispose
 784  * Signature: ()V
 785  */
 786 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_dispose
 787   (JNIEnv *env, jobject thiz)
 788 {
 789     LOGD("OcSecureResource_dispose");
 790     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 791     delete secureResource;
 792 }