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, "provisionResultListener cannot be null");
365 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
373 OCStackResult result = secureResource->removeDevice(env, timeout, jListener);
374 if (OC_STACK_OK != result)
376 ThrowOcException(result, "OcSecureResource_removeDevice");
380 catch (OCException& e)
382 LOGE("%s", e.reason().c_str());
383 ThrowOcException(e.code(), e.reason().c_str());
388 * Class: org_iotivity_base_OcSecureResource
389 * Method: unlinkDevices
390 * Signature: (Lorg/iotivity/base/OcSecureResource/unlinkDevices;)V
392 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_unlinkDevices
393 (JNIEnv *env, jobject thiz, jobject device2, jobject jListener)
395 LOGD("OcSecureResource_unlinkDevices");
396 if (!jListener || !device2)
398 ThrowOcException(OC_STACK_INVALID_PARAM, "provisionResultListener or device2 cannot be null");
402 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
410 OCStackResult result = secureResource->unlinkDevices(env, device2, jListener);
411 if (OC_STACK_OK != result)
413 ThrowOcException(result, "OcSecureResource_unlinkDevices");
417 catch (OCException& e)
419 LOGE("%s", e.reason().c_str());
420 ThrowOcException(e.code(), e.reason().c_str());
425 * Class: org_iotivity_base_OcSecureResource
426 * Method: provisionCredentials1
427 * Signature: (Lorg/iotivity/base/OcSecureResource/provisionCredentials;)V
429 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionCredentials1
430 (JNIEnv *env, jobject thiz, jint type, jint keySize, jobject device2, jobject jListener)
432 LOGD("OcSecureResource_provisionCredentials");
433 if (!jListener || !device2)
435 ThrowOcException(OC_STACK_INVALID_PARAM, "provisionResultListener or device2 cannot be null");
439 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
447 OCStackResult result = secureResource->provisionCredentials(env, type, keySize, device2,
449 if (OC_STACK_OK != result)
451 ThrowOcException(result, "OcSecureResource_provisionCredentials");
455 catch (OCException& e)
457 LOGE("%s", e.reason().c_str());
458 ThrowOcException(e.code(), e.reason().c_str());
463 * Class: org_iotivity_base_OcSecureResource
464 * Method: provisionACL
465 * Signature: (Lorg/iotivity/base/OcSecureResource/provisionACL;)V
467 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionACL
468 (JNIEnv *env, jobject thiz, jobject acl, jobject jListener)
470 LOGD("OcSecureResource_provisionACL");
471 if (!jListener || !acl)
473 ThrowOcException(OC_STACK_INVALID_PARAM, "provisionResultListener or acl cannot be null");
477 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
485 OCStackResult result = secureResource->provisionACL(env, acl, jListener);
486 if (OC_STACK_OK != result)
488 ThrowOcException(result, "OcSecureResource_provisionACL");
492 catch (OCException& e)
494 LOGE("%s", e.reason().c_str());
495 ThrowOcException(e.code(), e.reason().c_str());
500 * Class: org_iotivity_base_OcSecureResource
501 * Method: provisionPairwiseDevices1
502 * Signature: (Lorg/iotivity/base/OcSecureResource/provisionPairwiseDevices;)V
504 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionPairwiseDevices1
505 (JNIEnv *env, jobject thiz, jint type, jint keySize, jobject acl1, jobject device2,
506 jobject acl2, jobject jListener)
508 LOGD("OcSecureResource_provisionPairwiseDevices");
509 if (!jListener || !device2)
511 ThrowOcException(OC_STACK_INVALID_PARAM, "Invalid Parameters");
515 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
523 OCStackResult result = secureResource->provisionPairwiseDevices(env, type, keySize,
524 acl1, device2, acl2, jListener);
525 if (OC_STACK_OK != result)
527 ThrowOcException(result, "OcSecureResource_provisionPairwiseDevices");
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: getLinkedDevices
541 * Signature: ()Ljava/util/List;
543 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcSecureResource_getLinkedDevices
544 (JNIEnv *env, jobject thiz)
546 LOGD("OcSecureResource_getLinkedDevices");
549 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
557 OCStackResult result = secureResource->getLinkedDevices(env, uuidList);
558 if (OC_STACK_OK != result)
560 ThrowOcException(result, "OcSecureResource_getLinkedDevices");
563 return JniSecureUtils::convertUUIDVectorToJavaStrList(env, uuidList);
565 catch (OCException& e)
567 LOGE("%s", e.reason().c_str());
568 ThrowOcException(e.code(), e.reason().c_str());
574 * Class: org_iotivity_base_OcSecureResource
576 * Signature: ()Ljava/lang/String;
578 JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcSecureResource_getIpAddr
579 (JNIEnv *env, jobject thiz)
581 LOGD("OcSecureResource_getIpAddr");
582 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
588 return env->NewStringUTF(secureResource->getIpAddr().c_str());
592 * Class: org_iotivity_base_OcSecureResource
593 * Method: getDeviceID
594 * Signature: ()Ljava/lang/String;
596 JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcSecureResource_getDeviceID
597 (JNIEnv *env , jobject thiz)
599 LOGD("OcSecureResource_getDeviceID");
600 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
606 return env->NewStringUTF(secureResource->getDeviceID().c_str());
610 * Class: org_iotivity_base_OcSecureResource
611 * Method: deviceStatus
614 JNIEXPORT jint JNICALL Java_org_iotivity_base_OcSecureResource_deviceStatus
615 (JNIEnv *env, jobject thiz)
617 LOGD("OcSecureResource_deviceStatus");
618 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
624 return secureResource->getDeviceStatus();
628 * Class: org_iotivity_base_OcSecureResource
629 * Method: ownedStatus
632 JNIEXPORT jint JNICALL Java_org_iotivity_base_OcSecureResource_ownedStatus
633 (JNIEnv *env, jobject thiz)
635 LOGD("OcSecureResource_ownedStatus");
636 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
642 return secureResource->getOwnedStatus();
646 * Class: org_iotivity_base_OcSecureResource
650 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_dispose
651 (JNIEnv *env, jobject thiz)
653 LOGD("OcSecureResource_dispose");
654 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
655 delete secureResource;