2 * //******************************************************************
4 * // Copyright 2015 Samsung Electronics All Rights Reserved.
6 * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
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
12 * // http://www.apache.org/licenses/LICENSE-2.0
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.
20 * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
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;
30 JniOcSecureResource::JniOcSecureResource(std::shared_ptr<OCSecureResource> device)
31 : m_sharedSecureResource(device)
34 JniOcSecureResource::~JniOcSecureResource()
36 LOGD("~JniOcSecureResource()");
37 m_sharedSecureResource = nullptr;
40 std::string JniOcSecureResource::getIpAddr()
42 return m_sharedSecureResource->getDevAddr();
45 std::string JniOcSecureResource::getDeviceID()
47 return m_sharedSecureResource->getDeviceID();
50 int JniOcSecureResource::getDeviceStatus()
52 return m_sharedSecureResource->getDeviceStatus();
55 bool JniOcSecureResource::getOwnedStatus()
57 return m_sharedSecureResource->getOwnedStatus();
60 OCSecureResource* JniOcSecureResource::getDevicePtr()
62 return m_sharedSecureResource.get();
65 JniOcSecureResource* JniOcSecureResource::getJniOcSecureResourcePtr(JNIEnv *env, jobject thiz)
67 JniOcSecureResource *secureResource = GetHandle<JniOcSecureResource>(env, thiz);
68 if (env->ExceptionCheck())
70 LOGE("Failed to get native handle from OcSecureResource");
74 ThrowOcException(JNI_NO_NATIVE_POINTER, "");
76 return secureResource;
79 JniProvisionResultListner* JniOcSecureResource::AddProvisionResultListener(JNIEnv* env,
82 JniProvisionResultListner *resultListener = NULL;
85 for (auto it = resultMap.begin(); it != resultMap.end(); ++it)
87 if (env->IsSameObject(jListener, it->first))
89 auto refPair = it->second;
90 resultListener = refPair.first;
93 resultMap.insert(*it);
94 LOGD("Provision resultListener: ref. count incremented");
100 resultListener = new JniProvisionResultListner(env, jListener,
101 RemoveCallback(std::bind(&JniOcSecureResource::RemoveProvisionResultListener,
102 this, PH::_1, PH::_2)));
103 jobject jgListener = env->NewGlobalRef(jListener);
105 resultMap.insert(std::pair < jobject, std::pair < JniProvisionResultListner*,
106 int >> (jgListener, std::pair<JniProvisionResultListner*, int>(resultListener, 1)));
107 LOGD("Provision resultListener: new listener");
109 resultMapLock.unlock();
110 return resultListener;
113 void JniOcSecureResource::RemoveProvisionResultListener(JNIEnv* env, jobject jListener)
115 resultMapLock.lock();
117 for (auto it = resultMap.begin(); it != resultMap.end(); ++it)
119 if (env->IsSameObject(jListener, it->first))
121 auto refPair = it->second;
122 if (refPair.second > 1)
125 it->second = refPair;
126 resultMap.insert(*it);
127 LOGI("Provision resultListener: ref. count decremented");
131 env->DeleteGlobalRef(it->first);
132 JniProvisionResultListner* listener = refPair.first;
135 LOGI("Provision resultListener removed");
140 resultMapLock.unlock();
143 OCStackResult JniOcSecureResource::doOwnershipTransfer(JNIEnv* env, jobject jListener)
145 JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
147 ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
149 resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::OWNERSHIPTRANSFER);
152 return m_sharedSecureResource->doOwnershipTransfer(resultCallback);
155 OCStackResult JniOcSecureResource::getLinkedDevices(JNIEnv *env, UuidList_t &uuidList)
157 return m_sharedSecureResource->getLinkedDevices(uuidList);
160 OCStackResult JniOcSecureResource::removeDevice(JNIEnv* env, jint timeout, jobject jListener)
162 JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
164 ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
166 resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::REMOVEDEVICE);
169 return m_sharedSecureResource->removeDevice((int)timeout, resultCallback);
172 OCStackResult JniOcSecureResource::unlinkDevices(JNIEnv* env, jobject _device2, jobject jListener)
174 JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
176 ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
178 resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::UNLINKDEVICES);
181 JniOcSecureResource *device2 = JniOcSecureResource::getJniOcSecureResourcePtr(env, _device2);
184 return OC_STACK_ERROR;
187 return m_sharedSecureResource->unlinkDevices(*device2->getDevicePtr(), resultCallback);
190 OCStackResult JniOcSecureResource::provisionCredentials(JNIEnv* env, jint type, jint keySize,
191 jobject _device2, jobject jListener)
193 JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
195 ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
197 resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::PROVISIONCREDENTIALS);
200 JniOcSecureResource *device2 = JniOcSecureResource::getJniOcSecureResourcePtr(env, _device2);
203 return OC_STACK_ERROR;
206 Credential cred((OicSecCredType_t)type, keySize);
208 return m_sharedSecureResource->provisionCredentials(cred, *device2->getDevicePtr(),
212 #if defined(__WITH_TLS__)
213 OCStackResult JniOcSecureResource::provisionTrustCertChain(JNIEnv* env, jint type, jint credId,
216 JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
218 ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
220 resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::PROVISIONTRUSTCERTCHAIN);
223 return m_sharedSecureResource->provisionTrustCertChain((OicSecCredType_t)type, credId,
228 OCStackResult JniOcSecureResource::provisionACL(JNIEnv* env, jobject _acl, jobject jListener)
231 JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
232 OicSecAcl_t *acl = (OicSecAcl_t*)OICCalloc(1, sizeof(OicSecAcl_t));
236 return OC_STACK_NO_MEMORY;
239 if (OC_STACK_OK != JniSecureUtils::convertJavaACLToOCAcl(env, _acl, acl))
242 return OC_STACK_ERROR;
245 ResultCallBack resultCallback = [acl, resultListener](PMResultList_t *result, int hasError)
248 resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::PROVISIONACL);
250 ret = m_sharedSecureResource->provisionACL(acl, resultCallback);
252 if (ret != OC_STACK_OK)
259 OCStackResult JniOcSecureResource::provisionDirectPairing(JNIEnv* env, jobjectArray jpdacls,
260 jobject jListener, std::string pin, std::vector<int> prms, int edp)
263 JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
265 jsize len = env->GetArrayLength(jpdacls);
267 OicSecPconf_t *pconf = nullptr;
268 OicSecPdAcl_t *head = nullptr;
270 for (jsize i = 0; i < len; ++i)
272 OicSecPdAcl_t *pdacl = new OicSecPdAcl_t;
275 return OC_STACK_NO_MEMORY;
278 memset(pdacl, 0, sizeof(OicSecPdAcl_t));
279 pdacl->next = nullptr;
281 jobject jpdacl = env->GetObjectArrayElement(jpdacls, i);
283 if (OC_STACK_OK != JniSecureUtils::convertJavaPdACLToOCAcl(env, jpdacl, pdacl))
286 return OC_STACK_ERROR;
293 pconf = new OicSecPconf_t;
294 memset(pconf, 0, sizeof(OicSecPconf_t));
296 pconf->prmLen = prms.size();
297 pconf->prm = new OicSecPrm_t[pconf->prmLen];
300 for (int i = 0 ; i < prms.size(); i++)
301 pconf->prm[i] = (OicSecPrm_t)prms[i];
303 memcpy(pconf->pin.val, pin.c_str(), DP_PIN_LENGTH);
304 pconf->pdacls = head;
306 ResultCallBack resultCallback = [head, resultListener, pconf, prms]
307 (PMResultList_t *result, int hasError)
309 OicSecPdAcl_t *tmp1, *tmp2;
320 resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::PROVISIONDIRECTPAIRING);
323 ret = m_sharedSecureResource->provisionDirectPairing(pconf, resultCallback);
325 if (ret != OC_STACK_OK)
327 OicSecPdAcl_t *tmp1, *tmp2;
342 OCStackResult JniOcSecureResource::provisionPairwiseDevices(JNIEnv* env, jint type, jint keySize,
343 jobject _acl1, jobject _device2, jobject _acl2, jobject jListener)
348 return OC_STACK_INVALID_CALLBACK;
350 JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
351 JniOcSecureResource *device2 = JniOcSecureResource::getJniOcSecureResourcePtr(env, _device2);
354 return OC_STACK_ERROR;
357 Credential cred((OicSecCredType_t)type, keySize);
359 OicSecAcl_t *acl1 = nullptr;
360 OicSecAcl_t *acl2 = nullptr;
364 acl1 = (OicSecAcl_t*)OICCalloc(1, sizeof(OicSecAcl_t));
367 return OC_STACK_NO_MEMORY;
370 if (OC_STACK_OK != JniSecureUtils::convertJavaACLToOCAcl(env, _acl1, acl1))
373 return OC_STACK_ERROR;
379 acl2 = (OicSecAcl_t*)OICCalloc(1, sizeof(OicSecAcl_t));
383 return OC_STACK_NO_MEMORY;
386 if (OC_STACK_OK != JniSecureUtils::convertJavaACLToOCAcl(env, _acl2, acl2))
389 return OC_STACK_ERROR;
393 ResultCallBack resultCallback = [acl1, acl2, resultListener](PMResultList_t *result,
398 resultListener->ProvisionResultCallback(result, hasError,
399 ListenerFunc::PROVISIONPAIRWISEDEVICES);
403 ret = m_sharedSecureResource->provisionPairwiseDevices(cred, acl1,
404 *device2->getDevicePtr(), acl2, resultCallback);
405 if (ret != OC_STACK_OK)
414 * Class: org_iotivity_base_OcSecureResource
415 * Method: doOwnershipTransfer
416 * Signature: (Lorg/iotivity/base/OcSecureResource/doOwnershipTransferListener;)V
418 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_doOwnershipTransfer
419 (JNIEnv *env, jobject thiz, jobject jListener)
421 LOGD("OcSecureResource_doOwnershipTransfer");
424 ThrowOcException(OC_STACK_INVALID_CALLBACK, "provisionResultListener cannot be null");
428 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
431 ThrowOcException(OC_STACK_ERROR, "getJniOcSecureResourcePtr failed");
437 OCStackResult result = secureResource->doOwnershipTransfer(env, jListener);
438 if (OC_STACK_OK != result)
440 ThrowOcException(result, "OcSecureResource_doOwnershipTransfer");
444 catch (OCException& e)
446 LOGE("%s", e.reason().c_str());
447 ThrowOcException(e.code(), e.reason().c_str());
452 * Class: org_iotivity_base_OcSecureResource
453 * Method: removeDevice
454 * Signature: (ILorg/iotivity/base/OcSecureResource/removeDevice;)V
456 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_removeDevice
457 (JNIEnv *env, jobject thiz, jint timeout, jobject jListener)
459 LOGD("OcSecureResource_removeDevice");
462 ThrowOcException(OC_STACK_INVALID_PARAM, "Timeout value cannot be negative");
468 ThrowOcException(OC_STACK_INVALID_CALLBACK, "provisionResultListener cannot be null");
472 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
475 ThrowOcException(OC_STACK_ERROR, "getJniOcSecureResourcePtr failed");
481 OCStackResult result = secureResource->removeDevice(env, timeout, jListener);
482 if (OC_STACK_OK != result)
484 ThrowOcException(result, "OcSecureResource_removeDevice");
488 catch (OCException& e)
490 LOGE("%s", e.reason().c_str());
491 ThrowOcException(e.code(), e.reason().c_str());
496 * Class: org_iotivity_base_OcSecureResource
497 * Method: unlinkDevices
498 * Signature: (Lorg/iotivity/base/OcSecureResource/unlinkDevices;)V
500 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_unlinkDevices
501 (JNIEnv *env, jobject thiz, jobject device2, jobject jListener)
503 LOGD("OcSecureResource_unlinkDevices");
506 ThrowOcException(OC_STACK_INVALID_CALLBACK, "provisionResultListener cannot be null");
511 ThrowOcException(OC_STACK_INVALID_PARAM, "device2 cannot be null");
515 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
518 ThrowOcException(OC_STACK_ERROR, "getJniOcSecureResourcePtr failed");
524 OCStackResult result = secureResource->unlinkDevices(env, device2, jListener);
525 if (OC_STACK_OK != result)
527 ThrowOcException(result, "OcSecureResource_unlinkDevices");
531 catch (OCException& e)
533 LOGE("%s", e.reason().c_str());
534 ThrowOcException(e.code(), e.reason().c_str());
539 * Class: org_iotivity_base_OcSecureResource
540 * Method: provisionCredentials1
541 * Signature: (Lorg/iotivity/base/OcSecureResource/provisionCredentials;)V
543 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionCredentials1
544 (JNIEnv *env, jobject thiz, jint type, jint keySize, jobject device2, jobject jListener)
546 LOGD("OcSecureResource_provisionCredentials");
549 ThrowOcException(OC_STACK_INVALID_CALLBACK, "provisionResultListener cannot be null");
554 ThrowOcException(OC_STACK_INVALID_PARAM, "device2 cannot be null");
558 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
561 ThrowOcException(OC_STACK_ERROR, "getJniOcSecureResourcePtr failed");
567 OCStackResult result = secureResource->provisionCredentials(env, type, keySize, device2,
569 if (OC_STACK_OK != result)
571 ThrowOcException(result, "OcSecureResource_provisionCredentials");
575 catch (OCException& e)
577 LOGE("%s", e.reason().c_str());
578 ThrowOcException(e.code(), e.reason().c_str());
583 * Class: org_iotivity_base_OcSecureResource
584 * Method: provisionTrustCertChain1
585 * Signature: (Lorg/iotivity/base/OcSecureResource/provisionTrustCertChain1;)V
587 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionTrustCertChain1
588 (JNIEnv *env, jobject thiz, jint type, jint credId, jobject jListener)
590 LOGD("OcSecureResource_provisionTrustCertChain1");
591 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
594 ThrowOcException(OC_STACK_INVALID_CALLBACK, "provisionTrustCertChainListener cannot be null");
598 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
606 OCStackResult result = secureResource->provisionTrustCertChain(env, type, credId,
608 if (OC_STACK_OK != result)
610 ThrowOcException(result, "OcSecureResource_provisionTrustCertChain1");
614 catch (OCException& e)
616 LOGE("%s", e.reason().c_str());
617 ThrowOcException(e.code(), e.reason().c_str());
620 ThrowOcException(OC_STACK_INVALID_PARAM, "WITH_TLS not enabled");
622 #endif // __WITH_DTLS__ || __WITH_TLS__
626 * Class: org_iotivity_base_OcSecureResource
627 * Method: provisionACL
628 * Signature: (Lorg/iotivity/base/OcSecureResource/provisionACL;)V
630 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionACL
631 (JNIEnv *env, jobject thiz, jobject acl, jobject jListener)
633 LOGD("OcSecureResource_provisionACL");
636 ThrowOcException(OC_STACK_INVALID_CALLBACK, "provisionResultListener cannot be null");
641 ThrowOcException(OC_STACK_INVALID_PARAM, "acl cannot be null");
645 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
648 ThrowOcException(OC_STACK_ERROR, "getJniOcSecureResourcePtr failed");
654 OCStackResult result = secureResource->provisionACL(env, acl, jListener);
655 if (OC_STACK_OK != result)
657 ThrowOcException(result, "OcSecureResource_provisionACL");
661 catch (OCException& e)
663 LOGE("%s", e.reason().c_str());
664 ThrowOcException(e.code(), e.reason().c_str());
669 * Class: org_iotivity_base_OcSecureResource
670 * Method: provisionPairwiseDevices1
671 * Signature: (Lorg/iotivity/base/OcSecureResource/provisionPairwiseDevices;)V
673 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionPairwiseDevices1
674 (JNIEnv *env, jobject thiz, jint type, jint keySize, jobject acl1, jobject device2,
675 jobject acl2, jobject jListener)
677 LOGD("OcSecureResource_provisionPairwiseDevices");
680 ThrowOcException(OC_STACK_INVALID_CALLBACK, "Invalid Callback");
685 ThrowOcException(OC_STACK_INVALID_PARAM, "device2 cannot be null");
689 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
692 ThrowOcException(OC_STACK_ERROR, "getJniOcSecureResourcePtr failed");
698 OCStackResult result = secureResource->provisionPairwiseDevices(env, type, keySize,
699 acl1, device2, acl2, jListener);
700 if (OC_STACK_OK != result)
702 ThrowOcException(result, "OcSecureResource_provisionPairwiseDevices");
706 catch (OCException& e)
708 LOGE("%s", e.reason().c_str());
709 ThrowOcException(e.code(), e.reason().c_str());
714 * Class: org_iotivity_base_OcSecureResource
715 * Method: provisionDirectPairing
716 * Signature: (Ljava/lang/String;[Lorg/iotivity/base/OicSecPdAcl;ILorg/iotivity/base/OcSecureResource/ProvisionDirectPairingListener;I)V
718 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionDirectPairing
719 (JNIEnv *env, jobject thiz, jstring jpin, jobjectArray pdacls, jintArray jprmType,
720 jint jedp, jobject jListener)
722 LOGD("OcSecureResource_provisionDirectPairing");
725 ThrowOcException(OC_STACK_INVALID_CALLBACK, "Invalid Callback");
728 if (!pdacls || !jpin || ! jprmType)
730 ThrowOcException(OC_STACK_INVALID_PARAM, "Invalid Parameters");
733 std::string pin = env->GetStringUTFChars(jpin, nullptr);
735 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
738 ThrowOcException(OC_STACK_ERROR, "getJniOcSecureResourcePtr failed");
742 const jsize len = env->GetArrayLength(jprmType);
743 jint* ints = env->GetIntArrayElements(jprmType, nullptr);
744 std::vector<int> value;
745 for (jsize i = 0; i < len; ++i)
747 value.push_back(static_cast<int>(ints[i]));
749 env->ReleaseIntArrayElements(jprmType, ints, JNI_ABORT);
753 OCStackResult result = secureResource->provisionDirectPairing(env, pdacls, jListener,
754 pin, value, static_cast<int>(jedp));
755 if (OC_STACK_OK != result)
757 ThrowOcException(result, "OcSecureResource_provisionDirectPairing");
761 catch (OCException& e)
763 LOGE("%s", e.reason().c_str());
764 ThrowOcException(e.code(), e.reason().c_str());
769 * Class: org_iotivity_base_OcSecureResource
770 * Method: getLinkedDevices
771 * Signature: ()Ljava/util/List;
773 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcSecureResource_getLinkedDevices
774 (JNIEnv *env, jobject thiz)
776 LOGD("OcSecureResource_getLinkedDevices");
779 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
782 ThrowOcException(OC_STACK_ERROR, "getJniOcSecureResourcePtr failed");
788 OCStackResult result = secureResource->getLinkedDevices(env, uuidList);
789 if (OC_STACK_OK != result)
791 ThrowOcException(result, "OcSecureResource_getLinkedDevices");
794 return JniSecureUtils::convertUUIDVectorToJavaStrList(env, uuidList);
796 catch (OCException& e)
798 LOGE("%s", e.reason().c_str());
799 ThrowOcException(e.code(), e.reason().c_str());
805 * Class: org_iotivity_base_OcSecureResource
807 * Signature: ()Ljava/lang/String;
809 JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcSecureResource_getIpAddr
810 (JNIEnv *env, jobject thiz)
812 LOGD("OcSecureResource_getIpAddr");
813 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
816 LOGD("getJniOcSecureResourcePtr failed");
820 return env->NewStringUTF(secureResource->getIpAddr().c_str());
824 * Class: org_iotivity_base_OcSecureResource
825 * Method: getDeviceID
826 * Signature: ()Ljava/lang/String;
828 JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcSecureResource_getDeviceID
829 (JNIEnv *env , jobject thiz)
831 LOGD("OcSecureResource_getDeviceID");
832 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
835 LOGD("getJniOcSecureResourcePtr failed");
839 return env->NewStringUTF(secureResource->getDeviceID().c_str());
843 * Class: org_iotivity_base_OcSecureResource
844 * Method: deviceStatus
847 JNIEXPORT jint JNICALL Java_org_iotivity_base_OcSecureResource_deviceStatus
848 (JNIEnv *env, jobject thiz)
850 LOGD("OcSecureResource_deviceStatus");
851 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
854 LOGD("getJniOcSecureResourcePtr failed");
858 return secureResource->getDeviceStatus();
862 * Class: org_iotivity_base_OcSecureResource
863 * Method: ownedStatus
866 JNIEXPORT jint JNICALL Java_org_iotivity_base_OcSecureResource_ownedStatus
867 (JNIEnv *env, jobject thiz)
869 LOGD("OcSecureResource_ownedStatus");
870 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
873 LOGD("getJniOcSecureResourcePtr failed");
877 return secureResource->getOwnedStatus();
881 * Class: org_iotivity_base_OcSecureResource
885 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_dispose
886 (JNIEnv *env, jobject thiz)
888 LOGD("OcSecureResource_dispose");
889 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
890 delete secureResource;