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 namespace PH = std::placeholders;
27 JniOcSecureResource::JniOcSecureResource(std::shared_ptr<OCSecureResource> device)
28 : m_sharedSecureResource(device)
31 JniOcSecureResource::~JniOcSecureResource()
33 LOGD("~JniOcSecureResource()");
34 m_sharedSecureResource = nullptr;
37 std::string JniOcSecureResource::getIpAddr()
39 return m_sharedSecureResource->getDevAddr();
42 std::string JniOcSecureResource::getDeviceID()
44 return m_sharedSecureResource->getDeviceID();
47 int JniOcSecureResource::getDeviceStatus()
49 return m_sharedSecureResource->getDeviceStatus();
52 bool JniOcSecureResource::getOwnedStatus()
54 return m_sharedSecureResource->getOwnedStatus();
57 OCSecureResource* JniOcSecureResource::getDevicePtr()
59 return m_sharedSecureResource.get();
62 JniOcSecureResource* JniOcSecureResource::getJniOcSecureResourcePtr(JNIEnv *env, jobject thiz)
64 JniOcSecureResource *secureResource = GetHandle<JniOcSecureResource>(env, thiz);
65 if (env->ExceptionCheck())
67 LOGE("Failed to get native handle from OcSecureResource");
71 ThrowOcException(JNI_NO_NATIVE_POINTER, "");
73 return secureResource;
76 JniProvisionResultListner* JniOcSecureResource::AddProvisionResultListener(JNIEnv* env,
79 JniProvisionResultListner *resultListener = NULL;
82 for (auto it = resultMap.begin(); it != resultMap.end(); ++it)
84 if (env->IsSameObject(jListener, it->first))
86 auto refPair = it->second;
87 resultListener = refPair.first;
90 resultMap.insert(*it);
91 LOGD("Provision resultListener: ref. count incremented");
97 resultListener = new JniProvisionResultListner(env, jListener,
98 RemoveCallback(std::bind(&JniOcSecureResource::RemoveProvisionResultListener,
99 this, PH::_1, PH::_2)));
100 jobject jgListener = env->NewGlobalRef(jListener);
102 resultMap.insert(std::pair < jobject, std::pair < JniProvisionResultListner*,
103 int >> (jgListener, std::pair<JniProvisionResultListner*, int>(resultListener, 1)));
104 LOGD("Provision resultListener: new listener");
106 resultMapLock.unlock();
107 return resultListener;
110 void JniOcSecureResource::RemoveProvisionResultListener(JNIEnv* env, jobject jListener)
112 resultMapLock.lock();
114 for (auto it = resultMap.begin(); it != resultMap.end(); ++it)
116 if (env->IsSameObject(jListener, it->first))
118 auto refPair = it->second;
119 if (refPair.second > 1)
122 it->second = refPair;
123 resultMap.insert(*it);
124 LOGI("Provision resultListener: ref. count decremented");
128 env->DeleteGlobalRef(it->first);
129 JniProvisionResultListner* listener = refPair.first;
132 LOGI("Provision resultListener removed");
137 resultMapLock.unlock();
140 OCStackResult JniOcSecureResource::doOwnershipTransfer(JNIEnv* env, jobject jListener)
142 JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
144 ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
146 resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::OWNERSHIPTRANSFER);
149 return m_sharedSecureResource->doOwnershipTransfer(resultCallback);
152 OCStackResult JniOcSecureResource::getLinkedDevices(JNIEnv *env, UuidList_t &uuidList)
154 return m_sharedSecureResource->getLinkedDevices(uuidList);
157 OCStackResult JniOcSecureResource::removeDevice(JNIEnv* env, jint timeout, jobject jListener)
159 JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
161 ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
163 resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::REMOVEDEVICE);
166 return m_sharedSecureResource->removeDevice((int)timeout, resultCallback);
169 OCStackResult JniOcSecureResource::unlinkDevices(JNIEnv* env, jobject _device2, jobject jListener)
171 JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
173 ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
175 resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::UNLINKDEVICES);
178 JniOcSecureResource *device2 = JniOcSecureResource::getJniOcSecureResourcePtr(env, _device2);
181 return OC_STACK_ERROR;
184 return m_sharedSecureResource->unlinkDevices(*device2->getDevicePtr(), resultCallback);
187 OCStackResult JniOcSecureResource::provisionCredentials(JNIEnv* env, jint type, jint keySize,
188 jobject _device2, jobject jListener)
190 JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
192 ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
194 resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::PROVISIONCREDENTIALS);
197 JniOcSecureResource *device2 = JniOcSecureResource::getJniOcSecureResourcePtr(env, _device2);
200 return OC_STACK_ERROR;
203 Credential cred((OicSecCredType_t)type, keySize);
205 return m_sharedSecureResource->provisionCredentials(cred, *device2->getDevicePtr(),
209 OCStackResult JniOcSecureResource::provisionACL(JNIEnv* env, jobject _acl, jobject jListener)
212 JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
213 OicSecAcl_t *acl = new OicSecAcl_t;
217 return OC_STACK_NO_MEMORY;
222 if (OC_STACK_OK != JniSecureUtils::convertJavaACLToOCAcl(env, _acl, acl))
225 return OC_STACK_ERROR;
228 ResultCallBack resultCallback = [acl, resultListener](PMResultList_t *result, int hasError)
231 resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::PROVISIONACL);
233 ret = m_sharedSecureResource->provisionACL(acl, resultCallback);
235 if (ret != OC_STACK_OK)
243 OCStackResult JniOcSecureResource::provisionPairwiseDevices(JNIEnv* env, jint type, jint keySize,
244 jobject _acl1, jobject _device2, jobject _acl2, jobject jListener)
248 JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
249 JniOcSecureResource *device2 = JniOcSecureResource::getJniOcSecureResourcePtr(env, _device2);
252 return OC_STACK_ERROR;
255 Credential cred((OicSecCredType_t)type, keySize);
257 OicSecAcl_t *acl1 = nullptr;
258 OicSecAcl_t *acl2 = nullptr;
262 acl1 = new OicSecAcl_t;
265 return OC_STACK_NO_MEMORY;
268 if (OC_STACK_OK != JniSecureUtils::convertJavaACLToOCAcl(env, _acl1, acl1))
271 return OC_STACK_ERROR;
273 acl1->next = nullptr;
278 acl2 = new OicSecAcl_t;
282 return OC_STACK_NO_MEMORY;
285 if (OC_STACK_OK != JniSecureUtils::convertJavaACLToOCAcl(env, _acl2, acl2))
288 return OC_STACK_ERROR;
290 acl2->next = nullptr;
293 ResultCallBack resultCallback = [acl1, acl2, resultListener](PMResultList_t *result,
298 resultListener->ProvisionResultCallback(result, hasError,
299 ListenerFunc::PROVISIONPAIRWISEDEVICES);
303 ret = m_sharedSecureResource->provisionPairwiseDevices(cred, acl1,
304 *device2->getDevicePtr(), acl2, resultCallback);
305 if (ret != OC_STACK_OK)
314 * Class: org_iotivity_base_OcSecureResource
315 * Method: doOwnershipTransfer
316 * Signature: (Lorg/iotivity/base/OcSecureResource/doOwnershipTransferListener;)V
318 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_doOwnershipTransfer
319 (JNIEnv *env, jobject thiz, jobject jListener)
321 LOGD("OcSecureResource_doOwnershipTransfer");
324 ThrowOcException(OC_STACK_INVALID_PARAM, "provisionResultListener cannot be null");
328 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
336 OCStackResult result = secureResource->doOwnershipTransfer(env, jListener);
337 if (OC_STACK_OK != result)
339 ThrowOcException(result, "OcSecureResource_doOwnershipTransfer");
343 catch (OCException& e)
345 LOGE("%s", e.reason().c_str());
346 ThrowOcException(e.code(), e.reason().c_str());
351 * Class: org_iotivity_base_OcSecureResource
352 * Method: removeDevice
353 * Signature: (ILorg/iotivity/base/OcSecureResource/removeDevice;)V
355 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_removeDevice
356 (JNIEnv *env, jobject thiz, jint timeout, jobject jListener)
358 LOGD("OcSecureResource_removeDevice");
361 ThrowOcException(OC_STACK_INVALID_PARAM, "Timeout value cannot be negative");
367 ThrowOcException(OC_STACK_INVALID_PARAM, "provisionResultListener cannot be null");
371 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
379 OCStackResult result = secureResource->removeDevice(env, timeout, jListener);
380 if (OC_STACK_OK != result)
382 ThrowOcException(result, "OcSecureResource_removeDevice");
386 catch (OCException& e)
388 LOGE("%s", e.reason().c_str());
389 ThrowOcException(e.code(), e.reason().c_str());
394 * Class: org_iotivity_base_OcSecureResource
395 * Method: unlinkDevices
396 * Signature: (Lorg/iotivity/base/OcSecureResource/unlinkDevices;)V
398 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_unlinkDevices
399 (JNIEnv *env, jobject thiz, jobject device2, jobject jListener)
401 LOGD("OcSecureResource_unlinkDevices");
402 if (!jListener || !device2)
404 ThrowOcException(OC_STACK_INVALID_PARAM, "provisionResultListener or device2 cannot be null");
408 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
416 OCStackResult result = secureResource->unlinkDevices(env, device2, jListener);
417 if (OC_STACK_OK != result)
419 ThrowOcException(result, "OcSecureResource_unlinkDevices");
423 catch (OCException& e)
425 LOGE("%s", e.reason().c_str());
426 ThrowOcException(e.code(), e.reason().c_str());
431 * Class: org_iotivity_base_OcSecureResource
432 * Method: provisionCredentials1
433 * Signature: (Lorg/iotivity/base/OcSecureResource/provisionCredentials;)V
435 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionCredentials1
436 (JNIEnv *env, jobject thiz, jint type, jint keySize, jobject device2, jobject jListener)
438 LOGD("OcSecureResource_provisionCredentials");
439 if (!jListener || !device2)
441 ThrowOcException(OC_STACK_INVALID_PARAM, "provisionResultListener or device2 cannot be null");
445 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
453 OCStackResult result = secureResource->provisionCredentials(env, type, keySize, device2,
455 if (OC_STACK_OK != result)
457 ThrowOcException(result, "OcSecureResource_provisionCredentials");
461 catch (OCException& e)
463 LOGE("%s", e.reason().c_str());
464 ThrowOcException(e.code(), e.reason().c_str());
469 * Class: org_iotivity_base_OcSecureResource
470 * Method: provisionACL
471 * Signature: (Lorg/iotivity/base/OcSecureResource/provisionACL;)V
473 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionACL
474 (JNIEnv *env, jobject thiz, jobject acl, jobject jListener)
476 LOGD("OcSecureResource_provisionACL");
477 if (!jListener || !acl)
479 ThrowOcException(OC_STACK_INVALID_PARAM, "provisionResultListener or acl cannot be null");
483 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
491 OCStackResult result = secureResource->provisionACL(env, acl, jListener);
492 if (OC_STACK_OK != result)
494 ThrowOcException(result, "OcSecureResource_provisionACL");
498 catch (OCException& e)
500 LOGE("%s", e.reason().c_str());
501 ThrowOcException(e.code(), e.reason().c_str());
506 * Class: org_iotivity_base_OcSecureResource
507 * Method: provisionPairwiseDevices1
508 * Signature: (Lorg/iotivity/base/OcSecureResource/provisionPairwiseDevices;)V
510 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionPairwiseDevices1
511 (JNIEnv *env, jobject thiz, jint type, jint keySize, jobject acl1, jobject device2,
512 jobject acl2, jobject jListener)
514 LOGD("OcSecureResource_provisionPairwiseDevices");
515 if (!jListener || !device2)
517 ThrowOcException(OC_STACK_INVALID_PARAM, "Invalid Parameters");
521 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
529 OCStackResult result = secureResource->provisionPairwiseDevices(env, type, keySize,
530 acl1, device2, acl2, jListener);
531 if (OC_STACK_OK != result)
533 ThrowOcException(result, "OcSecureResource_provisionPairwiseDevices");
537 catch (OCException& e)
539 LOGE("%s", e.reason().c_str());
540 ThrowOcException(e.code(), e.reason().c_str());
545 * Class: org_iotivity_base_OcSecureResource
546 * Method: getLinkedDevices
547 * Signature: ()Ljava/util/List;
549 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcSecureResource_getLinkedDevices
550 (JNIEnv *env, jobject thiz)
552 LOGD("OcSecureResource_getLinkedDevices");
555 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
563 OCStackResult result = secureResource->getLinkedDevices(env, uuidList);
564 if (OC_STACK_OK != result)
566 ThrowOcException(result, "OcSecureResource_getLinkedDevices");
569 return JniSecureUtils::convertUUIDVectorToJavaStrList(env, uuidList);
571 catch (OCException& e)
573 LOGE("%s", e.reason().c_str());
574 ThrowOcException(e.code(), e.reason().c_str());
580 * Class: org_iotivity_base_OcSecureResource
582 * Signature: ()Ljava/lang/String;
584 JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcSecureResource_getIpAddr
585 (JNIEnv *env, jobject thiz)
587 LOGD("OcSecureResource_getIpAddr");
588 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
594 return env->NewStringUTF(secureResource->getIpAddr().c_str());
598 * Class: org_iotivity_base_OcSecureResource
599 * Method: getDeviceID
600 * Signature: ()Ljava/lang/String;
602 JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcSecureResource_getDeviceID
603 (JNIEnv *env , jobject thiz)
605 LOGD("OcSecureResource_getDeviceID");
606 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
612 return env->NewStringUTF(secureResource->getDeviceID().c_str());
616 * Class: org_iotivity_base_OcSecureResource
617 * Method: deviceStatus
620 JNIEXPORT jint JNICALL Java_org_iotivity_base_OcSecureResource_deviceStatus
621 (JNIEnv *env, jobject thiz)
623 LOGD("OcSecureResource_deviceStatus");
624 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
630 return secureResource->getDeviceStatus();
634 * Class: org_iotivity_base_OcSecureResource
635 * Method: ownedStatus
638 JNIEXPORT jint JNICALL Java_org_iotivity_base_OcSecureResource_ownedStatus
639 (JNIEnv *env, jobject thiz)
641 LOGD("OcSecureResource_ownedStatus");
642 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
648 return secureResource->getOwnedStatus();
652 * Class: org_iotivity_base_OcSecureResource
656 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_dispose
657 (JNIEnv *env, jobject thiz)
659 LOGD("OcSecureResource_dispose");
660 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
661 delete secureResource;