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