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"
33 #include "JniOcAccountManager.h"
38 JniOnResourceFoundListener* AddOnResourceFoundListener(JNIEnv* env, jobject jListener)
40 JniOnResourceFoundListener *onResourceFoundListener = nullptr;
42 resourceFoundMapLock.lock();
44 for (auto it = onResourceFoundListenerMap.begin();
45 it != onResourceFoundListenerMap.end();
48 if (env->IsSameObject(jListener, it->first))
50 auto refPair = it->second;
51 onResourceFoundListener = refPair.first;
54 onResourceFoundListenerMap.insert(*it);
55 LOGD("OnResourceFoundListener: ref. count incremented");
60 if (!onResourceFoundListener)
62 onResourceFoundListener =
63 new JniOnResourceFoundListener(env, jListener, RemoveOnResourceFoundListener);
64 jobject jgListener = env->NewGlobalRef(jListener);
66 onResourceFoundListenerMap.insert(
68 std::pair<JniOnResourceFoundListener*, int >>(
70 std::pair<JniOnResourceFoundListener*, int>(onResourceFoundListener,
72 LOGD("OnResourceFoundListener: new listener");
74 resourceFoundMapLock.unlock();
75 return onResourceFoundListener;
78 void RemoveOnResourceFoundListener(JNIEnv* env, jobject jListener)
80 resourceFoundMapLock.lock();
82 for (auto it = onResourceFoundListenerMap.begin();
83 it != onResourceFoundListenerMap.end();
86 if (env->IsSameObject(jListener, it->first))
88 auto refPair = it->second;
89 if (refPair.second > 1)
93 onResourceFoundListenerMap.insert(*it);
94 LOGI("OnResourceFoundListener: ref. count decremented");
98 env->DeleteGlobalRef(it->first);
99 JniOnResourceFoundListener* listener = refPair.first;
101 onResourceFoundListenerMap.erase(it);
102 LOGI("OnResourceFoundListener removed");
107 resourceFoundMapLock.unlock();
110 JniOnDeviceInfoListener* AddOnDeviceInfoListener(JNIEnv* env, jobject jListener)
112 JniOnDeviceInfoListener *onDeviceInfoListener = nullptr;
114 deviceInfoMapLock.lock();
116 for (auto it = onDeviceInfoListenerMap.begin(); it != onDeviceInfoListenerMap.end(); ++it)
118 if (env->IsSameObject(jListener, it->first))
120 auto refPair = it->second;
121 onDeviceInfoListener = refPair.first;
123 it->second = refPair;
124 onDeviceInfoListenerMap.insert(*it);
125 LOGD("OnDeviceInfoListener: ref. count incremented");
130 if (!onDeviceInfoListener)
132 onDeviceInfoListener =
133 new JniOnDeviceInfoListener(env, jListener, RemoveOnDeviceInfoListener);
134 jobject jgListener = env->NewGlobalRef(jListener);
136 onDeviceInfoListenerMap.insert(
138 std::pair<JniOnDeviceInfoListener*, int>>(
140 std::pair<JniOnDeviceInfoListener*, int>(onDeviceInfoListener, 1)));
141 LOGI("OnDeviceInfoListener: new listener");
144 deviceInfoMapLock.unlock();
145 return onDeviceInfoListener;
148 void RemoveOnDeviceInfoListener(JNIEnv* env, jobject jListener)
150 deviceInfoMapLock.lock();
151 bool isFound = false;
152 for (auto it = onDeviceInfoListenerMap.begin(); it != onDeviceInfoListenerMap.end(); ++it)
154 if (env->IsSameObject(jListener, it->first))
156 auto refPair = it->second;
157 if (refPair.second > 1)
160 it->second = refPair;
161 onDeviceInfoListenerMap.insert(*it);
162 LOGI("OnDeviceInfoListener: ref. count decremented");
166 env->DeleteGlobalRef(it->first);
167 JniOnDeviceInfoListener* listener = refPair.first;
169 onDeviceInfoListenerMap.erase(it);
171 LOGI("OnDeviceInfoListener removed");
181 ThrowOcException(JNI_EXCEPTION, "OnDeviceInfoListenet not found");
183 deviceInfoMapLock.unlock();
186 JniOnPlatformInfoListener* AddOnPlatformInfoListener(JNIEnv* env, jobject jListener)
188 JniOnPlatformInfoListener *onPlatformInfoListener = nullptr;
190 platformInfoMapLock.lock();
192 for (auto it = onPlatformInfoListenerMap.begin(); it != onPlatformInfoListenerMap.end(); ++it)
194 if (env->IsSameObject(jListener, it->first))
196 auto refPair = it->second;
197 onPlatformInfoListener = refPair.first;
199 it->second = refPair;
200 onPlatformInfoListenerMap.insert(*it);
201 LOGD("OnPlatformInfoListener: ref. count incremented");
206 if (!onPlatformInfoListener)
208 onPlatformInfoListener =
209 new JniOnPlatformInfoListener(env, jListener, RemoveOnPlatformInfoListener);
210 jobject jgListener = env->NewGlobalRef(jListener);
212 onPlatformInfoListenerMap.insert(
213 std::pair<jobject, std::pair<JniOnPlatformInfoListener*, int>>(
215 std::pair<JniOnPlatformInfoListener*, int>(onPlatformInfoListener, 1)));
216 LOGI("OnPlatformInfoListener: new listener");
219 platformInfoMapLock.unlock();
220 return onPlatformInfoListener;
223 void RemoveOnPlatformInfoListener(JNIEnv* env, jobject jListener)
225 platformInfoMapLock.lock();
226 bool isFound = false;
227 for (auto it = onPlatformInfoListenerMap.begin(); it != onPlatformInfoListenerMap.end(); ++it)
229 if (env->IsSameObject(jListener, it->first))
231 auto refPair = it->second;
232 if (refPair.second > 1)
235 it->second = refPair;
236 onPlatformInfoListenerMap.insert(*it);
237 LOGI("OnPlatformInfoListener: ref. count decremented");
241 env->DeleteGlobalRef(it->first);
242 JniOnPlatformInfoListener* listener = refPair.first;
244 onPlatformInfoListenerMap.erase(it);
246 LOGI("OnPlatformInfoListener removed");
256 ThrowOcException(JNI_EXCEPTION, "OnPlatformInfoListenet not found");
258 platformInfoMapLock.unlock();
261 JniOnPresenceListener* AddOnPresenceListener(JNIEnv* env, jobject jListener)
263 JniOnPresenceListener *onPresenceListener = nullptr;
265 presenceMapLock.lock();
267 for (auto it = onPresenceListenerMap.begin(); it != onPresenceListenerMap.end(); ++it)
269 if (env->IsSameObject(jListener, it->first))
271 auto refPair = it->second;
272 onPresenceListener = refPair.first;
274 it->second = refPair;
275 onPresenceListenerMap.insert(*it);
276 LOGD("OnPresenceListener: ref. count incremented");
280 if (!onPresenceListener)
282 onPresenceListener = new JniOnPresenceListener(env, jListener, RemoveOnPresenceListener);
283 jobject jgListener = env->NewGlobalRef(jListener);
284 onPresenceListenerMap.insert(
285 std::pair<jobject, std::pair<JniOnPresenceListener*, int>>(
287 std::pair<JniOnPresenceListener*, int>(onPresenceListener, 1)));
288 LOGI("OnPresenceListener: new listener");
290 presenceMapLock.unlock();
291 return onPresenceListener;
294 void RemoveOnPresenceListener(JNIEnv* env, jobject jListener)
296 presenceMapLock.lock();
297 bool isFound = false;
298 for (auto it = onPresenceListenerMap.begin(); it != onPresenceListenerMap.end(); ++it)
300 if (env->IsSameObject(jListener, it->first))
302 auto refPair = it->second;
303 if (refPair.second > 1)
306 it->second = refPair;
307 onPresenceListenerMap.insert(*it);
308 LOGI("OnPresenceListener: ref. count decremented");
312 env->DeleteGlobalRef(it->first);
313 JniOnPresenceListener* listener = refPair.first;
315 onPresenceListenerMap.erase(it);
316 LOGI("OnPresenceListener is removed");
324 ThrowOcException(JNI_EXCEPTION, "OnPresenceListener not found");
326 presenceMapLock.unlock();
329 JniOnObserveListener* AddOnObserveListener(JNIEnv* env, jobject jListener)
331 JniOnObserveListener *onObserveListener = nullptr;
333 observeMapLock.lock();
335 for (auto it = onObserveListenerMap.begin(); it != onObserveListenerMap.end(); ++it)
337 if (env->IsSameObject(jListener, it->first))
339 auto refPair = it->second;
340 onObserveListener = refPair.first;
342 it->second = refPair;
343 onObserveListenerMap.insert(*it);
344 LOGD("OnObserveListener: ref. count incremented");
348 if (!onObserveListener)
350 onObserveListener = new JniOnObserveListener(env, jListener, nullptr);
351 jobject jgListener = env->NewGlobalRef(jListener);
352 onObserveListenerMap.insert(
353 std::pair<jobject, std::pair<JniOnObserveListener*, int>>(
355 std::pair<JniOnObserveListener*, int>(onObserveListener, 1)));
356 LOGI("OnObserveListener: new listener");
358 observeMapLock.unlock();
359 return onObserveListener;
362 void RemoveOnObserveListener(JNIEnv* env, jobject jListener)
364 observeMapLock.lock();
365 bool isFound = false;
366 for (auto it = onObserveListenerMap.begin(); it != onObserveListenerMap.end(); ++it)
368 if (env->IsSameObject(jListener, it->first))
370 auto refPair = it->second;
371 if (refPair.second > 1)
374 it->second = refPair;
375 onObserveListenerMap.insert(*it);
376 LOGI("OnObserveListener: ref. count decremented");
380 env->DeleteGlobalRef(it->first);
381 JniOnObserveListener* listener = refPair.first;
383 onObserveListenerMap.erase(it);
384 LOGI("OnObserveListener is removed");
392 ThrowOcException(JNI_EXCEPTION, "OnObserveListener not found");
394 observeMapLock.unlock();
397 JniOnDPDevicesFoundListener* AddOnDPDevicesFoundListener(JNIEnv* env, jobject jListener)
399 JniOnDPDevicesFoundListener *onDPDeviceListener = nullptr;
401 dpDevicesFoundListenerMapLock.lock();
403 for (auto it = onDPDevicesFoundListenerMap.begin(); it !=
404 onDPDevicesFoundListenerMap.end(); ++it)
406 if (env->IsSameObject(jListener, it->first))
408 auto refPair = it->second;
409 onDPDeviceListener = refPair.first;
411 it->second = refPair;
412 onDPDevicesFoundListenerMap.insert(*it);
413 LOGD("onDPDeviceListener: ref. count incremented");
417 if (!onDPDeviceListener)
419 onDPDeviceListener = new JniOnDPDevicesFoundListener(env, jListener,
420 RemoveOnDPDevicesFoundListener);
421 jobject jgListener = env->NewGlobalRef(jListener);
422 onDPDevicesFoundListenerMap.insert(
423 std::pair<jobject, std::pair<JniOnDPDevicesFoundListener*, int>>(
425 std::pair<JniOnDPDevicesFoundListener*, int>(onDPDeviceListener, 1)));
426 LOGI("onDPDeviceListener: new listener");
428 dpDevicesFoundListenerMapLock.unlock();
429 return onDPDeviceListener;
432 void RemoveOnDPDevicesFoundListener(JNIEnv* env, jobject jListener)
434 dpDevicesFoundListenerMapLock.lock();
435 bool isFound = false;
436 for (auto it = onDPDevicesFoundListenerMap.begin(); it !=
437 onDPDevicesFoundListenerMap.end(); ++it)
439 if (env->IsSameObject(jListener, it->first))
441 auto refPair = it->second;
442 if (refPair.second > 1)
445 it->second = refPair;
446 onDPDevicesFoundListenerMap.insert(*it);
447 LOGI("onDPDeviceListener: ref. count decremented");
451 env->DeleteGlobalRef(it->first);
452 JniOnDPDevicesFoundListener* listener = refPair.first;
454 onDPDevicesFoundListenerMap.erase(it);
455 LOGI("onDPDeviceListener is removed");
463 ThrowOcException(JNI_EXCEPTION, "onDPDeviceListener not found");
465 dpDevicesFoundListenerMapLock.unlock();
468 JniOnDirectPairingListener* AddOnDirectPairingListener(JNIEnv* env, jobject jListener)
470 JniOnDirectPairingListener *onDirectPairingListener = nullptr;
472 directPairingListenerMapLock.lock();
474 for (auto it = directPairingListenerMap.begin(); it !=
475 directPairingListenerMap.end(); ++it)
477 if (env->IsSameObject(jListener, it->first))
479 auto refPair = it->second;
480 onDirectPairingListener = refPair.first;
482 it->second = refPair;
483 directPairingListenerMap.insert(*it);
484 LOGD("onDirectPairingListener: ref. count incremented");
488 if (!onDirectPairingListener)
490 onDirectPairingListener = new JniOnDirectPairingListener(env, jListener,
491 RemoveOnDirectPairingListener);
492 jobject jgListener = env->NewGlobalRef(jListener);
493 directPairingListenerMap.insert(
494 std::pair<jobject, std::pair<JniOnDirectPairingListener*, int>>(
496 std::pair<JniOnDirectPairingListener*, int>(onDirectPairingListener, 1)));
497 LOGI("onDirectPairingListener: new listener");
499 directPairingListenerMapLock.unlock();
500 return onDirectPairingListener;
503 void RemoveOnDirectPairingListener(JNIEnv* env, jobject jListener)
505 directPairingListenerMapLock.lock();
506 bool isFound = false;
507 for (auto it = directPairingListenerMap.begin(); it !=
508 directPairingListenerMap.end(); ++it)
510 if (env->IsSameObject(jListener, it->first))
512 auto refPair = it->second;
513 if (refPair.second > 1)
516 it->second = refPair;
517 directPairingListenerMap.insert(*it);
518 LOGI("onDirectPairingListener: ref. count decremented");
522 env->DeleteGlobalRef(it->first);
523 JniOnDirectPairingListener* listener = refPair.first;
525 directPairingListenerMap.erase(it);
526 LOGI("onDirectPairingListener is removed");
534 ThrowOcException(JNI_EXCEPTION, "onDirectPairingListener not found");
536 directPairingListenerMapLock.unlock();
539 JniOnPublishResourceListener* AddOnPublishResourceListener(JNIEnv* env, jobject jListener)
547 JniOnPublishResourceListener *onPublishResourceListener = nullptr;
549 publishResourceListenerMapLock.lock();
551 for (auto it = onPublishResourceListenerMap.begin(); it !=
552 onPublishResourceListenerMap.end(); ++it)
554 if (env->IsSameObject(jListener, it->first))
556 auto refPair = it->second;
557 onPublishResourceListener = refPair.first;
559 it->second = refPair;
560 onPublishResourceListenerMap.insert(*it);
561 LOGD("onPublishResourceListener: ref. count incremented");
565 if (!onPublishResourceListener)
567 onPublishResourceListener = new JniOnPublishResourceListener(env, jListener,
568 RemoveOnPublishResourceListener);
569 jobject jgListener = env->NewGlobalRef(jListener);
570 onPublishResourceListenerMap.insert(
571 std::pair<jobject, std::pair<JniOnPublishResourceListener*, int>>(
573 std::pair<JniOnPublishResourceListener*, int>(onPublishResourceListener, 1)));
574 LOGI("onPublishResourceListener: new listener");
576 publishResourceListenerMapLock.unlock();
577 return onPublishResourceListener;
580 void RemoveOnPublishResourceListener(JNIEnv* env, jobject jListener)
584 ThrowOcException(JNI_EXCEPTION, "env is null");
588 publishResourceListenerMapLock.lock();
589 bool isFound = false;
590 for (auto it = onPublishResourceListenerMap.begin(); it !=
591 onPublishResourceListenerMap.end(); ++it)
593 if (env->IsSameObject(jListener, it->first))
595 auto refPair = it->second;
596 if (refPair.second > 1)
599 it->second = refPair;
600 onPublishResourceListenerMap.insert(*it);
601 LOGI("onPublishResourceListener: ref. count decremented");
605 env->DeleteGlobalRef(it->first);
606 JniOnPublishResourceListener* listener = refPair.first;
608 onPublishResourceListenerMap.erase(it);
609 LOGI("onPublishResourceListener is removed");
617 ThrowOcException(JNI_EXCEPTION, "onPublishResourceListener not found");
619 publishResourceListenerMapLock.unlock();
622 JniOnDeleteResourceListener* AddOnDeleteResourceListener(JNIEnv* env, jobject jListener)
630 JniOnDeleteResourceListener *onDeleteResourceListener = nullptr;
632 deleteResourceListenerMapLock.lock();
634 for (auto it = onDeleteResourceListenerMap.begin(); it !=
635 onDeleteResourceListenerMap.end(); ++it)
637 if (env->IsSameObject(jListener, it->first))
639 auto refPair = it->second;
640 onDeleteResourceListener = refPair.first;
642 it->second = refPair;
643 onDeleteResourceListenerMap.insert(*it);
644 LOGD("onDeleteResourceListener: ref. count incremented");
648 if (!onDeleteResourceListener)
650 onDeleteResourceListener = new JniOnDeleteResourceListener(env, jListener,
651 RemoveOnDeleteResourceListener);
652 jobject jgListener = env->NewGlobalRef(jListener);
653 onDeleteResourceListenerMap.insert(
654 std::pair<jobject, std::pair<JniOnDeleteResourceListener*, int>>(
656 std::pair<JniOnDeleteResourceListener*, int>(onDeleteResourceListener, 1)));
657 LOGI("onDeleteResourceListener: new listener");
659 deleteResourceListenerMapLock.unlock();
660 return onDeleteResourceListener;
663 void RemoveOnDeleteResourceListener(JNIEnv* env, jobject jListener)
667 ThrowOcException(JNI_EXCEPTION, "env is null");
671 deleteResourceListenerMapLock.lock();
672 bool isFound = false;
673 for (auto it = onDeleteResourceListenerMap.begin(); it !=
674 onDeleteResourceListenerMap.end(); ++it)
676 if (env->IsSameObject(jListener, it->first))
678 auto refPair = it->second;
679 if (refPair.second > 1)
682 it->second = refPair;
683 onDeleteResourceListenerMap.insert(*it);
684 LOGI("onDeleteResourceListener: ref. count decremented");
688 env->DeleteGlobalRef(it->first);
689 JniOnDeleteResourceListener* listener = refPair.first;
691 onDeleteResourceListenerMap.erase(it);
692 LOGI("onDeleteResourceListener is removed");
700 ThrowOcException(JNI_EXCEPTION, "onDeleteResourceListener not found");
702 deleteResourceListenerMapLock.unlock();
706 * Class: org_iotivity_base_OcPlatform
708 * Signature: (IILjava/lang/String;II)V
710 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_configure
711 (JNIEnv *env, jclass clazz, jint jServiceType, jint jModeType, jstring jIpAddress, jint jPort,
712 jint jQOS, jstring jDbPath)
714 LOGI("OcPlatform_configure");
716 std::string ipAddress;
720 ipAddress = env->GetStringUTFChars(jIpAddress, nullptr);
724 dbfile = env->GetStringUTFChars(jDbPath, nullptr);
725 JniOcSecurity::StoreDbPath(dbfile);
730 port = static_cast<uint16_t>(jPort);
734 JniUtils::getServiceType(env, jServiceType),
735 JniUtils::getModeType(env, jModeType),
738 JniUtils::getQOS(env, static_cast<int>(jQOS)),
739 JniOcSecurity::getOCPersistentStorage()
741 OCPlatform::Configure(cfg);
745 * Class: org_iotivity_base_OcPlatform
746 * Method: notifyAllObservers0
747 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V
749 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyAllObservers0
750 (JNIEnv *env, jclass clazz, jobject jResourceHandle)
752 LOGI("OcPlatform_notifyAllObservers");
753 if (!jResourceHandle)
755 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
759 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
760 env, jResourceHandle);
761 if (!jniOcResourceHandle)
768 OCStackResult result =
769 OCPlatform::notifyAllObservers(jniOcResourceHandle->getOCResourceHandle());
771 if (OC_STACK_OK != result)
773 ThrowOcException(result, "Failed to notify all observers");
777 catch (OCException& e)
779 LOGE("%s", e.reason().c_str());
780 ThrowOcException(e.code(), e.reason().c_str());
785 * Class: org_iotivity_base_OcPlatform
786 * Method: notifyAllObservers1
787 * Signature: (Lorg/iotivity/base/OcResourceHandle;I)V
789 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyAllObservers1
790 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jint jQoS)
792 LOGI("OcPlatform_notifyAllObservers1");
794 if (!jResourceHandle)
796 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
800 JniOcResourceHandle* jniOcResourceHandle =
801 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
802 if (!jniOcResourceHandle)
808 OCStackResult result = OCPlatform::notifyAllObservers(
809 jniOcResourceHandle->getOCResourceHandle(),
810 JniUtils::getQOS(env, static_cast<int>(jQoS)));
812 if (OC_STACK_OK != result)
814 ThrowOcException(result, "Failed to notify all observers");
818 catch (OCException& e)
820 LOGE("%s", e.reason().c_str());
821 ThrowOcException(e.code(), e.reason().c_str());
826 * Class: org_iotivity_base_OcPlatform
827 * Method: notifyListOfObservers2
828 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Ljava/lang/Byte;Lorg/iotivity/base/OcResourceResponse;)V
830 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyListOfObservers2(
833 jobject jResourceHandle,
834 jbyteArray jObservationIdArr,
835 jobject jResourceResponse)
837 LOGD("OcPlatform_notifyListOfObservers2");
838 if (!jResourceHandle)
840 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
843 if (!jObservationIdArr)
845 ThrowOcException(OC_STACK_INVALID_PARAM, "observationIdList cannot be null");
848 if (!jResourceResponse)
850 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
854 JniOcResourceHandle* jniOcResourceHandle =
855 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
856 if (!jniOcResourceHandle)
861 JniOcResourceResponse* jniOcResourceResponse =
862 JniOcResourceResponse::getJniOcResourceResponsePtr(env, jResourceResponse);
863 if (!jniOcResourceResponse)
868 int len = env->GetArrayLength(jObservationIdArr);
869 uint8_t* bArr = (uint8_t*)env->GetByteArrayElements(jObservationIdArr, 0);
871 ObservationIds observationIds;
872 for (int i = 0; i < len; ++i)
874 observationIds.push_back(bArr[i]);
877 env->ReleaseByteArrayElements(jObservationIdArr, (jbyte*)bArr, 0);
881 OCStackResult result = OCPlatform::notifyListOfObservers(
882 jniOcResourceHandle->getOCResourceHandle(),
884 jniOcResourceResponse->getOCResourceResponse());
886 if (OC_STACK_OK != result)
888 ThrowOcException(result, "Failed to notify all observers");
891 catch (OCException& e)
893 LOGE("%s", e.reason().c_str());
894 ThrowOcException(e.code(), e.reason().c_str());
899 * Class: org_iotivity_base_OcPlatform
900 * Method: notifyListOfObservers3
901 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Ljava/lang/Byte;Lorg/iotivity/base/OcResourceResponse;I)V
903 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyListOfObservers3(
906 jobject jResourceHandle,
907 jbyteArray jObservationIdArr,
908 jobject jResourceResponse,
911 LOGD("OcPlatform_notifyListOfObservers3");
912 if (!jResourceHandle)
914 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
917 if (!jObservationIdArr)
919 ThrowOcException(OC_STACK_INVALID_PARAM, "observationIdList cannot be null");
922 if (!jResourceResponse)
924 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
928 JniOcResourceHandle* jniOcResourceHandle =
929 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
930 if (!jniOcResourceHandle)
935 JniOcResourceResponse* jniOcResourceResponse =
936 JniOcResourceResponse::getJniOcResourceResponsePtr(env, jResourceResponse);
937 if (!jniOcResourceResponse)
942 int len = env->GetArrayLength(jObservationIdArr);
943 uint8_t* bArr = (uint8_t*)env->GetByteArrayElements(jObservationIdArr, 0);
945 ObservationIds observationIds;
946 for (int i = 0; i < len; ++i)
948 observationIds.push_back(bArr[i]);
951 env->ReleaseByteArrayElements(jObservationIdArr, (jbyte*)bArr, 0);
955 OCStackResult result = OCPlatform::notifyListOfObservers(
956 jniOcResourceHandle->getOCResourceHandle(),
958 jniOcResourceResponse->getOCResourceResponse(),
959 JniUtils::getQOS(env, static_cast<int>(jQoS)));
961 if (OC_STACK_OK != result)
963 ThrowOcException(result, "Failed to notify all observers");
966 catch (OCException& e)
968 LOGE("%s", e.reason().c_str());
969 ThrowOcException(e.code(), e.reason().c_str());
974 * Class: org_iotivity_base_OcPlatform
975 * Method: findResource0
976 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnResourceFoundListener;)V
978 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findResource0(
982 jstring jResourceUri,
983 jint jConnectivityType,
986 LOGD("OcPlatform_findResource");
990 host = env->GetStringUTFChars(jHost, nullptr);
992 std::string resourceUri;
995 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
999 ThrowOcException(OC_STACK_INVALID_PARAM, "onResourceFoundListener cannot be null");
1003 JniOnResourceFoundListener *onResFoundListener = AddOnResourceFoundListener(env, jListener);
1005 FindCallback findCallback = [onResFoundListener](std::shared_ptr<OCResource> resource)
1007 onResFoundListener->foundResourceCallback(resource);
1010 FindErrorCallback findErrorCallback = [onResFoundListener](const std::string& uri, const int eCode)
1012 onResFoundListener->findResourceErrorCallback(uri, eCode);
1017 OCStackResult result = OCPlatform::findResource(
1020 static_cast<OCConnectivityType>(jConnectivityType),
1024 if (OC_STACK_OK != result)
1026 ThrowOcException(result, "Find resource has failed");
1030 catch (OCException& e)
1032 LOGE("%s", e.reason().c_str());
1033 ThrowOcException(e.code(), e.reason().c_str());
1038 * Class: org_iotivity_base_OcPlatform
1039 * Method: findResource1
1040 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnResourceFoundListener;I)V
1042 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findResource1(
1046 jstring jResourceUri,
1047 jint jConnectivityType,
1051 LOGD("OcPlatform_findResource");
1055 host = env->GetStringUTFChars(jHost, nullptr);
1057 std::string resourceUri;
1060 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1064 ThrowOcException(OC_STACK_INVALID_PARAM, "onResourceFoundListener cannot be null");
1067 JniOnResourceFoundListener *onResFoundListener = AddOnResourceFoundListener(env, jListener);
1069 FindCallback findCallback = [onResFoundListener](std::shared_ptr<OCResource> resource)
1071 onResFoundListener->foundResourceCallback(resource);
1074 FindErrorCallback findErrorCallback = [onResFoundListener](const std::string& uri, const int eCode)
1076 onResFoundListener->findResourceErrorCallback(uri, eCode);
1081 OCStackResult result = OCPlatform::findResource(
1084 static_cast<OCConnectivityType>(jConnectivityType),
1087 JniUtils::getQOS(env, static_cast<int>(jQoS)));
1089 if (OC_STACK_OK != result)
1091 ThrowOcException(result, "Find resource has failed");
1095 catch (OCException& e)
1097 LOGE("%s", e.reason().c_str());
1098 ThrowOcException(e.code(), e.reason().c_str());
1103 * Class: org_iotivity_base_OcPlatform
1104 * Method: findDirectPairingDevices
1105 * Signature: (ILorg/iotivity/base/OcPlatform/FindDirectPairingListener;)V
1107 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findDirectPairingDevices
1108 (JNIEnv * env, jclass clazz, jint jTimeout, jobject jListener)
1110 LOGD("OcPlatform_findDirectPairingDevices");
1114 ThrowOcException(OC_STACK_INVALID_PARAM, "onDPDevicesFoundListener cannot be null");
1117 JniOnDPDevicesFoundListener *onDPDevsFoundListener = AddOnDPDevicesFoundListener(env,
1120 GetDirectPairedCallback getDirectPairedCallback =
1121 [onDPDevsFoundListener](PairedDevices pairingDevList)
1123 onDPDevsFoundListener->directPairingDevicesCallback(pairingDevList,
1124 DPFunc::FIND_DIRECT_PAIRED_DEV_LIST);
1129 OCStackResult result = OCPlatform::findDirectPairingDevices(jTimeout,
1130 getDirectPairedCallback);
1131 if (OC_STACK_OK != result)
1133 ThrowOcException(result, "OCPlatform::findDirectPairingDevices has failed");
1137 catch (OCException& e)
1139 LOGE("%s", e.reason().c_str());
1140 ThrowOcException(e.code(), e.reason().c_str());
1145 * Class: org_iotivity_base_OcPlatform
1146 * Method: getDirectPairedDevices
1147 * Signature: (Lorg/iotivity/base/OcDirectPairDevice/GetDirectPairedListener;)V
1149 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDirectPairedDevices
1150 (JNIEnv *env, jclass jclazz, jobject jListener)
1152 LOGD("OcPlatform_getDirectPairedDevices");
1156 ThrowOcException(OC_STACK_INVALID_PARAM, "getPairedDevList Callback cannot be null");
1159 JniOnDPDevicesFoundListener *onGetPairedDevicesListener = AddOnDPDevicesFoundListener(env,
1162 GetDirectPairedCallback getDirectPairedCallback =
1163 [onGetPairedDevicesListener](PairedDevices pairedDevList)
1165 onGetPairedDevicesListener->directPairingDevicesCallback(pairedDevList,
1166 DPFunc::GET_PAIRED_DEV_LIST);
1171 OCStackResult result = OCPlatform::getDirectPairedDevices(getDirectPairedCallback);
1172 if (OC_STACK_OK != result)
1174 ThrowOcException(result, "OcDirectPairDevice_getDirectPairedDevices");
1178 catch (OCException& e)
1180 LOGE("%s", e.reason().c_str());
1181 ThrowOcException(e.code(), e.reason().c_str());
1186 * Class: org_iotivity_base_OcPlatform
1187 * Method: doDirectPairing
1188 * Signature: (Lorg/iotivity/base/OcDirectPairDevice;Lorg/iotivity/base/OcPrmType;
1189 * Ljava/lang/String;Lorg/iotivity/base/OcDirectPairDevice/DirectPairingListener;)V
1191 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_doDirectPairing0
1192 (JNIEnv *env, jclass clazz, jobject jpeer, jint jprmType, jstring jpin, jobject jListener)
1194 LOGD("OcPlatform_doDirectPairing");
1198 ThrowOcException(OC_STACK_INVALID_PARAM, "doDirectPairing Callback cannot be null");
1203 ThrowOcException(OC_STACK_INVALID_PARAM, "Peer cannot be null");
1207 JniOnDirectPairingListener *onDirectPairingListener = AddOnDirectPairingListener(env,
1210 DirectPairingCallback DirectPairingCB =
1211 [onDirectPairingListener](std::shared_ptr<OCDirectPairing> dpDev, OCStackResult result)
1213 onDirectPairingListener->doDirectPairingCB(dpDev, result);
1216 JniOcDirectPairDevice *dev = JniOcDirectPairDevice::getJniOcDirectPairDevicePtr(env, jpeer);
1222 std::string pin = env->GetStringUTFChars(jpin, 0);
1226 OCStackResult result = OCPlatform::doDirectPairing(dev->getPtr(), (OCPrm_t)jprmType,
1227 pin, DirectPairingCB);
1228 if (OC_STACK_OK != result)
1230 ThrowOcException(result, "OcPlatform_oDirectPairing");
1234 catch (OCException& e)
1236 LOGE("%s", e.reason().c_str());
1237 ThrowOcException(e.code(), e.reason().c_str());
1242 * Class: org_iotivity_base_OcPlatform
1243 * Method: getDeviceInfo0
1244 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeviceFoundListener;)V
1246 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDeviceInfo0(
1250 jstring jResourceUri,
1251 jint jConnectivityType,
1254 LOGD("OcPlatform_getDeviceInfo0");
1258 host = env->GetStringUTFChars(jHost, nullptr);
1260 std::string resourceUri;
1263 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1267 ThrowOcException(OC_STACK_INVALID_PARAM, "onDeviceFoundListener cannot be null");
1270 JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
1272 FindDeviceCallback findDeviceCallback =
1273 [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
1275 onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
1280 OCStackResult result = OCPlatform::getDeviceInfo(
1283 static_cast<OCConnectivityType>(jConnectivityType),
1284 findDeviceCallback);
1286 if (OC_STACK_OK != result)
1288 ThrowOcException(result, "Find device has failed");
1291 catch (OCException& e)
1293 LOGE("%s", e.reason().c_str());
1294 ThrowOcException(e.code(), e.reason().c_str());
1299 * Class: org_iotivity_base_OcPlatform
1300 * Method: getDeviceInfo1
1301 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeviceFoundListener;I)V
1303 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDeviceInfo1(
1307 jstring jResourceUri,
1308 jint jConnectivityType,
1312 LOGD("OcPlatform_getDeviceInfo1");
1316 host = env->GetStringUTFChars(jHost, nullptr);
1318 std::string resourceUri;
1321 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1325 ThrowOcException(OC_STACK_INVALID_PARAM, "onDeviceFoundListener cannot be null");
1328 JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
1330 FindDeviceCallback findDeviceCallback =
1331 [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
1333 onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
1338 OCStackResult result = OCPlatform::getDeviceInfo(
1341 static_cast<OCConnectivityType>(jConnectivityType),
1343 JniUtils::getQOS(env, static_cast<int>(jQoS)));
1345 if (OC_STACK_OK != result)
1347 ThrowOcException(result, "Find device has failed");
1350 catch (OCException& e)
1352 LOGE("%s", e.reason().c_str());
1353 ThrowOcException(e.code(), e.reason().c_str());
1358 * Class: org_iotivity_base_OcPlatform
1359 * Method: getPlatformInfo0
1360 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPlatformFoundListener;)V
1362 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getPlatformInfo0(
1366 jstring jResourceUri,
1367 jint jConnectivityType,
1370 LOGD("OcPlatform_getPlatformInfo0");
1374 host = env->GetStringUTFChars(jHost, nullptr);
1376 std::string resourceUri;
1379 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1383 ThrowOcException(OC_STACK_INVALID_PARAM, "onPlatformFoundListener cannot be null");
1386 JniOnPlatformInfoListener *onPlatformInfoListener = AddOnPlatformInfoListener(env, jListener);
1388 FindPlatformCallback findPlatformCallback =
1389 [onPlatformInfoListener](const OCRepresentation& ocRepresentation)
1391 onPlatformInfoListener->foundPlatformCallback(ocRepresentation);
1396 OCStackResult result = OCPlatform::getPlatformInfo(
1399 static_cast<OCConnectivityType>(jConnectivityType),
1400 findPlatformCallback);
1402 if (OC_STACK_OK != result)
1404 ThrowOcException(result, "Find platform has failed");
1407 catch (OCException& e)
1409 LOGE("%s", e.reason().c_str());
1410 ThrowOcException(e.code(), e.reason().c_str());
1415 * Class: org_iotivity_base_OcPlatform
1416 * Method: getPlatformInfo1
1417 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPlatformFoundListener;I)V
1419 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getPlatformInfo1(
1423 jstring jResourceUri,
1424 jint jConnectivityType,
1428 LOGD("OcPlatform_getPlatformInfo1");
1432 host = env->GetStringUTFChars(jHost, nullptr);
1434 std::string resourceUri;
1437 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1441 ThrowOcException(OC_STACK_INVALID_PARAM, "onPlatformFoundListener cannot be null");
1444 JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
1446 FindDeviceCallback findDeviceCallback =
1447 [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
1449 onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
1454 OCStackResult result = OCPlatform::getPlatformInfo(
1457 static_cast<OCConnectivityType>(jConnectivityType),
1459 JniUtils::getQOS(env, static_cast<int>(jQoS)));
1461 if (OC_STACK_OK != result)
1463 ThrowOcException(result, "Find platform has failed");
1466 catch (OCException& e)
1468 LOGE("%s", e.reason().c_str());
1469 ThrowOcException(e.code(), e.reason().c_str());
1474 * Class: org_iotivity_base_OcPlatform
1475 * Method: registerResource0
1476 * Signature: (Lorg/iotivity/base/OcResource;)Lorg/iotivity/base/OcResourceHandle;
1478 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_registerResource0(
1479 JNIEnv *env, jclass clazz, jobject jResource)
1481 LOGD("OcPlatform_registerResource");
1484 ThrowOcException(OC_STACK_INVALID_PARAM, "Resource cannot be null");
1487 JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, jResource);
1493 OCResourceHandle resourceHandle;
1496 OCStackResult result = OCPlatform::registerResource(
1498 resource->getOCResource());
1500 if (OC_STACK_OK != result)
1502 ThrowOcException(result, "register resource");
1505 catch (OCException& e)
1507 LOGE("%s", e.reason().c_str());
1508 ThrowOcException(e.code(), e.reason().c_str());
1511 JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);
1512 jlong handle = reinterpret_cast<jlong>(jniHandle);
1513 jobject jResourceHandle =
1514 env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);
1516 if (!jResourceHandle)
1518 LOGE("Failed to create OcResourceHandle");
1521 return jResourceHandle;
1525 * Class: org_iotivity_base_OcPlatform
1526 * Method: registerResource1
1527 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcPlatform/EntityHandler;I)Lorg/iotivity/base/OcResourceHandle;
1529 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_registerResource1(
1532 jstring jResourceUri,
1533 jstring jResourceTypeName,
1534 jstring jResourceInterface,
1535 jobject jListener, jint jResourceProperty)
1537 LOGI("OcPlatform_registerResource1");
1538 std::string resourceUri;
1541 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1543 std::string resourceTypeName;
1544 if (jResourceTypeName)
1546 resourceTypeName = env->GetStringUTFChars(jResourceTypeName, nullptr);
1548 std::string resourceInterface;
1549 if (jResourceInterface)
1551 resourceInterface = env->GetStringUTFChars(jResourceInterface, nullptr);
1553 JniEntityHandler* entityHandler = NULL;
1554 EntityHandler handleEntityCallback = NULL;
1557 entityHandler = new JniEntityHandler(env, jListener);
1558 handleEntityCallback =
1559 [entityHandler](const std::shared_ptr<OCResourceRequest> request) -> OCEntityHandlerResult
1561 return entityHandler->handleEntity(request);
1565 OCResourceHandle resourceHandle;
1568 OCStackResult result = OCPlatform::registerResource(
1573 handleEntityCallback,
1574 static_cast<int>(jResourceProperty));
1576 if (OC_STACK_OK != result)
1578 delete entityHandler;
1579 ThrowOcException(result, "register resource");
1583 catch (OCException& e)
1585 LOGE("%s", e.reason().c_str());
1586 delete entityHandler;
1587 ThrowOcException(e.code(), e.reason().c_str());
1591 JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);
1592 jlong handle = reinterpret_cast<jlong>(jniHandle);
1593 jobject jResourceHandle =
1594 env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);
1595 if (!jResourceHandle)
1597 LOGE("Failed to create OcResourceHandle");
1601 return jResourceHandle;
1605 * Class: org_iotivity_base_OcPlatform
1606 * Method: registerDeviceInfo0
1607 * 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
1609 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_registerDeviceInfo0(
1612 jstring jDeviceName,
1613 jobjectArray jDeviceTypes)
1615 LOGI("OcPlatform_registerDeviceInfo");
1619 ThrowOcException(OC_STACK_INVALID_PARAM, "deviceName cannot be null");
1625 ThrowOcException(OC_STACK_INVALID_PARAM, "deviceTypes cannot be null");
1629 OCDeviceInfo deviceInfo;
1632 DuplicateString(&deviceInfo.deviceName, env->GetStringUTFChars(jDeviceName, nullptr));
1633 deviceInfo.types = NULL;
1635 jsize len = env->GetArrayLength(jDeviceTypes);
1636 for (jsize i = 0; i < len; ++i)
1638 jstring jStr = (jstring)env->GetObjectArrayElement(jDeviceTypes, i);
1641 delete deviceInfo.deviceName;
1642 ThrowOcException(OC_STACK_INVALID_PARAM, "device type cannot be null");
1646 OCResourcePayloadAddStringLL(&deviceInfo.types, env->GetStringUTFChars(jStr, nullptr));
1647 if (env->ExceptionCheck())
1649 delete deviceInfo.deviceName;
1653 env->DeleteLocalRef(jStr);
1656 catch (std::exception &e)
1658 ThrowOcException(JNI_EXCEPTION, "Failed to construct device info");
1664 OCStackResult result = OCPlatform::registerDeviceInfo(deviceInfo);
1666 delete deviceInfo.deviceName;
1668 if (OC_STACK_OK != result)
1670 ThrowOcException(result, "Failed to register device info");
1674 catch (OCException& e)
1676 LOGE("%s", e.reason().c_str());
1677 ThrowOcException(e.code(), e.reason().c_str());
1682 * Class: org_iotivity_base_OcPlatform
1683 * Method: registerPlatformInfo0
1684 * 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
1686 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_registerPlatformInfo0(
1689 jstring jPlatformID,
1690 jstring jManufacturerName,
1691 jstring jManufacturerUrl,
1692 jstring jModelNumber,
1693 jstring jDateOfManufacture,
1694 jstring jPlatformVersion,
1695 jstring jOperatingSystemVersion,
1696 jstring jHardwareVersion,
1697 jstring jFirmwareVersion,
1698 jstring jSupportUrl,
1699 jstring jSystemTime)
1701 LOGI("OcPlatform_registerPlatformInfo");
1704 std::string platformID;
1705 std::string manufacturerName;
1706 std::string manufacturerUrl;
1707 std::string modelNumber;
1708 std::string dateOfManufacture;
1709 std::string platformVersion;
1710 std::string operatingSystemVersion;
1711 std::string hardwareVersion;
1712 std::string firmwareVersion;
1713 std::string supportUrl;
1714 std::string systemTime;
1718 platformID = env->GetStringUTFChars(jPlatformID, nullptr);
1720 if (jManufacturerName)
1722 manufacturerName = env->GetStringUTFChars(jManufacturerName, nullptr);
1724 if (jManufacturerUrl)
1726 manufacturerUrl = env->GetStringUTFChars(jManufacturerUrl, nullptr);
1730 modelNumber = env->GetStringUTFChars(jModelNumber, nullptr);
1732 if (jDateOfManufacture)
1734 dateOfManufacture = env->GetStringUTFChars(jDateOfManufacture, nullptr);
1736 if (jPlatformVersion)
1738 platformVersion = env->GetStringUTFChars(jPlatformVersion, nullptr);
1740 if (jOperatingSystemVersion)
1742 operatingSystemVersion = env->GetStringUTFChars(jOperatingSystemVersion, nullptr);
1744 if (jHardwareVersion)
1746 hardwareVersion = env->GetStringUTFChars(jHardwareVersion, nullptr);
1748 if (jFirmwareVersion)
1750 firmwareVersion = env->GetStringUTFChars(jFirmwareVersion, nullptr);
1754 supportUrl = env->GetStringUTFChars(jSupportUrl, nullptr);
1758 systemTime = env->GetStringUTFChars(jSystemTime, nullptr);
1761 OCPlatformInfo platformInfo;
1764 DuplicateString(&platformInfo.platformID, platformID);
1765 DuplicateString(&platformInfo.manufacturerName, manufacturerName);
1766 DuplicateString(&platformInfo.manufacturerUrl, manufacturerUrl);
1767 DuplicateString(&platformInfo.modelNumber, modelNumber);
1768 DuplicateString(&platformInfo.dateOfManufacture, dateOfManufacture);
1769 DuplicateString(&platformInfo.platformVersion, platformVersion);
1770 DuplicateString(&platformInfo.operatingSystemVersion, operatingSystemVersion);
1771 DuplicateString(&platformInfo.hardwareVersion, hardwareVersion);
1772 DuplicateString(&platformInfo.firmwareVersion, firmwareVersion);
1773 DuplicateString(&platformInfo.supportUrl, supportUrl);
1774 DuplicateString(&platformInfo.systemTime, systemTime);
1776 catch (std::exception &e)
1778 ThrowOcException(JNI_EXCEPTION, "Failed to construct platform info");
1782 // __android_log_print(ANDROID_LOG_INFO, "Rahul", "platformID = %s", platformID);
1785 OCStackResult result = OCPlatform::registerPlatformInfo(platformInfo);
1787 delete platformInfo.platformID;
1788 delete platformInfo.manufacturerName;
1789 delete platformInfo.manufacturerUrl;
1790 delete platformInfo.modelNumber;
1791 delete platformInfo.dateOfManufacture;
1792 delete platformInfo.platformVersion;
1793 delete platformInfo.operatingSystemVersion;
1794 delete platformInfo.hardwareVersion;
1795 delete platformInfo.firmwareVersion;
1796 delete platformInfo.supportUrl;
1797 delete platformInfo.systemTime;
1799 if (OC_STACK_OK != result)
1801 ThrowOcException(result, "Failed to register platform info");
1805 catch (OCException& e)
1807 LOGE("Error is due to %s", e.reason().c_str());
1808 ThrowOcException(e.code(), e.reason().c_str());
1813 * Class: org_iotivity_base_OcPlatform
1814 * Method: unregisterResource0
1815 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V
1817 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unregisterResource0(
1818 JNIEnv *env, jclass clazz, jobject jResourceHandle)
1820 LOGI("OcPlatform_unregisterResource");
1821 if (!jResourceHandle)
1823 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1826 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1827 env, jResourceHandle);
1828 if (!jniOcResourceHandle)
1835 OCResourceHandle resHandle = jniOcResourceHandle->getOCResourceHandle();
1836 OCStackResult result = OCPlatform::unregisterResource(resHandle);
1837 if (OC_STACK_OK != result)
1839 ThrowOcException(result, "Failed to unregister resource");
1842 catch (OCException& e)
1844 LOGE("%s", e.reason().c_str());
1845 ThrowOcException(e.code(), e.reason().c_str());
1850 * Class: org_iotivity_base_OcPlatform
1851 * Method: bindResource0
1852 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
1854 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResource0
1855 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobject jResourceHandle)
1857 LOGI("OcPlatform_bindResource");
1858 if (!jResourceCollectionHandle)
1860 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1863 if (!jResourceHandle)
1865 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1868 JniOcResourceHandle* jniOcResourceCollectionHandle =
1869 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1870 if (!jniOcResourceCollectionHandle)
1875 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1876 env, jResourceHandle);
1877 if (!jniOcResourceHandle)
1884 OCStackResult result = OCPlatform::bindResource(
1885 jniOcResourceCollectionHandle->getOCResourceHandle(),
1886 jniOcResourceHandle->getOCResourceHandle()
1889 if (OC_STACK_OK != result)
1891 ThrowOcException(result, "Failed to bind resource");
1894 catch (OCException& e)
1896 LOGE("%s", e.reason().c_str());
1897 ThrowOcException(e.code(), e.reason().c_str());
1902 * Class: org_iotivity_base_OcPlatform
1903 * Method: bindResources0
1904 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
1906 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResources0(
1909 jobject jResourceCollectionHandle,
1910 jobjectArray jResourceHandleArray)
1912 LOGI("OcPlatform_bindResources");
1914 if (!jResourceCollectionHandle)
1916 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1919 if (!jResourceHandleArray)
1921 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
1925 JniOcResourceHandle* jniOcResourceCollectionHandle =
1926 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1927 if (!jniOcResourceCollectionHandle)
1932 std::vector<OCResourceHandle> resourceHandleList;
1933 int len = env->GetArrayLength(jResourceHandleArray);
1934 for (int i = 0; i < len; ++i)
1936 jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
1937 if (!jResourceHandle)
1939 ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
1943 JniOcResourceHandle* jniOcResourceHandle =
1944 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1945 if (!jniOcResourceHandle)
1950 resourceHandleList.push_back(
1951 jniOcResourceHandle->getOCResourceHandle());
1956 OCStackResult result = OCPlatform::bindResources(
1957 jniOcResourceCollectionHandle->getOCResourceHandle(),
1961 if (OC_STACK_OK != result)
1963 ThrowOcException(result, "Failed to bind resources");
1966 catch (OCException& e)
1968 LOGE("%s", e.reason().c_str());
1969 ThrowOcException(e.code(), e.reason().c_str());
1974 * Class: org_iotivity_base_OcPlatform
1975 * Method: unbindResource0
1976 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
1978 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResource0(
1981 jobject jResourceCollectionHandle,
1982 jobject jResourceHandle)
1984 LOGI("OcPlatform_unbindResource");
1985 if (!jResourceCollectionHandle)
1987 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1990 if (!jResourceHandle)
1992 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1996 JniOcResourceHandle* jniOcResourceCollectionHandle =
1997 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1998 if (!jniOcResourceCollectionHandle)
2003 JniOcResourceHandle* jniOcResourceHandle =
2004 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
2005 if (!jniOcResourceHandle)
2012 OCStackResult result = OCPlatform::unbindResource(
2013 jniOcResourceCollectionHandle->getOCResourceHandle(),
2014 jniOcResourceHandle->getOCResourceHandle());
2016 if (OC_STACK_OK != result)
2018 ThrowOcException(result, "Failed to unbind resource");
2021 catch (OCException& e)
2023 LOGE("%s", e.reason().c_str());
2024 ThrowOcException(e.code(), e.reason().c_str());
2029 * Class: org_iotivity_base_OcPlatform
2030 * Method: unbindResources0
2031 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
2033 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResources0(
2036 jobject jResourceCollectionHandle,
2037 jobjectArray jResourceHandleArray)
2039 LOGI("OcPlatform_unbindResources");
2040 if (!jResourceCollectionHandle)
2042 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
2045 if (!jResourceHandleArray)
2047 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
2051 JniOcResourceHandle* jniOcResourceCollectionHandle =
2052 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
2053 if (!jniOcResourceCollectionHandle)
2058 std::vector<OCResourceHandle> resourceHandleList;
2059 int len = env->GetArrayLength(jResourceHandleArray);
2060 for (int i = 0; i < len; ++i)
2062 jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
2063 if (!jResourceHandle)
2065 ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
2069 JniOcResourceHandle* jniOcResourceHandle =
2070 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
2071 if (!jniOcResourceHandle)
2076 resourceHandleList.push_back(
2077 jniOcResourceHandle->getOCResourceHandle());
2082 OCStackResult result = OCPlatform::unbindResources(
2083 jniOcResourceCollectionHandle->getOCResourceHandle(),
2087 if (OC_STACK_OK != result)
2089 ThrowOcException(result, "Failed to unbind resources");
2092 catch (OCException& e)
2094 LOGE("%s", e.reason().c_str());
2095 ThrowOcException(e.code(), e.reason().c_str());
2100 * Class: org_iotivity_base_OcPlatform
2101 * Method: bindTypeToResource0
2102 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
2104 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindTypeToResource0(
2107 jobject jResourceHandle,
2108 jstring jResourceTypeName)
2110 LOGI("OcPlatform_bindTypeToResource");
2111 if (!jResourceHandle)
2113 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
2116 std::string typeName;
2117 if (jResourceTypeName)
2119 typeName = env->GetStringUTFChars(jResourceTypeName, nullptr);
2122 JniOcResourceHandle* jniOcResourceHandle =
2123 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
2124 if (!jniOcResourceHandle)
2131 OCStackResult result = OCPlatform::bindTypeToResource(
2132 jniOcResourceHandle->getOCResourceHandle(),
2136 if (OC_STACK_OK != result)
2138 ThrowOcException(result, "Failed to bind type to resource");
2141 catch (OCException& e)
2143 LOGE("%s", e.reason().c_str());
2144 ThrowOcException(e.code(), e.reason().c_str());
2149 * Class: org_iotivity_base_OcPlatform
2150 * Method: bindInterfaceToResource0
2151 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
2153 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindInterfaceToResource0
2154 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jstring jResourceInterfaceName)
2156 LOGI("OcPlatform_bindInterfaceToResource");
2157 if (!jResourceHandle)
2159 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
2162 std::string interfaceName;
2163 if (jResourceInterfaceName)
2165 interfaceName = env->GetStringUTFChars(jResourceInterfaceName, nullptr);
2168 JniOcResourceHandle* jniOcResourceHandle =
2169 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
2170 if (!jniOcResourceHandle)
2177 OCStackResult result = OCPlatform::bindInterfaceToResource(
2178 jniOcResourceHandle->getOCResourceHandle(),
2182 if (OC_STACK_OK != result)
2184 ThrowOcException(result, "Failed to bind interface to resource");
2187 catch (OCException& e)
2189 LOGE("%s", e.reason().c_str());
2190 ThrowOcException(e.code(), e.reason().c_str());
2195 * Class: org_iotivity_base_OcPlatform
2196 * Method: startPresence0
2199 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_startPresence0(
2200 JNIEnv *env, jclass clazz, jint ttl)
2202 LOGI("OcPlatform_startPresence");
2206 OCStackResult result = OCPlatform::startPresence((unsigned int)ttl);
2208 if (OC_STACK_OK != result)
2210 ThrowOcException(result, "Failed to start presence");
2213 catch (OCException& e)
2215 LOGE("%s", e.reason().c_str());
2216 ThrowOcException(e.code(), e.reason().c_str());
2221 * Class: org_iotivity_base_OcPlatform
2222 * Method: stopPresence0
2225 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_stopPresence0(
2226 JNIEnv *env, jclass clazz)
2228 LOGI("OcPlatform_stopPresence");
2232 OCStackResult result = OCPlatform::stopPresence();
2234 if (OC_STACK_OK != result)
2236 ThrowOcException(result, "Failed to stop presence");
2239 catch (OCException& e)
2241 LOGE("%s", e.reason().c_str());
2242 ThrowOcException(e.code(), e.reason().c_str());
2247 * Class: org_iotivity_base_OcPlatform
2248 * Method: subscribePresence0
2249 * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
2251 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence0(
2255 jint jConnectivityType,
2258 LOGD("OcPlatform_subscribePresence");
2262 host = env->GetStringUTFChars(jHost, nullptr);
2266 ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
2270 JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
2272 SubscribeCallback subscribeCallback =
2273 [onPresenceListener](OCStackResult result,
2274 const unsigned int nonce,
2275 const std::string& hostAddress)
2277 onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
2280 OCPlatform::OCPresenceHandle presenceHandle;
2283 OCStackResult result = OCPlatform::subscribePresence(
2286 static_cast<OCConnectivityType>(jConnectivityType),
2289 if (OC_STACK_OK != result)
2291 ThrowOcException(result, "subscribe presence has failed");
2294 catch (OCException& e)
2296 LOGE("%s", e.reason().c_str());
2297 ThrowOcException(e.code(), e.reason().c_str());
2301 JniOcPresenceHandle* jniPresenceHandle =
2302 new JniOcPresenceHandle(onPresenceListener, presenceHandle);
2303 jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
2304 jobject jPresenceHandle =
2305 env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
2306 if (!jPresenceHandle)
2308 LOGE("Failed to create OcPresenceHandle");
2309 delete jniPresenceHandle;
2311 return jPresenceHandle;
2315 * Class: org_iotivity_base_OcPlatform
2316 * Method: subscribePresence1
2317 * Signature: (Ljava/lang/String;Ljava/lang/String;I
2318 Lorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
2320 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence1(
2324 jstring jResourceType,
2325 jint jConnectivityType,
2328 LOGD("OcPlatform_subscribePresence1");
2332 host = env->GetStringUTFChars(jHost, nullptr);
2334 std::string resourceType;
2337 resourceType = env->GetStringUTFChars(jResourceType, nullptr);
2341 ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
2345 JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
2347 SubscribeCallback subscribeCallback = [onPresenceListener](OCStackResult result,
2348 const unsigned int nonce, const std::string& hostAddress)
2350 onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
2353 OCPlatform::OCPresenceHandle presenceHandle;
2356 OCStackResult result = OCPlatform::subscribePresence(
2360 static_cast<OCConnectivityType>(jConnectivityType),
2363 if (OC_STACK_OK != result)
2365 ThrowOcException(result, "subscribe presence has failed");
2368 catch (OCException& e)
2370 LOGE("%s", e.reason().c_str());
2371 ThrowOcException(e.code(), e.reason().c_str());
2375 JniOcPresenceHandle* jniPresenceHandle =
2376 new JniOcPresenceHandle(onPresenceListener, presenceHandle);
2377 jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
2378 jobject jPresenceHandle =
2379 env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
2380 if (!jPresenceHandle)
2382 LOGE("Failed to create OcPresenceHandle");
2383 delete jniPresenceHandle;
2385 return jPresenceHandle;
2389 * Class: org_iotivity_base_OcPlatform
2390 * Method: unsubscribePresence0
2391 * Signature: (Lorg/iotivity/base/OcPresenceHandle;)V
2393 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unsubscribePresence0(
2394 JNIEnv *env, jclass clazz, jobject jPresenceHandle)
2396 LOGD("OcPlatform_unsubscribePresence");
2397 if (!jPresenceHandle)
2399 ThrowOcException(OC_STACK_INVALID_PARAM, "presenceHandle cannot be null");
2402 JniOcPresenceHandle* jniPresenceHandle =
2403 JniOcPresenceHandle::getJniOcPresenceHandlePtr(env, jPresenceHandle);
2404 if (!jniPresenceHandle)
2409 OCPresenceHandle presenceHandle = jniPresenceHandle->getOCPresenceHandle();
2413 OCStackResult result = OCPlatform::unsubscribePresence(presenceHandle);
2415 if (OC_STACK_OK != result)
2417 ThrowOcException(result, "unsubscribe presence has failed");
2420 jweak jwOnPresenceListener =
2421 jniPresenceHandle->getJniOnPresenceListener()->getJWListener();
2422 if (jwOnPresenceListener)
2424 RemoveOnPresenceListener(env, jwOnPresenceListener);
2426 jweak jwOnObserveListener =
2427 jniPresenceHandle->getJniOnObserveListener()->getJWListener();
2428 if (jwOnObserveListener)
2430 RemoveOnObserveListener(env, jwOnObserveListener);
2433 catch (OCException& e)
2435 LOGE("%s", e.reason().c_str());
2436 ThrowOcException(e.code(), e.reason().c_str());
2441 * Class: org_iotivity_base_OcPlatform
2442 * Method: subscribeDevicePresence0
2443 * Signature: (Ljava/lang/String;[Ljava/lang/String;I
2444 Lorg/iotivity/base/OcResource/OnObserveListener;)Lorg/iotivity/base/OcPresenceHandle;
2446 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribeDevicePresence0(
2450 jobjectArray jDiArray,
2451 jint jConnectivityType,
2454 LOGD("OcPlatform_subscribeDevicePresence0");
2459 host = env->GetStringUTFChars(jHost, nullptr);
2464 ThrowOcException(OC_STACK_INVALID_PARAM, "device id List cannot be null");
2468 std::vector<std::string> di;
2469 JniUtils::convertJavaStrArrToStrVector(env, jDiArray, di);
2473 ThrowOcException(OC_STACK_INVALID_PARAM, "onObserveListener cannot be null");
2477 JniOnObserveListener *onObserveListener = AddOnObserveListener(env, jListener);
2479 ObserveCallback observeCallback = [onObserveListener](const HeaderOptions& opts,
2480 const OCRepresentation& rep, const int& eCode, const int& sequenceNumber)
2482 onObserveListener->onObserveCallback(opts, rep, eCode, sequenceNumber);
2485 OCPlatform::OCPresenceHandle presenceHandle;
2488 OCStackResult result = OCPlatform::subscribeDevicePresence(
2492 static_cast<OCConnectivityType>(jConnectivityType),
2495 if (OC_STACK_OK != result)
2497 ThrowOcException(result, "subscribe device presence has failed");
2500 catch (OCException& e)
2502 LOGE("%s", e.reason().c_str());
2503 ThrowOcException(e.code(), e.reason().c_str());
2507 JniOcPresenceHandle* jniPresenceHandle =
2508 new JniOcPresenceHandle(onObserveListener, presenceHandle);
2509 jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
2510 jobject jPresenceHandle =
2511 env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
2512 if (!jPresenceHandle)
2514 LOGE("Failed to create OcPresenceHandle");
2515 delete jniPresenceHandle;
2517 return jPresenceHandle;
2519 ThrowOcException(JNI_EXCEPTION, "Not support");
2525 * Class: org_iotivity_base_OcPlatform
2526 * Method: constructResourceObject0
2527 * Signature: (Ljava/lang/String;Ljava/lang/String;IZ[Ljava/lang/String;[Ljava/lang/String;)
2528 Lorg/iotivity/base/OcResource;
2530 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_constructResourceObject0(
2535 jint jConnectivityType,
2536 jboolean jIsObservable,
2537 jobjectArray jResourceTypeArray,
2538 jobjectArray jInterfaceArray)
2540 LOGD("OcPlatform_constructResourceObject");
2544 host = env->GetStringUTFChars(jHost, nullptr);
2549 uri = env->GetStringUTFChars(jUri, nullptr);
2551 if (!jResourceTypeArray)
2553 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceTypeList cannot be null");
2556 if (!jInterfaceArray)
2558 ThrowOcException(OC_STACK_INVALID_PARAM, "interfaceList cannot be null");
2562 std::vector<std::string> resourceTypes;
2563 JniUtils::convertJavaStrArrToStrVector(env, jResourceTypeArray, resourceTypes);
2565 std::vector<std::string> interfaces;
2566 JniUtils::convertJavaStrArrToStrVector(env, jInterfaceArray, interfaces);
2568 std::shared_ptr<OCResource> resource = OCPlatform::constructResourceObject(
2571 static_cast<OCConnectivityType>(jConnectivityType),
2572 static_cast<bool>(jIsObservable),
2578 ThrowOcException(OC_STACK_ERROR, "Failed to create OCResource");
2582 JniOcResource *jniOcResource = new JniOcResource(resource);
2584 jobject jResource = env->NewObject(g_cls_OcResource, g_mid_OcResource_ctor);
2587 delete jniOcResource;
2590 SetHandle<JniOcResource>(env, jResource, jniOcResource);
2591 if (env->ExceptionCheck())
2593 delete jniOcResource;
2600 * Class: org_iotivity_base_OcPlatform
2601 * Method: sendResponse0
2602 * Signature: (Lorg/iotivity/base/OcResourceResponse;)V
2604 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_sendResponse0(
2605 JNIEnv *env, jclass clazz, jobject jResourceResponse)
2607 LOGD("OcPlatform_sendResponse");
2608 if (!jResourceResponse)
2610 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
2614 JniOcResourceResponse *jniResponse =
2615 JniOcResourceResponse::getJniOcResourceResponsePtr(env, jResourceResponse);
2623 OCStackResult result =
2624 OCPlatform::sendResponse(jniResponse->getOCResourceResponse());
2626 if (OC_STACK_OK != result)
2628 ThrowOcException(result, "failed to send response");
2631 catch (OCException& e)
2633 LOGE("%s", e.reason().c_str());
2634 ThrowOcException(e.code(), e.reason().c_str());
2639 * Class: org_iotivity_base_OcPlatform
2640 * Method: publishResourceToRD0
2641 * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPublishResourceListener;I)V
2643 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_publishResourceToRD0(
2647 jint jConnectivityType,
2651 LOGD("OcPlatform_publishResourceToRD");
2656 host = env->GetStringUTFChars(jHost, nullptr);
2660 ThrowOcException(OC_STACK_INVALID_PARAM, "onPublishResourceListener cannot be null");
2663 JniOnPublishResourceListener *onPubResListener = AddOnPublishResourceListener(env, jListener);
2665 PublishResourceCallback pubResCallback = [onPubResListener](
2666 const OCRepresentation& ocRepresentation,
2669 onPubResListener->onPublishResourceCallback(ocRepresentation, eCode);
2674 OCStackResult result = OCPlatform::publishResourceToRD(
2676 static_cast<OCConnectivityType>(jConnectivityType),
2678 JniUtils::getQOS(env, static_cast<int>(jQoS)));
2680 if (OC_STACK_OK != result)
2682 ThrowOcException(result, "Publish resource has failed");
2686 catch (OCException& e)
2688 LOGE("%s", e.reason().c_str());
2689 ThrowOcException(e.code(), e.reason().c_str());
2692 ThrowOcException(OC_STACK_ERROR, "Publish resource has failed");
2698 * Class: org_iotivity_base_OcPlatform
2699 * Method: publishResourceToRD1
2700 * Signature: (Ljava/lang/String;I[Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcPlatform/OnPublishResourceListener;I)V
2702 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_publishResourceToRD1(
2706 jint jConnectivityType,
2707 jobjectArray jResourceHandleArray,
2711 LOGD("OcPlatform_publishResourceToRD");
2715 ThrowOcException(OC_STACK_INVALID_PARAM, "env is null");
2721 host = env->GetStringUTFChars(jHost, nullptr);
2725 ThrowOcException(OC_STACK_INVALID_PARAM, "onPublishResourceListener cannot be null");
2728 if (!jResourceHandleArray)
2730 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
2733 JniOnPublishResourceListener *onPubResListener = AddOnPublishResourceListener(env, jListener);
2735 PublishResourceCallback pubResCallback = [onPubResListener](
2736 const OCRepresentation& ocRepresentation,
2739 onPubResListener->onPublishResourceCallback(ocRepresentation, eCode);
2742 std::vector<OCResourceHandle> resourceHandleList;
2743 size_t len = env->GetArrayLength(jResourceHandleArray);
2744 for (size_t i = 0; i < len; ++i)
2746 jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
2747 if (!jResourceHandle)
2749 ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
2753 JniOcResourceHandle* jniOcResourceHandle =
2754 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
2755 if (!jniOcResourceHandle)
2757 ThrowOcException(OC_STACK_INVALID_PARAM, "resource handle is invalid");
2761 resourceHandleList.push_back(jniOcResourceHandle->getOCResourceHandle());
2766 OCStackResult result = OCPlatform::publishResourceToRD(
2768 static_cast<OCConnectivityType>(jConnectivityType),
2771 JniUtils::getQOS(env, static_cast<int>(jQoS)));
2773 if (OC_STACK_OK != result)
2775 ThrowOcException(result, "Publish resource has failed");
2779 catch (OCException& e)
2781 LOGE("%s", e.reason().c_str());
2782 ThrowOcException(e.code(), e.reason().c_str());
2785 ThrowOcException(OC_STACK_ERROR, "Publish resource has failed");
2791 * Class: org_iotivity_base_OcPlatform
2792 * Method: deleteResourceFromRD0
2793 * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeleteResourceListener;I)V
2795 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_deleteResourceFromRD0(
2799 jint jConnectivityType,
2803 LOGD("OcPlatform_deleteResourceFromRD");
2808 host = env->GetStringUTFChars(jHost, nullptr);
2812 ThrowOcException(OC_STACK_INVALID_PARAM, "onDeleteResourceListener cannot be null");
2815 JniOnDeleteResourceListener *onDelResListener = AddOnDeleteResourceListener(env, jListener);
2817 DeleteResourceCallback delResCallback = [onDelResListener](const int eCode)
2819 onDelResListener->onDeleteResourceCallback(eCode);
2824 OCStackResult result = OCPlatform::deleteResourceFromRD(
2826 static_cast<OCConnectivityType>(jConnectivityType),
2828 JniUtils::getQOS(env, static_cast<int>(jQoS)));
2830 if (OC_STACK_OK != result)
2832 ThrowOcException(result, "Delete resource has failed");
2836 catch (OCException& e)
2838 LOGE("%s", e.reason().c_str());
2839 ThrowOcException(e.code(), e.reason().c_str());
2842 ThrowOcException(OC_STACK_ERROR, "Delete resource has failed");
2848 * Class: org_iotivity_base_OcPlatform
2849 * Method: deleteResourceFromRD1
2850 * Signature: (Ljava/lang/String;I[Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcPlatform/OnDeleteResourceListener;I)V
2852 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_deleteResourceFromRD1(
2856 jint jConnectivityType,
2857 jobjectArray jResourceHandleArray,
2861 LOGD("OcPlatform_deleteResourceFromRD");
2865 ThrowOcException(OC_STACK_INVALID_PARAM, "env is null");
2871 host = env->GetStringUTFChars(jHost, nullptr);
2875 ThrowOcException(OC_STACK_INVALID_PARAM, "onDeleteResourceListener cannot be null");
2878 if (!jResourceHandleArray)
2880 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
2883 JniOnDeleteResourceListener *onDelResListener = AddOnDeleteResourceListener(env, jListener);
2885 DeleteResourceCallback delResCallback = [onDelResListener](const int eCode)
2887 onDelResListener->onDeleteResourceCallback(eCode);
2890 std::vector<OCResourceHandle> resourceHandleList;
2891 size_t len = env->GetArrayLength(jResourceHandleArray);
2892 for (size_t i = 0; i < len; ++i)
2894 jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
2895 if (!jResourceHandle)
2897 ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
2901 JniOcResourceHandle* jniOcResourceHandle =
2902 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
2903 if (!jniOcResourceHandle)
2905 ThrowOcException(OC_STACK_INVALID_PARAM, "resource handle is invalid");
2909 resourceHandleList.push_back(jniOcResourceHandle->getOCResourceHandle());
2914 OCStackResult result = OCPlatform::deleteResourceFromRD(
2916 static_cast<OCConnectivityType>(jConnectivityType),
2919 JniUtils::getQOS(env, static_cast<int>(jQoS)));
2921 if (OC_STACK_OK != result)
2923 ThrowOcException(result, "Delete resource has failed");
2927 catch (OCException& e)
2929 LOGE("%s", e.reason().c_str());
2930 ThrowOcException(e.code(), e.reason().c_str());
2933 ThrowOcException(OC_STACK_ERROR, "Delete resource has failed");
2939 * Class: org_iotivity_base_OcPlatform
2940 * Method: constructAccountManagerObject0
2941 * Signature: (Ljava/lang/String;I)Lorg/iotivity/base/OcAccountManager;
2943 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_constructAccountManagerObject0(
2947 jint jConnectivityType)
2950 ThrowOcException(OC_STACK_ERROR,
2951 "OCAccountManager is not supported. (Please build with WITH_CLOUD=1 option)");
2954 LOGD("OcPlatform_constructAccountManagerObject");
2957 ThrowOcException(OC_STACK_INVALID_PARAM, "host cannot be null");
2961 const char* charHost = env->GetStringUTFChars(jHost, nullptr);
2964 ThrowOcException(JNI_EXCEPTION, "charHost is null");
2967 std::string host(charHost);
2968 env->ReleaseStringUTFChars(jHost, charHost);
2970 std::shared_ptr<OCAccountManager> accountManager = OCPlatform::constructAccountManagerObject(
2972 static_cast<OCConnectivityType>(jConnectivityType));
2974 if (!accountManager)
2976 ThrowOcException(OC_STACK_ERROR, "Failed to create OCAccountManager");
2980 JniOcAccountManager *jniOcAccountManager = new JniOcAccountManager(accountManager);
2982 jobject jAccountManager = env->NewObject(g_cls_OcAccountManager, g_mid_OcAccountManager_ctor);
2983 if (!jAccountManager)
2985 delete jniOcAccountManager;
2988 SetHandle<JniOcAccountManager>(env, jAccountManager, jniOcAccountManager);
2989 if (env->ExceptionCheck())
2991 delete jniOcAccountManager;
2994 return jAccountManager;