1 //******************************************************************
3 // Copyright 2015 Intel Corporation.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
7 // Licensed under the Apache License, Version 2.0 (the "License");
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
11 // http://www.apache.org/licenses/LICENSE-2.0
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an "AS IS" BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
21 #include "JniOcPlatform.h"
22 #include "OCPlatform.h"
23 #include "JniOcResource.h"
24 #include "JniOcResourceHandle.h"
25 #include "JniOcPresenceHandle.h"
26 #include "JniOcResourceResponse.h"
27 #include "JniOcSecurity.h"
28 #include "JniOcDirectPairDevice.h"
30 #include "ocpayload.h"
34 JniOnResourceFoundListener* AddOnResourceFoundListener(JNIEnv* env, jobject jListener)
36 JniOnResourceFoundListener *onResourceFoundListener = nullptr;
38 resourceFoundMapLock.lock();
40 for (auto it = onResourceFoundListenerMap.begin();
41 it != onResourceFoundListenerMap.end();
44 if (env->IsSameObject(jListener, it->first))
46 auto refPair = it->second;
47 onResourceFoundListener = refPair.first;
50 onResourceFoundListenerMap.insert(*it);
51 LOGD("OnResourceFoundListener: ref. count incremented");
56 if (!onResourceFoundListener)
58 onResourceFoundListener =
59 new JniOnResourceFoundListener(env, jListener, RemoveOnResourceFoundListener);
60 jobject jgListener = env->NewGlobalRef(jListener);
62 onResourceFoundListenerMap.insert(
64 std::pair<JniOnResourceFoundListener*, int >>(
66 std::pair<JniOnResourceFoundListener*, int>(onResourceFoundListener,
68 LOGD("OnResourceFoundListener: new listener");
70 resourceFoundMapLock.unlock();
71 return onResourceFoundListener;
74 void RemoveOnResourceFoundListener(JNIEnv* env, jobject jListener)
76 resourceFoundMapLock.lock();
78 for (auto it = onResourceFoundListenerMap.begin();
79 it != onResourceFoundListenerMap.end();
82 if (env->IsSameObject(jListener, it->first))
84 auto refPair = it->second;
85 if (refPair.second > 1)
89 onResourceFoundListenerMap.insert(*it);
90 LOGI("OnResourceFoundListener: ref. count decremented");
94 env->DeleteGlobalRef(it->first);
95 JniOnResourceFoundListener* listener = refPair.first;
97 onResourceFoundListenerMap.erase(it);
98 LOGI("OnResourceFoundListener removed");
103 resourceFoundMapLock.unlock();
106 JniOnDeviceInfoListener* AddOnDeviceInfoListener(JNIEnv* env, jobject jListener)
108 JniOnDeviceInfoListener *onDeviceInfoListener = nullptr;
110 deviceInfoMapLock.lock();
112 for (auto it = onDeviceInfoListenerMap.begin(); it != onDeviceInfoListenerMap.end(); ++it)
114 if (env->IsSameObject(jListener, it->first))
116 auto refPair = it->second;
117 onDeviceInfoListener = refPair.first;
119 it->second = refPair;
120 onDeviceInfoListenerMap.insert(*it);
121 LOGD("OnDeviceInfoListener: ref. count incremented");
126 if (!onDeviceInfoListener)
128 onDeviceInfoListener =
129 new JniOnDeviceInfoListener(env, jListener, RemoveOnDeviceInfoListener);
130 jobject jgListener = env->NewGlobalRef(jListener);
132 onDeviceInfoListenerMap.insert(
134 std::pair<JniOnDeviceInfoListener*, int>>(
136 std::pair<JniOnDeviceInfoListener*, int>(onDeviceInfoListener, 1)));
137 LOGI("OnDeviceInfoListener: new listener");
140 deviceInfoMapLock.unlock();
141 return onDeviceInfoListener;
144 void RemoveOnDeviceInfoListener(JNIEnv* env, jobject jListener)
146 deviceInfoMapLock.lock();
147 bool isFound = false;
148 for (auto it = onDeviceInfoListenerMap.begin(); it != onDeviceInfoListenerMap.end(); ++it)
150 if (env->IsSameObject(jListener, it->first))
152 auto refPair = it->second;
153 if (refPair.second > 1)
156 it->second = refPair;
157 onDeviceInfoListenerMap.insert(*it);
158 LOGI("OnDeviceInfoListener: ref. count decremented");
162 env->DeleteGlobalRef(it->first);
163 JniOnDeviceInfoListener* listener = refPair.first;
165 onDeviceInfoListenerMap.erase(it);
167 LOGI("OnDeviceInfoListener removed");
177 ThrowOcException(JNI_EXCEPTION, "OnDeviceInfoListenet not found");
179 deviceInfoMapLock.unlock();
182 JniOnPlatformInfoListener* AddOnPlatformInfoListener(JNIEnv* env, jobject jListener)
184 JniOnPlatformInfoListener *onPlatformInfoListener = nullptr;
186 platformInfoMapLock.lock();
188 for (auto it = onPlatformInfoListenerMap.begin(); it != onPlatformInfoListenerMap.end(); ++it)
190 if (env->IsSameObject(jListener, it->first))
192 auto refPair = it->second;
193 onPlatformInfoListener = refPair.first;
195 it->second = refPair;
196 onPlatformInfoListenerMap.insert(*it);
197 LOGD("OnPlatformInfoListener: ref. count incremented");
202 if (!onPlatformInfoListener)
204 onPlatformInfoListener =
205 new JniOnPlatformInfoListener(env, jListener, RemoveOnPlatformInfoListener);
206 jobject jgListener = env->NewGlobalRef(jListener);
208 onPlatformInfoListenerMap.insert(
209 std::pair<jobject, std::pair<JniOnPlatformInfoListener*, int>>(
211 std::pair<JniOnPlatformInfoListener*, int>(onPlatformInfoListener, 1)));
212 LOGI("OnPlatformInfoListener: new listener");
215 platformInfoMapLock.unlock();
216 return onPlatformInfoListener;
219 void RemoveOnPlatformInfoListener(JNIEnv* env, jobject jListener)
221 platformInfoMapLock.lock();
222 bool isFound = false;
223 for (auto it = onPlatformInfoListenerMap.begin(); it != onPlatformInfoListenerMap.end(); ++it)
225 if (env->IsSameObject(jListener, it->first))
227 auto refPair = it->second;
228 if (refPair.second > 1)
231 it->second = refPair;
232 onPlatformInfoListenerMap.insert(*it);
233 LOGI("OnPlatformInfoListener: ref. count decremented");
237 env->DeleteGlobalRef(it->first);
238 JniOnPlatformInfoListener* listener = refPair.first;
240 onPlatformInfoListenerMap.erase(it);
242 LOGI("OnPlatformInfoListener removed");
252 ThrowOcException(JNI_EXCEPTION, "OnPlatformInfoListenet not found");
254 platformInfoMapLock.unlock();
257 JniOnPresenceListener* AddOnPresenceListener(JNIEnv* env, jobject jListener)
259 JniOnPresenceListener *onPresenceListener = nullptr;
261 presenceMapLock.lock();
263 for (auto it = onPresenceListenerMap.begin(); it != onPresenceListenerMap.end(); ++it)
265 if (env->IsSameObject(jListener, it->first))
267 auto refPair = it->second;
268 onPresenceListener = refPair.first;
270 it->second = refPair;
271 onPresenceListenerMap.insert(*it);
272 LOGD("OnPresenceListener: ref. count incremented");
276 if (!onPresenceListener)
278 onPresenceListener = new JniOnPresenceListener(env, jListener, RemoveOnPresenceListener);
279 jobject jgListener = env->NewGlobalRef(jListener);
280 onPresenceListenerMap.insert(
281 std::pair<jobject, std::pair<JniOnPresenceListener*, int>>(
283 std::pair<JniOnPresenceListener*, int>(onPresenceListener, 1)));
284 LOGI("OnPresenceListener: new listener");
286 presenceMapLock.unlock();
287 return onPresenceListener;
290 void RemoveOnPresenceListener(JNIEnv* env, jobject jListener)
292 presenceMapLock.lock();
293 bool isFound = false;
294 for (auto it = onPresenceListenerMap.begin(); it != onPresenceListenerMap.end(); ++it)
296 if (env->IsSameObject(jListener, it->first))
298 auto refPair = it->second;
299 if (refPair.second > 1)
302 it->second = refPair;
303 onPresenceListenerMap.insert(*it);
304 LOGI("OnPresenceListener: ref. count decremented");
308 env->DeleteGlobalRef(it->first);
309 JniOnPresenceListener* listener = refPair.first;
311 onPresenceListenerMap.erase(it);
312 LOGI("OnPresenceListener is removed");
320 ThrowOcException(JNI_EXCEPTION, "OnPresenceListener not found");
322 presenceMapLock.unlock();
325 JniOnDPDevicesFoundListener* AddOnDPDevicesFoundListener(JNIEnv* env, jobject jListener)
327 JniOnDPDevicesFoundListener *onDPDeviceListener = nullptr;
329 dpDevicesFoundListenerMapLock.lock();
331 for (auto it = onDPDevicesFoundListenerMap.begin(); it !=
332 onDPDevicesFoundListenerMap.end(); ++it)
334 if (env->IsSameObject(jListener, it->first))
336 auto refPair = it->second;
337 onDPDeviceListener = refPair.first;
339 it->second = refPair;
340 onDPDevicesFoundListenerMap.insert(*it);
341 LOGD("onDPDeviceListener: ref. count incremented");
345 if (!onDPDeviceListener)
347 onDPDeviceListener = new JniOnDPDevicesFoundListener(env, jListener,
348 RemoveOnDPDevicesFoundListener);
349 jobject jgListener = env->NewGlobalRef(jListener);
350 onDPDevicesFoundListenerMap.insert(
351 std::pair<jobject, std::pair<JniOnDPDevicesFoundListener*, int>>(
353 std::pair<JniOnDPDevicesFoundListener*, int>(onDPDeviceListener, 1)));
354 LOGI("onDPDeviceListener: new listener");
356 dpDevicesFoundListenerMapLock.unlock();
357 return onDPDeviceListener;
360 void RemoveOnDPDevicesFoundListener(JNIEnv* env, jobject jListener)
362 dpDevicesFoundListenerMapLock.lock();
363 bool isFound = false;
364 for (auto it = onDPDevicesFoundListenerMap.begin(); it !=
365 onDPDevicesFoundListenerMap.end(); ++it)
367 if (env->IsSameObject(jListener, it->first))
369 auto refPair = it->second;
370 if (refPair.second > 1)
373 it->second = refPair;
374 onDPDevicesFoundListenerMap.insert(*it);
375 LOGI("onDPDeviceListener: ref. count decremented");
379 env->DeleteGlobalRef(it->first);
380 JniOnDPDevicesFoundListener* listener = refPair.first;
382 onDPDevicesFoundListenerMap.erase(it);
383 LOGI("onDPDeviceListener is removed");
391 ThrowOcException(JNI_EXCEPTION, "onDPDeviceListener not found");
393 dpDevicesFoundListenerMapLock.unlock();
396 JniOnDirectPairingListener* AddOnDirectPairingListener(JNIEnv* env, jobject jListener)
398 JniOnDirectPairingListener *onDirectPairingListener = nullptr;
400 directPairingListenerMapLock.lock();
402 for (auto it = directPairingListenerMap.begin(); it !=
403 directPairingListenerMap.end(); ++it)
405 if (env->IsSameObject(jListener, it->first))
407 auto refPair = it->second;
408 onDirectPairingListener = refPair.first;
410 it->second = refPair;
411 directPairingListenerMap.insert(*it);
412 LOGD("onDirectPairingListener: ref. count incremented");
416 if (!onDirectPairingListener)
418 onDirectPairingListener = new JniOnDirectPairingListener(env, jListener,
419 RemoveOnDirectPairingListener);
420 jobject jgListener = env->NewGlobalRef(jListener);
421 directPairingListenerMap.insert(
422 std::pair<jobject, std::pair<JniOnDirectPairingListener*, int>>(
424 std::pair<JniOnDirectPairingListener*, int>(onDirectPairingListener, 1)));
425 LOGI("onDirectPairingListener: new listener");
427 directPairingListenerMapLock.unlock();
428 return onDirectPairingListener;
431 void RemoveOnDirectPairingListener(JNIEnv* env, jobject jListener)
433 directPairingListenerMapLock.lock();
434 bool isFound = false;
435 for (auto it = directPairingListenerMap.begin(); it !=
436 directPairingListenerMap.end(); ++it)
438 if (env->IsSameObject(jListener, it->first))
440 auto refPair = it->second;
441 if (refPair.second > 1)
444 it->second = refPair;
445 directPairingListenerMap.insert(*it);
446 LOGI("onDirectPairingListener: ref. count decremented");
450 env->DeleteGlobalRef(it->first);
451 JniOnDirectPairingListener* listener = refPair.first;
453 directPairingListenerMap.erase(it);
454 LOGI("onDirectPairingListener is removed");
462 ThrowOcException(JNI_EXCEPTION, "onDirectPairingListener not found");
464 directPairingListenerMapLock.unlock();
468 * Class: org_iotivity_base_OcPlatform
470 * Signature: (IILjava/lang/String;II)V
472 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_configure
473 (JNIEnv *env, jclass clazz, jint jServiceType, jint jModeType, jstring jIpAddress, jint jPort,
474 jint jQOS, jstring jDbPath)
476 LOGI("OcPlatform_configure");
478 std::string ipAddress;
482 ipAddress = env->GetStringUTFChars(jIpAddress, nullptr);
486 dbfile = env->GetStringUTFChars(jDbPath, nullptr);
487 JniOcSecurity::StoreDbPath(dbfile);
492 port = static_cast<uint16_t>(jPort);
496 JniUtils::getServiceType(env, jServiceType),
497 JniUtils::getModeType(env, jModeType),
500 JniUtils::getQOS(env, static_cast<int>(jQOS)),
501 JniOcSecurity::getOCPersistentStorage()
503 OCPlatform::Configure(cfg);
507 * Class: org_iotivity_base_OcPlatform
508 * Method: notifyAllObservers0
509 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V
511 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyAllObservers0
512 (JNIEnv *env, jclass clazz, jobject jResourceHandle)
514 LOGI("OcPlatform_notifyAllObservers");
515 if (!jResourceHandle)
517 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
521 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
522 env, jResourceHandle);
523 if (!jniOcResourceHandle)
530 OCStackResult result =
531 OCPlatform::notifyAllObservers(jniOcResourceHandle->getOCResourceHandle());
533 if (OC_STACK_OK != result)
535 ThrowOcException(result, "Failed to notify all observers");
539 catch (OCException& e)
541 LOGE("%s", e.reason().c_str());
542 ThrowOcException(e.code(), e.reason().c_str());
547 * Class: org_iotivity_base_OcPlatform
548 * Method: notifyAllObservers1
549 * Signature: (Lorg/iotivity/base/OcResourceHandle;I)V
551 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyAllObservers1
552 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jint jQoS)
554 LOGI("OcPlatform_notifyAllObservers1");
556 if (!jResourceHandle)
558 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
562 JniOcResourceHandle* jniOcResourceHandle =
563 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
564 if (!jniOcResourceHandle)
570 OCStackResult result = OCPlatform::notifyAllObservers(
571 jniOcResourceHandle->getOCResourceHandle(),
572 JniUtils::getQOS(env, static_cast<int>(jQoS)));
574 if (OC_STACK_OK != result)
576 ThrowOcException(result, "Failed to notify all observers");
580 catch (OCException& e)
582 LOGE("%s", e.reason().c_str());
583 ThrowOcException(e.code(), e.reason().c_str());
588 * Class: org_iotivity_base_OcPlatform
589 * Method: notifyListOfObservers2
590 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Ljava/lang/Byte;Lorg/iotivity/base/OcResourceResponse;)V
592 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyListOfObservers2(
595 jobject jResourceHandle,
596 jbyteArray jObservationIdArr,
597 jobject jResourceResponse)
599 LOGD("OcPlatform_notifyListOfObservers2");
600 if (!jResourceHandle)
602 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
605 if (!jObservationIdArr)
607 ThrowOcException(OC_STACK_INVALID_PARAM, "observationIdList cannot be null");
610 if (!jResourceResponse)
612 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
616 JniOcResourceHandle* jniOcResourceHandle =
617 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
618 if (!jniOcResourceHandle)
623 JniOcResourceResponse* jniOcResourceResponse =
624 JniOcResourceResponse::getJniOcResourceResponsePtr(env, jResourceResponse);
625 if (!jniOcResourceResponse)
630 int len = env->GetArrayLength(jObservationIdArr);
631 uint8_t* bArr = (uint8_t*)env->GetByteArrayElements(jObservationIdArr, 0);
633 ObservationIds observationIds;
634 for (int i = 0; i < len; ++i)
636 observationIds.push_back(bArr[i]);
639 env->ReleaseByteArrayElements(jObservationIdArr, (jbyte*)bArr, 0);
643 OCStackResult result = OCPlatform::notifyListOfObservers(
644 jniOcResourceHandle->getOCResourceHandle(),
646 jniOcResourceResponse->getOCResourceResponse());
648 if (OC_STACK_OK != result)
650 ThrowOcException(result, "Failed to notify all observers");
653 catch (OCException& e)
655 LOGE("%s", e.reason().c_str());
656 ThrowOcException(e.code(), e.reason().c_str());
661 * Class: org_iotivity_base_OcPlatform
662 * Method: notifyListOfObservers3
663 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Ljava/lang/Byte;Lorg/iotivity/base/OcResourceResponse;I)V
665 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyListOfObservers3(
668 jobject jResourceHandle,
669 jbyteArray jObservationIdArr,
670 jobject jResourceResponse,
673 LOGD("OcPlatform_notifyListOfObservers3");
674 if (!jResourceHandle)
676 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
679 if (!jObservationIdArr)
681 ThrowOcException(OC_STACK_INVALID_PARAM, "observationIdList cannot be null");
684 if (!jResourceResponse)
686 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
690 JniOcResourceHandle* jniOcResourceHandle =
691 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
692 if (!jniOcResourceHandle)
697 JniOcResourceResponse* jniOcResourceResponse =
698 JniOcResourceResponse::getJniOcResourceResponsePtr(env, jResourceResponse);
699 if (!jniOcResourceResponse)
704 int len = env->GetArrayLength(jObservationIdArr);
705 uint8_t* bArr = (uint8_t*)env->GetByteArrayElements(jObservationIdArr, 0);
707 ObservationIds observationIds;
708 for (int i = 0; i < len; ++i)
710 observationIds.push_back(bArr[i]);
713 env->ReleaseByteArrayElements(jObservationIdArr, (jbyte*)bArr, 0);
717 OCStackResult result = OCPlatform::notifyListOfObservers(
718 jniOcResourceHandle->getOCResourceHandle(),
720 jniOcResourceResponse->getOCResourceResponse(),
721 JniUtils::getQOS(env, static_cast<int>(jQoS)));
723 if (OC_STACK_OK != result)
725 ThrowOcException(result, "Failed to notify all observers");
728 catch (OCException& e)
730 LOGE("%s", e.reason().c_str());
731 ThrowOcException(e.code(), e.reason().c_str());
736 * Class: org_iotivity_base_OcPlatform
737 * Method: findResource0
738 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnResourceFoundListener;)V
740 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findResource0(
744 jstring jResourceUri,
745 jint jConnectivityType,
748 LOGD("OcPlatform_findResource");
752 host = env->GetStringUTFChars(jHost, nullptr);
754 std::string resourceUri;
757 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
761 ThrowOcException(OC_STACK_INVALID_PARAM, "onResourceFoundListener cannot be null");
765 JniOnResourceFoundListener *onResFoundListener = AddOnResourceFoundListener(env, jListener);
767 FindCallback findCallback = [onResFoundListener](std::shared_ptr<OCResource> resource)
769 onResFoundListener->foundResourceCallback(resource);
772 FindErrorCallback findErrorCallback = [onResFoundListener](const std::string& uri, const int eCode)
774 onResFoundListener->findResourceErrorCallback(uri, eCode);
779 OCStackResult result = OCPlatform::findResource(
782 static_cast<OCConnectivityType>(jConnectivityType),
786 if (OC_STACK_OK != result)
788 ThrowOcException(result, "Find resource has failed");
792 catch (OCException& e)
794 LOGE("%s", e.reason().c_str());
795 ThrowOcException(e.code(), e.reason().c_str());
800 * Class: org_iotivity_base_OcPlatform
801 * Method: findResource1
802 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnResourceFoundListener;I)V
804 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findResource1(
808 jstring jResourceUri,
809 jint jConnectivityType,
813 LOGD("OcPlatform_findResource");
817 host = env->GetStringUTFChars(jHost, nullptr);
819 std::string resourceUri;
822 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
826 ThrowOcException(OC_STACK_INVALID_PARAM, "onResourceFoundListener cannot be null");
829 JniOnResourceFoundListener *onResFoundListener = AddOnResourceFoundListener(env, jListener);
831 FindCallback findCallback = [onResFoundListener](std::shared_ptr<OCResource> resource)
833 onResFoundListener->foundResourceCallback(resource);
836 FindErrorCallback findErrorCallback = [onResFoundListener](const std::string& uri, const int eCode)
838 onResFoundListener->findResourceErrorCallback(uri, eCode);
843 OCStackResult result = OCPlatform::findResource(
846 static_cast<OCConnectivityType>(jConnectivityType),
849 JniUtils::getQOS(env, static_cast<int>(jQoS)));
851 if (OC_STACK_OK != result)
853 ThrowOcException(result, "Find resource has failed");
857 catch (OCException& e)
859 LOGE("%s", e.reason().c_str());
860 ThrowOcException(e.code(), e.reason().c_str());
865 * Class: org_iotivity_base_OcPlatform
866 * Method: findDirectPairingDevices
867 * Signature: (ILorg/iotivity/base/OcPlatform/FindDirectPairingListener;)V
869 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findDirectPairingDevices
870 (JNIEnv * env, jclass clazz, jint jTimeout, jobject jListener)
872 LOGD("OcPlatform_findDirectPairingDevices");
876 ThrowOcException(OC_STACK_INVALID_PARAM, "onDPDevicesFoundListener cannot be null");
879 JniOnDPDevicesFoundListener *onDPDevsFoundListener = AddOnDPDevicesFoundListener(env,
882 GetDirectPairedCallback getDirectPairedCallback =
883 [onDPDevsFoundListener](PairedDevices pairingDevList)
885 onDPDevsFoundListener->directPairingDevicesCallback(pairingDevList,
886 DPFunc::FIND_DIRECT_PAIRED_DEV_LIST);
891 OCStackResult result = OCPlatform::findDirectPairingDevices(jTimeout,
892 getDirectPairedCallback);
893 if (OC_STACK_OK != result)
895 ThrowOcException(result, "OCPlatform::findDirectPairingDevices has failed");
899 catch (OCException& e)
901 LOGE("%s", e.reason().c_str());
902 ThrowOcException(e.code(), e.reason().c_str());
907 * Class: org_iotivity_base_OcPlatform
908 * Method: getDirectPairedDevices
909 * Signature: (Lorg/iotivity/base/OcDirectPairDevice/GetDirectPairedListener;)V
911 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDirectPairedDevices
912 (JNIEnv *env, jclass jclazz, jobject jListener)
914 LOGD("OcPlatform_getDirectPairedDevices");
918 ThrowOcException(OC_STACK_INVALID_PARAM, "getPairedDevList Callback cannot be null");
921 JniOnDPDevicesFoundListener *onGetPairedDevicesListener = AddOnDPDevicesFoundListener(env,
924 GetDirectPairedCallback getDirectPairedCallback =
925 [onGetPairedDevicesListener](PairedDevices pairedDevList)
927 onGetPairedDevicesListener->directPairingDevicesCallback(pairedDevList,
928 DPFunc::GET_PAIRED_DEV_LIST);
933 OCStackResult result = OCPlatform::getDirectPairedDevices(getDirectPairedCallback);
934 if (OC_STACK_OK != result)
936 ThrowOcException(result, "OcDirectPairDevice_getDirectPairedDevices");
940 catch (OCException& e)
942 LOGE("%s", e.reason().c_str());
943 ThrowOcException(e.code(), e.reason().c_str());
948 * Class: org_iotivity_base_OcPlatform
949 * Method: doDirectPairing
950 * Signature: (Lorg/iotivity/base/OcDirectPairDevice;Lorg/iotivity/base/OcPrmType;
951 * Ljava/lang/String;Lorg/iotivity/base/OcDirectPairDevice/DirectPairingListener;)V
953 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_doDirectPairing0
954 (JNIEnv *env, jclass clazz, jobject jpeer, jint jprmType, jstring jpin, jobject jListener)
956 LOGD("OcPlatform_doDirectPairing");
960 ThrowOcException(OC_STACK_INVALID_PARAM, "doDirectPairing Callback cannot be null");
965 ThrowOcException(OC_STACK_INVALID_PARAM, "Peer cannot be null");
969 JniOnDirectPairingListener *onDirectPairingListener = AddOnDirectPairingListener(env,
972 DirectPairingCallback DirectPairingCB =
973 [onDirectPairingListener](std::shared_ptr<OCDirectPairing> dpDev, OCStackResult result)
975 onDirectPairingListener->doDirectPairingCB(dpDev, result);
978 JniOcDirectPairDevice *dev = JniOcDirectPairDevice::getJniOcDirectPairDevicePtr(env, jpeer);
984 std::string pin = env->GetStringUTFChars(jpin, 0);
988 OCStackResult result = OCPlatform::doDirectPairing(dev->getPtr(), (OCPrm_t)jprmType,
989 pin, DirectPairingCB);
990 if (OC_STACK_OK != result)
992 ThrowOcException(result, "OcPlatform_oDirectPairing");
996 catch (OCException& e)
998 LOGE("%s", e.reason().c_str());
999 ThrowOcException(e.code(), e.reason().c_str());
1004 * Class: org_iotivity_base_OcPlatform
1005 * Method: getDeviceInfo0
1006 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeviceFoundListener;)V
1008 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDeviceInfo0(
1012 jstring jResourceUri,
1013 jint jConnectivityType,
1016 LOGD("OcPlatform_getDeviceInfo0");
1020 host = env->GetStringUTFChars(jHost, nullptr);
1022 std::string resourceUri;
1025 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1029 ThrowOcException(OC_STACK_INVALID_PARAM, "onDeviceFoundListener cannot be null");
1032 JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
1034 FindDeviceCallback findDeviceCallback =
1035 [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
1037 onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
1042 OCStackResult result = OCPlatform::getDeviceInfo(
1045 static_cast<OCConnectivityType>(jConnectivityType),
1046 findDeviceCallback);
1048 if (OC_STACK_OK != result)
1050 ThrowOcException(result, "Find device has failed");
1053 catch (OCException& e)
1055 LOGE("%s", e.reason().c_str());
1056 ThrowOcException(e.code(), e.reason().c_str());
1061 * Class: org_iotivity_base_OcPlatform
1062 * Method: getDeviceInfo1
1063 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeviceFoundListener;I)V
1065 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDeviceInfo1(
1069 jstring jResourceUri,
1070 jint jConnectivityType,
1074 LOGD("OcPlatform_getDeviceInfo1");
1078 host = env->GetStringUTFChars(jHost, nullptr);
1080 std::string resourceUri;
1083 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1087 ThrowOcException(OC_STACK_INVALID_PARAM, "onDeviceFoundListener cannot be null");
1090 JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
1092 FindDeviceCallback findDeviceCallback =
1093 [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
1095 onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
1100 OCStackResult result = OCPlatform::getDeviceInfo(
1103 static_cast<OCConnectivityType>(jConnectivityType),
1105 JniUtils::getQOS(env, static_cast<int>(jQoS)));
1107 if (OC_STACK_OK != result)
1109 ThrowOcException(result, "Find device has failed");
1112 catch (OCException& e)
1114 LOGE("%s", e.reason().c_str());
1115 ThrowOcException(e.code(), e.reason().c_str());
1120 * Class: org_iotivity_base_OcPlatform
1121 * Method: getPlatformInfo0
1122 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPlatformFoundListener;)V
1124 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getPlatformInfo0(
1128 jstring jResourceUri,
1129 jint jConnectivityType,
1132 LOGD("OcPlatform_getPlatformInfo0");
1136 host = env->GetStringUTFChars(jHost, nullptr);
1138 std::string resourceUri;
1141 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1145 ThrowOcException(OC_STACK_INVALID_PARAM, "onPlatformFoundListener cannot be null");
1148 JniOnPlatformInfoListener *onPlatformInfoListener = AddOnPlatformInfoListener(env, jListener);
1150 FindPlatformCallback findPlatformCallback =
1151 [onPlatformInfoListener](const OCRepresentation& ocRepresentation)
1153 onPlatformInfoListener->foundPlatformCallback(ocRepresentation);
1158 OCStackResult result = OCPlatform::getPlatformInfo(
1161 static_cast<OCConnectivityType>(jConnectivityType),
1162 findPlatformCallback);
1164 if (OC_STACK_OK != result)
1166 ThrowOcException(result, "Find platform has failed");
1169 catch (OCException& e)
1171 LOGE("%s", e.reason().c_str());
1172 ThrowOcException(e.code(), e.reason().c_str());
1177 * Class: org_iotivity_base_OcPlatform
1178 * Method: getPlatformInfo1
1179 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPlatformFoundListener;I)V
1181 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getPlatformInfo1(
1185 jstring jResourceUri,
1186 jint jConnectivityType,
1190 LOGD("OcPlatform_getPlatformInfo1");
1194 host = env->GetStringUTFChars(jHost, nullptr);
1196 std::string resourceUri;
1199 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1203 ThrowOcException(OC_STACK_INVALID_PARAM, "onPlatformFoundListener cannot be null");
1206 JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
1208 FindDeviceCallback findDeviceCallback =
1209 [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
1211 onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
1216 OCStackResult result = OCPlatform::getPlatformInfo(
1219 static_cast<OCConnectivityType>(jConnectivityType),
1221 JniUtils::getQOS(env, static_cast<int>(jQoS)));
1223 if (OC_STACK_OK != result)
1225 ThrowOcException(result, "Find platform has failed");
1228 catch (OCException& e)
1230 LOGE("%s", e.reason().c_str());
1231 ThrowOcException(e.code(), e.reason().c_str());
1236 * Class: org_iotivity_base_OcPlatform
1237 * Method: registerResource0
1238 * Signature: (Lorg/iotivity/base/OcResource;)Lorg/iotivity/base/OcResourceHandle;
1240 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_registerResource0(
1241 JNIEnv *env, jclass clazz, jobject jResource)
1243 LOGD("OcPlatform_registerResource");
1246 ThrowOcException(OC_STACK_INVALID_PARAM, "Resource cannot be null");
1249 JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, jResource);
1255 OCResourceHandle resourceHandle;
1258 OCStackResult result = OCPlatform::registerResource(
1260 resource->getOCResource());
1262 if (OC_STACK_OK != result)
1264 ThrowOcException(result, "register resource");
1267 catch (OCException& e)
1269 LOGE("%s", e.reason().c_str());
1270 ThrowOcException(e.code(), e.reason().c_str());
1273 JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);
1274 jlong handle = reinterpret_cast<jlong>(jniHandle);
1275 jobject jResourceHandle =
1276 env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);
1278 if (!jResourceHandle)
1280 LOGE("Failed to create OcResourceHandle");
1283 return jResourceHandle;
1287 * Class: org_iotivity_base_OcPlatform
1288 * Method: registerResource1
1289 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcPlatform/EntityHandler;I)Lorg/iotivity/base/OcResourceHandle;
1291 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_registerResource1(
1294 jstring jResourceUri,
1295 jstring jResourceTypeName,
1296 jstring jResourceInterface,
1297 jobject jListener, jint jResourceProperty)
1299 LOGI("OcPlatform_registerResource1");
1300 std::string resourceUri;
1303 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1305 std::string resourceTypeName;
1306 if (jResourceTypeName)
1308 resourceTypeName = env->GetStringUTFChars(jResourceTypeName, nullptr);
1310 std::string resourceInterface;
1311 if (jResourceInterface)
1313 resourceInterface = env->GetStringUTFChars(jResourceInterface, nullptr);
1315 JniEntityHandler* entityHandler = NULL;
1316 EntityHandler handleEntityCallback = NULL;
1319 entityHandler = new JniEntityHandler(env, jListener);
1320 handleEntityCallback =
1321 [entityHandler](const std::shared_ptr<OCResourceRequest> request) -> OCEntityHandlerResult
1323 return entityHandler->handleEntity(request);
1327 OCResourceHandle resourceHandle;
1330 OCStackResult result = OCPlatform::registerResource(
1335 handleEntityCallback,
1336 static_cast<int>(jResourceProperty));
1338 if (OC_STACK_OK != result)
1340 delete entityHandler;
1341 ThrowOcException(result, "register resource");
1345 catch (OCException& e)
1347 LOGE("%s", e.reason().c_str());
1348 delete entityHandler;
1349 ThrowOcException(e.code(), e.reason().c_str());
1353 JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);
1354 jlong handle = reinterpret_cast<jlong>(jniHandle);
1355 jobject jResourceHandle =
1356 env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);
1357 if (!jResourceHandle)
1359 LOGE("Failed to create OcResourceHandle");
1363 return jResourceHandle;
1367 * Class: org_iotivity_base_OcPlatform
1368 * Method: registerDeviceInfo0
1369 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
1371 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_registerDeviceInfo0(
1374 jstring jDeviceName,
1375 jobjectArray jDeviceTypes)
1377 LOGI("OcPlatform_registerDeviceInfo");
1381 ThrowOcException(OC_STACK_INVALID_PARAM, "deviceName cannot be null");
1387 ThrowOcException(OC_STACK_INVALID_PARAM, "deviceTypes cannot be null");
1391 OCDeviceInfo deviceInfo;
1394 DuplicateString(&deviceInfo.deviceName, env->GetStringUTFChars(jDeviceName, nullptr));
1395 deviceInfo.types = NULL;
1397 jsize len = env->GetArrayLength(jDeviceTypes);
1398 for (jsize i = 0; i < len; ++i)
1400 jstring jStr = (jstring)env->GetObjectArrayElement(jDeviceTypes, i);
1403 delete deviceInfo.deviceName;
1404 ThrowOcException(OC_STACK_INVALID_PARAM, "device type cannot be null");
1408 OCResourcePayloadAddStringLL(&deviceInfo.types, env->GetStringUTFChars(jStr, nullptr));
1409 if (env->ExceptionCheck())
1411 delete deviceInfo.deviceName;
1415 env->DeleteLocalRef(jStr);
1418 catch (std::exception &e)
1420 ThrowOcException(JNI_EXCEPTION, "Failed to construct device info");
1426 OCStackResult result = OCPlatform::registerDeviceInfo(deviceInfo);
1428 delete deviceInfo.deviceName;
1430 if (OC_STACK_OK != result)
1432 ThrowOcException(result, "Failed to register device info");
1436 catch (OCException& e)
1438 LOGE("%s", e.reason().c_str());
1439 ThrowOcException(e.code(), e.reason().c_str());
1444 * Class: org_iotivity_base_OcPlatform
1445 * Method: registerPlatformInfo0
1446 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
1448 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_registerPlatformInfo0(
1451 jstring jPlatformID,
1452 jstring jManufacturerName,
1453 jstring jManufacturerUrl,
1454 jstring jModelNumber,
1455 jstring jDateOfManufacture,
1456 jstring jPlatformVersion,
1457 jstring jOperatingSystemVersion,
1458 jstring jHardwareVersion,
1459 jstring jFirmwareVersion,
1460 jstring jSupportUrl,
1461 jstring jSystemTime)
1463 LOGI("OcPlatform_registerPlatformInfo");
1466 std::string platformID;
1467 std::string manufacturerName;
1468 std::string manufacturerUrl;
1469 std::string modelNumber;
1470 std::string dateOfManufacture;
1471 std::string platformVersion;
1472 std::string operatingSystemVersion;
1473 std::string hardwareVersion;
1474 std::string firmwareVersion;
1475 std::string supportUrl;
1476 std::string systemTime;
1480 platformID = env->GetStringUTFChars(jPlatformID, nullptr);
1482 if (jManufacturerName)
1484 manufacturerName = env->GetStringUTFChars(jManufacturerName, nullptr);
1486 if (jManufacturerUrl)
1488 manufacturerUrl = env->GetStringUTFChars(jManufacturerUrl, nullptr);
1492 modelNumber = env->GetStringUTFChars(jModelNumber, nullptr);
1494 if (jDateOfManufacture)
1496 dateOfManufacture = env->GetStringUTFChars(jDateOfManufacture, nullptr);
1498 if (jPlatformVersion)
1500 platformVersion = env->GetStringUTFChars(jPlatformVersion, nullptr);
1502 if (jOperatingSystemVersion)
1504 operatingSystemVersion = env->GetStringUTFChars(jOperatingSystemVersion, nullptr);
1506 if (jHardwareVersion)
1508 hardwareVersion = env->GetStringUTFChars(jHardwareVersion, nullptr);
1510 if (jFirmwareVersion)
1512 firmwareVersion = env->GetStringUTFChars(jFirmwareVersion, nullptr);
1516 supportUrl = env->GetStringUTFChars(jSupportUrl, nullptr);
1520 systemTime = env->GetStringUTFChars(jSystemTime, nullptr);
1523 OCPlatformInfo platformInfo;
1526 DuplicateString(&platformInfo.platformID, platformID);
1527 DuplicateString(&platformInfo.manufacturerName, manufacturerName);
1528 DuplicateString(&platformInfo.manufacturerUrl, manufacturerUrl);
1529 DuplicateString(&platformInfo.modelNumber, modelNumber);
1530 DuplicateString(&platformInfo.dateOfManufacture, dateOfManufacture);
1531 DuplicateString(&platformInfo.platformVersion, platformVersion);
1532 DuplicateString(&platformInfo.operatingSystemVersion, operatingSystemVersion);
1533 DuplicateString(&platformInfo.hardwareVersion, hardwareVersion);
1534 DuplicateString(&platformInfo.firmwareVersion, firmwareVersion);
1535 DuplicateString(&platformInfo.supportUrl, supportUrl);
1536 DuplicateString(&platformInfo.systemTime, systemTime);
1538 catch (std::exception &e)
1540 ThrowOcException(JNI_EXCEPTION, "Failed to construct platform info");
1544 // __android_log_print(ANDROID_LOG_INFO, "Rahul", "platformID = %s", platformID);
1547 OCStackResult result = OCPlatform::registerPlatformInfo(platformInfo);
1549 delete platformInfo.platformID;
1550 delete platformInfo.manufacturerName;
1551 delete platformInfo.manufacturerUrl;
1552 delete platformInfo.modelNumber;
1553 delete platformInfo.dateOfManufacture;
1554 delete platformInfo.platformVersion;
1555 delete platformInfo.operatingSystemVersion;
1556 delete platformInfo.hardwareVersion;
1557 delete platformInfo.firmwareVersion;
1558 delete platformInfo.supportUrl;
1559 delete platformInfo.systemTime;
1561 if (OC_STACK_OK != result)
1563 ThrowOcException(result, "Failed to register platform info");
1567 catch (OCException& e)
1569 LOGE("Error is due to %s", e.reason().c_str());
1570 ThrowOcException(e.code(), e.reason().c_str());
1575 * Class: org_iotivity_base_OcPlatform
1576 * Method: unregisterResource0
1577 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V
1579 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unregisterResource0(
1580 JNIEnv *env, jclass clazz, jobject jResourceHandle)
1582 LOGI("OcPlatform_unregisterResource");
1583 if (!jResourceHandle)
1585 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1588 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1589 env, jResourceHandle);
1590 if (!jniOcResourceHandle)
1597 OCResourceHandle resHandle = jniOcResourceHandle->getOCResourceHandle();
1598 OCStackResult result = OCPlatform::unregisterResource(resHandle);
1599 if (OC_STACK_OK != result)
1601 ThrowOcException(result, "Failed to unregister resource");
1604 catch (OCException& e)
1606 LOGE("%s", e.reason().c_str());
1607 ThrowOcException(e.code(), e.reason().c_str());
1612 * Class: org_iotivity_base_OcPlatform
1613 * Method: bindResource0
1614 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
1616 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResource0
1617 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobject jResourceHandle)
1619 LOGI("OcPlatform_bindResource");
1620 if (!jResourceCollectionHandle)
1622 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1625 if (!jResourceHandle)
1627 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1630 JniOcResourceHandle* jniOcResourceCollectionHandle =
1631 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1632 if (!jniOcResourceCollectionHandle)
1637 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1638 env, jResourceHandle);
1639 if (!jniOcResourceHandle)
1646 OCStackResult result = OCPlatform::bindResource(
1647 jniOcResourceCollectionHandle->getOCResourceHandle(),
1648 jniOcResourceHandle->getOCResourceHandle()
1651 if (OC_STACK_OK != result)
1653 ThrowOcException(result, "Failed to bind resource");
1656 catch (OCException& e)
1658 LOGE("%s", e.reason().c_str());
1659 ThrowOcException(e.code(), e.reason().c_str());
1664 * Class: org_iotivity_base_OcPlatform
1665 * Method: bindResources0
1666 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
1668 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResources0(
1671 jobject jResourceCollectionHandle,
1672 jobjectArray jResourceHandleArray)
1674 LOGI("OcPlatform_bindResources");
1676 if (!jResourceCollectionHandle)
1678 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1681 if (!jResourceHandleArray)
1683 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
1687 JniOcResourceHandle* jniOcResourceCollectionHandle =
1688 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1689 if (!jniOcResourceCollectionHandle)
1694 std::vector<OCResourceHandle> resourceHandleList;
1695 int len = env->GetArrayLength(jResourceHandleArray);
1696 for (int i = 0; i < len; ++i)
1698 jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
1699 if (!jResourceHandle)
1701 ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
1705 JniOcResourceHandle* jniOcResourceHandle =
1706 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1707 if (!jniOcResourceHandle)
1712 resourceHandleList.push_back(
1713 jniOcResourceHandle->getOCResourceHandle());
1718 OCStackResult result = OCPlatform::bindResources(
1719 jniOcResourceCollectionHandle->getOCResourceHandle(),
1723 if (OC_STACK_OK != result)
1725 ThrowOcException(result, "Failed to bind resources");
1728 catch (OCException& e)
1730 LOGE("%s", e.reason().c_str());
1731 ThrowOcException(e.code(), e.reason().c_str());
1736 * Class: org_iotivity_base_OcPlatform
1737 * Method: unbindResource0
1738 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
1740 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResource0(
1743 jobject jResourceCollectionHandle,
1744 jobject jResourceHandle)
1746 LOGI("OcPlatform_unbindResource");
1747 if (!jResourceCollectionHandle)
1749 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1752 if (!jResourceHandle)
1754 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1758 JniOcResourceHandle* jniOcResourceCollectionHandle =
1759 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1760 if (!jniOcResourceCollectionHandle)
1765 JniOcResourceHandle* jniOcResourceHandle =
1766 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1767 if (!jniOcResourceHandle)
1774 OCStackResult result = OCPlatform::unbindResource(
1775 jniOcResourceCollectionHandle->getOCResourceHandle(),
1776 jniOcResourceHandle->getOCResourceHandle());
1778 if (OC_STACK_OK != result)
1780 ThrowOcException(result, "Failed to unbind resource");
1783 catch (OCException& e)
1785 LOGE("%s", e.reason().c_str());
1786 ThrowOcException(e.code(), e.reason().c_str());
1791 * Class: org_iotivity_base_OcPlatform
1792 * Method: unbindResources0
1793 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
1795 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResources0(
1798 jobject jResourceCollectionHandle,
1799 jobjectArray jResourceHandleArray)
1801 LOGI("OcPlatform_unbindResources");
1802 if (!jResourceCollectionHandle)
1804 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1807 if (!jResourceHandleArray)
1809 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
1813 JniOcResourceHandle* jniOcResourceCollectionHandle =
1814 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1815 if (!jniOcResourceCollectionHandle)
1820 std::vector<OCResourceHandle> resourceHandleList;
1821 int len = env->GetArrayLength(jResourceHandleArray);
1822 for (int i = 0; i < len; ++i)
1824 jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
1825 if (!jResourceHandle)
1827 ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
1831 JniOcResourceHandle* jniOcResourceHandle =
1832 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1833 if (!jniOcResourceHandle)
1838 resourceHandleList.push_back(
1839 jniOcResourceHandle->getOCResourceHandle());
1844 OCStackResult result = OCPlatform::unbindResources(
1845 jniOcResourceCollectionHandle->getOCResourceHandle(),
1849 if (OC_STACK_OK != result)
1851 ThrowOcException(result, "Failed to unbind resources");
1854 catch (OCException& e)
1856 LOGE("%s", e.reason().c_str());
1857 ThrowOcException(e.code(), e.reason().c_str());
1862 * Class: org_iotivity_base_OcPlatform
1863 * Method: bindTypeToResource0
1864 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
1866 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindTypeToResource0(
1869 jobject jResourceHandle,
1870 jstring jResourceTypeName)
1872 LOGI("OcPlatform_bindTypeToResource");
1873 if (!jResourceHandle)
1875 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1878 std::string typeName;
1879 if (jResourceTypeName)
1881 typeName = env->GetStringUTFChars(jResourceTypeName, nullptr);
1884 JniOcResourceHandle* jniOcResourceHandle =
1885 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1886 if (!jniOcResourceHandle)
1893 OCStackResult result = OCPlatform::bindTypeToResource(
1894 jniOcResourceHandle->getOCResourceHandle(),
1898 if (OC_STACK_OK != result)
1900 ThrowOcException(result, "Failed to bind type to resource");
1903 catch (OCException& e)
1905 LOGE("%s", e.reason().c_str());
1906 ThrowOcException(e.code(), e.reason().c_str());
1911 * Class: org_iotivity_base_OcPlatform
1912 * Method: bindInterfaceToResource0
1913 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
1915 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindInterfaceToResource0
1916 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jstring jResourceInterfaceName)
1918 LOGI("OcPlatform_bindInterfaceToResource");
1919 if (!jResourceHandle)
1921 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1924 std::string interfaceName;
1925 if (jResourceInterfaceName)
1927 interfaceName = env->GetStringUTFChars(jResourceInterfaceName, nullptr);
1930 JniOcResourceHandle* jniOcResourceHandle =
1931 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1932 if (!jniOcResourceHandle)
1939 OCStackResult result = OCPlatform::bindInterfaceToResource(
1940 jniOcResourceHandle->getOCResourceHandle(),
1944 if (OC_STACK_OK != result)
1946 ThrowOcException(result, "Failed to bind interface to resource");
1949 catch (OCException& e)
1951 LOGE("%s", e.reason().c_str());
1952 ThrowOcException(e.code(), e.reason().c_str());
1957 * Class: org_iotivity_base_OcPlatform
1958 * Method: startPresence0
1961 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_startPresence0(
1962 JNIEnv *env, jclass clazz, jint ttl)
1964 LOGI("OcPlatform_startPresence");
1968 OCStackResult result = OCPlatform::startPresence((unsigned int)ttl);
1970 if (OC_STACK_OK != result)
1972 ThrowOcException(result, "Failed to start presence");
1975 catch (OCException& e)
1977 LOGE("%s", e.reason().c_str());
1978 ThrowOcException(e.code(), e.reason().c_str());
1983 * Class: org_iotivity_base_OcPlatform
1984 * Method: stopPresence0
1987 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_stopPresence0(
1988 JNIEnv *env, jclass clazz)
1990 LOGI("OcPlatform_stopPresence");
1994 OCStackResult result = OCPlatform::stopPresence();
1996 if (OC_STACK_OK != result)
1998 ThrowOcException(result, "Failed to stop presence");
2001 catch (OCException& e)
2003 LOGE("%s", e.reason().c_str());
2004 ThrowOcException(e.code(), e.reason().c_str());
2009 * Class: org_iotivity_base_OcPlatform
2010 * Method: subscribePresence0
2011 * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
2013 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence0(
2017 jint jConnectivityType,
2020 LOGD("OcPlatform_subscribePresence");
2024 host = env->GetStringUTFChars(jHost, nullptr);
2028 ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
2032 JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
2034 SubscribeCallback subscribeCallback =
2035 [onPresenceListener](OCStackResult result,
2036 const unsigned int nonce,
2037 const std::string& hostAddress)
2039 onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
2042 OCPlatform::OCPresenceHandle presenceHandle;
2045 OCStackResult result = OCPlatform::subscribePresence(
2048 static_cast<OCConnectivityType>(jConnectivityType),
2051 if (OC_STACK_OK != result)
2053 ThrowOcException(result, "subscribe presence has failed");
2056 catch (OCException& e)
2058 LOGE("%s", e.reason().c_str());
2059 ThrowOcException(e.code(), e.reason().c_str());
2063 JniOcPresenceHandle* jniPresenceHandle =
2064 new JniOcPresenceHandle(onPresenceListener, presenceHandle);
2065 jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
2066 jobject jPresenceHandle =
2067 env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
2068 if (!jPresenceHandle)
2070 LOGE("Failed to create OcPresenceHandle");
2071 delete jniPresenceHandle;
2073 return jPresenceHandle;
2077 * Class: org_iotivity_base_OcPlatform
2078 * Method: subscribePresence1
2079 * Signature: (Ljava/lang/String;Ljava/lang/String;I
2080 Lorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
2082 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence1(
2086 jstring jResourceType,
2087 jint jConnectivityType,
2090 LOGD("OcPlatform_subscribePresence1");
2094 host = env->GetStringUTFChars(jHost, nullptr);
2096 std::string resourceType;
2099 resourceType = env->GetStringUTFChars(jResourceType, nullptr);
2103 ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
2107 JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
2109 SubscribeCallback subscribeCallback = [onPresenceListener](OCStackResult result,
2110 const unsigned int nonce, const std::string& hostAddress)
2112 onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
2115 OCPlatform::OCPresenceHandle presenceHandle;
2118 OCStackResult result = OCPlatform::subscribePresence(
2122 static_cast<OCConnectivityType>(jConnectivityType),
2125 if (OC_STACK_OK != result)
2127 ThrowOcException(result, "subscribe presence has failed");
2130 catch (OCException& e)
2132 LOGE("%s", e.reason().c_str());
2133 ThrowOcException(e.code(), e.reason().c_str());
2137 JniOcPresenceHandle* jniPresenceHandle =
2138 new JniOcPresenceHandle(onPresenceListener, presenceHandle);
2139 jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
2140 jobject jPresenceHandle =
2141 env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
2142 if (!jPresenceHandle)
2144 LOGE("Failed to create OcPresenceHandle");
2145 delete jniPresenceHandle;
2147 return jPresenceHandle;
2151 * Class: org_iotivity_base_OcPlatform
2152 * Method: unsubscribePresence0
2153 * Signature: (Lorg/iotivity/base/OcPresenceHandle;)V
2155 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unsubscribePresence0(
2156 JNIEnv *env, jclass clazz, jobject jPresenceHandle)
2158 LOGD("OcPlatform_unsubscribePresence");
2159 if (!jPresenceHandle)
2161 ThrowOcException(OC_STACK_INVALID_PARAM, "presenceHandle cannot be null");
2164 JniOcPresenceHandle* jniPresenceHandle =
2165 JniOcPresenceHandle::getJniOcPresenceHandlePtr(env, jPresenceHandle);
2166 if (!jniPresenceHandle)
2171 OCPresenceHandle presenceHandle = jniPresenceHandle->getOCPresenceHandle();
2175 OCStackResult result = OCPlatform::unsubscribePresence(presenceHandle);
2177 if (OC_STACK_OK != result)
2179 ThrowOcException(result, "unsubscribe presence has failed");
2182 jweak jwOnPresenceListener =
2183 jniPresenceHandle->getJniOnPresenceListener()->getJWListener();
2184 if (jwOnPresenceListener)
2186 RemoveOnPresenceListener(env, jwOnPresenceListener);
2189 catch (OCException& e)
2191 LOGE("%s", e.reason().c_str());
2192 ThrowOcException(e.code(), e.reason().c_str());
2197 * Class: org_iotivity_base_OcPlatform
2198 * Method: constructResourceObject0
2199 * Signature: (Ljava/lang/String;Ljava/lang/String;IZ[Ljava/lang/String;[Ljava/lang/String;)
2200 Lorg/iotivity/base/OcResource;
2202 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_constructResourceObject0(
2207 jint jConnectivityType,
2208 jboolean jIsObservable,
2209 jobjectArray jResourceTypeArray,
2210 jobjectArray jInterfaceArray)
2212 LOGD("OcPlatform_constructResourceObject");
2216 host = env->GetStringUTFChars(jHost, nullptr);
2221 uri = env->GetStringUTFChars(jUri, nullptr);
2223 if (!jResourceTypeArray)
2225 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceTypeList cannot be null");
2228 if (!jInterfaceArray)
2230 ThrowOcException(OC_STACK_INVALID_PARAM, "interfaceList cannot be null");
2234 std::vector<std::string> resourceTypes;
2235 JniUtils::convertJavaStrArrToStrVector(env, jResourceTypeArray, resourceTypes);
2237 std::vector<std::string> interfaces;
2238 JniUtils::convertJavaStrArrToStrVector(env, jInterfaceArray, interfaces);
2240 std::shared_ptr<OCResource> resource = OCPlatform::constructResourceObject(
2243 static_cast<OCConnectivityType>(jConnectivityType),
2244 static_cast<bool>(jIsObservable),
2250 ThrowOcException(OC_STACK_ERROR, "Failed to create OCResource");
2254 JniOcResource *jniOcResource = new JniOcResource(resource);
2255 jlong handle = reinterpret_cast<jlong>(jniOcResource);
2257 jobject jResource = env->NewObject(g_cls_OcResource, g_mid_OcResource_ctor);
2260 delete jniOcResource;
2263 SetHandle<JniOcResource>(env, jResource, jniOcResource);
2264 if (env->ExceptionCheck())
2266 delete jniOcResource;
2273 * Class: org_iotivity_base_OcPlatform
2274 * Method: sendResponse0
2275 * Signature: (Lorg/iotivity/base/OcResourceResponse;)V
2277 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_sendResponse0(
2278 JNIEnv *env, jclass clazz, jobject jResourceResponse)
2280 LOGD("OcPlatform_sendResponse");
2281 if (!jResourceResponse)
2283 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
2287 JniOcResourceResponse *jniResponse =
2288 JniOcResourceResponse::getJniOcResourceResponsePtr(env, jResourceResponse);
2296 OCStackResult result =
2297 OCPlatform::sendResponse(jniResponse->getOCResourceResponse());
2299 if (OC_STACK_OK != result)
2301 ThrowOcException(result, "failed to send response");
2304 catch (OCException& e)
2306 LOGE("%s", e.reason().c_str());
2307 ThrowOcException(e.code(), e.reason().c_str());