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);
774 OCStackResult result = OCPlatform::findResource(
777 static_cast<OCConnectivityType>(jConnectivityType),
780 if (OC_STACK_OK != result)
782 ThrowOcException(result, "Find resource has failed");
786 catch (OCException& e)
788 LOGE("%s", e.reason().c_str());
789 ThrowOcException(e.code(), e.reason().c_str());
794 * Class: org_iotivity_base_OcPlatform
795 * Method: findResource1
796 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnResourceFoundListener;I)V
798 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findResource1(
802 jstring jResourceUri,
803 jint jConnectivityType,
807 LOGD("OcPlatform_findResource");
811 host = env->GetStringUTFChars(jHost, nullptr);
813 std::string resourceUri;
816 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
820 ThrowOcException(OC_STACK_INVALID_PARAM, "onResourceFoundListener cannot be null");
823 JniOnResourceFoundListener *onResFoundListener = AddOnResourceFoundListener(env, jListener);
825 FindCallback findCallback = [onResFoundListener](std::shared_ptr<OCResource> resource)
827 onResFoundListener->foundResourceCallback(resource);
832 OCStackResult result = OCPlatform::findResource(
835 static_cast<OCConnectivityType>(jConnectivityType),
837 JniUtils::getQOS(env, static_cast<int>(jQoS)));
839 if (OC_STACK_OK != result)
841 ThrowOcException(result, "Find resource has failed");
845 catch (OCException& e)
847 LOGE("%s", e.reason().c_str());
848 ThrowOcException(e.code(), e.reason().c_str());
853 * Class: org_iotivity_base_OcPlatform
854 * Method: findDirectPairingDevices
855 * Signature: (ILorg/iotivity/base/OcPlatform/FindDirectPairingListener;)V
857 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findDirectPairingDevices
858 (JNIEnv * env, jclass clazz, jint jTimeout, jobject jListener)
860 LOGD("OcPlatform_findDirectPairingDevices");
864 ThrowOcException(OC_STACK_INVALID_PARAM, "onDPDevicesFoundListener cannot be null");
867 JniOnDPDevicesFoundListener *onDPDevsFoundListener = AddOnDPDevicesFoundListener(env,
870 GetDirectPairedCallback getDirectPairedCallback =
871 [onDPDevsFoundListener](PairedDevices pairingDevList)
873 onDPDevsFoundListener->directPairingDevicesCallback(pairingDevList,
874 DPFunc::FIND_DIRECT_PAIRED_DEV_LIST);
879 OCStackResult result = OCPlatform::findDirectPairingDevices(jTimeout,
880 getDirectPairedCallback);
881 if (OC_STACK_OK != result)
883 ThrowOcException(result, "OCPlatform::findDirectPairingDevices has failed");
887 catch (OCException& e)
889 LOGE("%s", e.reason().c_str());
890 ThrowOcException(e.code(), e.reason().c_str());
895 * Class: org_iotivity_base_OcPlatform
896 * Method: getDirectPairedDevices
897 * Signature: (Lorg/iotivity/base/OcDirectPairDevice/GetDirectPairedListener;)V
899 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDirectPairedDevices
900 (JNIEnv *env, jclass jclazz, jobject jListener)
902 LOGD("OcPlatform_getDirectPairedDevices");
906 ThrowOcException(OC_STACK_INVALID_PARAM, "getPairedDevList Callback cannot be null");
909 JniOnDPDevicesFoundListener *onGetPairedDevicesListener = AddOnDPDevicesFoundListener(env,
912 GetDirectPairedCallback getDirectPairedCallback =
913 [onGetPairedDevicesListener](PairedDevices pairedDevList)
915 onGetPairedDevicesListener->directPairingDevicesCallback(pairedDevList,
916 DPFunc::GET_PAIRED_DEV_LIST);
921 OCStackResult result = OCPlatform::getDirectPairedDevices(getDirectPairedCallback);
922 if (OC_STACK_OK != result)
924 ThrowOcException(result, "OcDirectPairDevice_getDirectPairedDevices");
928 catch (OCException& e)
930 LOGE("%s", e.reason().c_str());
931 ThrowOcException(e.code(), e.reason().c_str());
936 * Class: org_iotivity_base_OcPlatform
937 * Method: doDirectPairing
938 * Signature: (Lorg/iotivity/base/OcDirectPairDevice;Lorg/iotivity/base/OcPrmType;
939 * Ljava/lang/String;Lorg/iotivity/base/OcDirectPairDevice/DirectPairingListener;)V
941 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_doDirectPairing0
942 (JNIEnv *env, jclass clazz, jobject jpeer, jint jprmType, jstring jpin, jobject jListener)
944 LOGD("OcPlatform_doDirectPairing");
948 ThrowOcException(OC_STACK_INVALID_PARAM, "doDirectPairing Callback cannot be null");
953 ThrowOcException(OC_STACK_INVALID_PARAM, "Peer cannot be null");
957 JniOnDirectPairingListener *onDirectPairingListener = AddOnDirectPairingListener(env,
960 DirectPairingCallback DirectPairingCB =
961 [onDirectPairingListener](std::shared_ptr<OCDirectPairing> dpDev, OCStackResult result)
963 onDirectPairingListener->doDirectPairingCB(dpDev, result);
966 JniOcDirectPairDevice *dev = JniOcDirectPairDevice::getJniOcDirectPairDevicePtr(env, jpeer);
972 std::string pin = env->GetStringUTFChars(jpin, 0);
976 OCStackResult result = OCPlatform::doDirectPairing(dev->getPtr(), (OCPrm_t)jprmType,
977 pin, DirectPairingCB);
978 if (OC_STACK_OK != result)
980 ThrowOcException(result, "OcPlatform_oDirectPairing");
984 catch (OCException& e)
986 LOGE("%s", e.reason().c_str());
987 ThrowOcException(e.code(), e.reason().c_str());
992 * Class: org_iotivity_base_OcPlatform
993 * Method: getDeviceInfo0
994 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeviceFoundListener;)V
996 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDeviceInfo0(
1000 jstring jResourceUri,
1001 jint jConnectivityType,
1004 LOGD("OcPlatform_getDeviceInfo0");
1008 host = env->GetStringUTFChars(jHost, nullptr);
1010 std::string resourceUri;
1013 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1017 ThrowOcException(OC_STACK_INVALID_PARAM, "onDeviceFoundListener cannot be null");
1020 JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
1022 FindDeviceCallback findDeviceCallback =
1023 [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
1025 onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
1030 OCStackResult result = OCPlatform::getDeviceInfo(
1033 static_cast<OCConnectivityType>(jConnectivityType),
1034 findDeviceCallback);
1036 if (OC_STACK_OK != result)
1038 ThrowOcException(result, "Find device has failed");
1041 catch (OCException& e)
1043 LOGE("%s", e.reason().c_str());
1044 ThrowOcException(e.code(), e.reason().c_str());
1049 * Class: org_iotivity_base_OcPlatform
1050 * Method: getDeviceInfo1
1051 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeviceFoundListener;I)V
1053 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDeviceInfo1(
1057 jstring jResourceUri,
1058 jint jConnectivityType,
1062 LOGD("OcPlatform_getDeviceInfo1");
1066 host = env->GetStringUTFChars(jHost, nullptr);
1068 std::string resourceUri;
1071 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1075 ThrowOcException(OC_STACK_INVALID_PARAM, "onDeviceFoundListener cannot be null");
1078 JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
1080 FindDeviceCallback findDeviceCallback =
1081 [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
1083 onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
1088 OCStackResult result = OCPlatform::getDeviceInfo(
1091 static_cast<OCConnectivityType>(jConnectivityType),
1093 JniUtils::getQOS(env, static_cast<int>(jQoS)));
1095 if (OC_STACK_OK != result)
1097 ThrowOcException(result, "Find device has failed");
1100 catch (OCException& e)
1102 LOGE("%s", e.reason().c_str());
1103 ThrowOcException(e.code(), e.reason().c_str());
1108 * Class: org_iotivity_base_OcPlatform
1109 * Method: getPlatformInfo0
1110 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPlatformFoundListener;)V
1112 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getPlatformInfo0(
1116 jstring jResourceUri,
1117 jint jConnectivityType,
1120 LOGD("OcPlatform_getPlatformInfo0");
1124 host = env->GetStringUTFChars(jHost, nullptr);
1126 std::string resourceUri;
1129 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1133 ThrowOcException(OC_STACK_INVALID_PARAM, "onPlatformFoundListener cannot be null");
1136 JniOnPlatformInfoListener *onPlatformInfoListener = AddOnPlatformInfoListener(env, jListener);
1138 FindPlatformCallback findPlatformCallback =
1139 [onPlatformInfoListener](const OCRepresentation& ocRepresentation)
1141 onPlatformInfoListener->foundPlatformCallback(ocRepresentation);
1146 OCStackResult result = OCPlatform::getPlatformInfo(
1149 static_cast<OCConnectivityType>(jConnectivityType),
1150 findPlatformCallback);
1152 if (OC_STACK_OK != result)
1154 ThrowOcException(result, "Find platform has failed");
1157 catch (OCException& e)
1159 LOGE("%s", e.reason().c_str());
1160 ThrowOcException(e.code(), e.reason().c_str());
1165 * Class: org_iotivity_base_OcPlatform
1166 * Method: getPlatformInfo1
1167 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPlatformFoundListener;I)V
1169 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getPlatformInfo1(
1173 jstring jResourceUri,
1174 jint jConnectivityType,
1178 LOGD("OcPlatform_getPlatformInfo1");
1182 host = env->GetStringUTFChars(jHost, nullptr);
1184 std::string resourceUri;
1187 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1191 ThrowOcException(OC_STACK_INVALID_PARAM, "onPlatformFoundListener cannot be null");
1194 JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
1196 FindDeviceCallback findDeviceCallback =
1197 [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
1199 onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
1204 OCStackResult result = OCPlatform::getPlatformInfo(
1207 static_cast<OCConnectivityType>(jConnectivityType),
1209 JniUtils::getQOS(env, static_cast<int>(jQoS)));
1211 if (OC_STACK_OK != result)
1213 ThrowOcException(result, "Find platform has failed");
1216 catch (OCException& e)
1218 LOGE("%s", e.reason().c_str());
1219 ThrowOcException(e.code(), e.reason().c_str());
1224 * Class: org_iotivity_base_OcPlatform
1225 * Method: registerResource0
1226 * Signature: (Lorg/iotivity/base/OcResource;)Lorg/iotivity/base/OcResourceHandle;
1228 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_registerResource0(
1229 JNIEnv *env, jclass clazz, jobject jResource)
1231 LOGD("OcPlatform_registerResource");
1234 ThrowOcException(OC_STACK_INVALID_PARAM, "Resource cannot be null");
1237 JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, jResource);
1243 OCResourceHandle resourceHandle;
1246 OCStackResult result = OCPlatform::registerResource(
1248 resource->getOCResource());
1250 if (OC_STACK_OK != result)
1252 ThrowOcException(result, "register resource");
1255 catch (OCException& e)
1257 LOGE("%s", e.reason().c_str());
1258 ThrowOcException(e.code(), e.reason().c_str());
1261 JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);
1262 jlong handle = reinterpret_cast<jlong>(jniHandle);
1263 jobject jResourceHandle =
1264 env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);
1266 if (!jResourceHandle)
1268 LOGE("Failed to create OcResourceHandle");
1271 return jResourceHandle;
1275 * Class: org_iotivity_base_OcPlatform
1276 * Method: registerResource1
1277 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcPlatform/EntityHandler;I)Lorg/iotivity/base/OcResourceHandle;
1279 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_registerResource1(
1282 jstring jResourceUri,
1283 jstring jResourceTypeName,
1284 jstring jResourceInterface,
1285 jobject jListener, jint jResourceProperty)
1287 LOGI("OcPlatform_registerResource1");
1288 std::string resourceUri;
1291 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1293 std::string resourceTypeName;
1294 if (jResourceTypeName)
1296 resourceTypeName = env->GetStringUTFChars(jResourceTypeName, nullptr);
1298 std::string resourceInterface;
1299 if (jResourceInterface)
1301 resourceInterface = env->GetStringUTFChars(jResourceInterface, nullptr);
1303 JniEntityHandler* entityHandler = NULL;
1304 EntityHandler handleEntityCallback = NULL;
1307 entityHandler = new JniEntityHandler(env, jListener);
1308 handleEntityCallback =
1309 [entityHandler](const std::shared_ptr<OCResourceRequest> request) -> OCEntityHandlerResult
1311 return entityHandler->handleEntity(request);
1315 OCResourceHandle resourceHandle;
1318 OCStackResult result = OCPlatform::registerResource(
1323 handleEntityCallback,
1324 static_cast<int>(jResourceProperty));
1326 if (OC_STACK_OK != result)
1328 delete entityHandler;
1329 ThrowOcException(result, "register resource");
1333 catch (OCException& e)
1335 LOGE("%s", e.reason().c_str());
1336 delete entityHandler;
1337 ThrowOcException(e.code(), e.reason().c_str());
1341 JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);
1342 jlong handle = reinterpret_cast<jlong>(jniHandle);
1343 jobject jResourceHandle =
1344 env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);
1345 if (!jResourceHandle)
1347 LOGE("Failed to create OcResourceHandle");
1351 return jResourceHandle;
1355 * Class: org_iotivity_base_OcPlatform
1356 * Method: registerDeviceInfo0
1357 * 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
1359 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_registerDeviceInfo0(
1362 jstring jDeviceName,
1363 jobjectArray jDeviceTypes)
1365 LOGI("OcPlatform_registerDeviceInfo");
1369 ThrowOcException(OC_STACK_INVALID_PARAM, "deviceName cannot be null");
1375 ThrowOcException(OC_STACK_INVALID_PARAM, "deviceTypes cannot be null");
1379 OCDeviceInfo deviceInfo;
1382 DuplicateString(&deviceInfo.deviceName, env->GetStringUTFChars(jDeviceName, nullptr));
1383 deviceInfo.types = NULL;
1385 jsize len = env->GetArrayLength(jDeviceTypes);
1386 for (jsize i = 0; i < len; ++i)
1388 jstring jStr = (jstring)env->GetObjectArrayElement(jDeviceTypes, i);
1391 delete deviceInfo.deviceName;
1392 ThrowOcException(OC_STACK_INVALID_PARAM, "device type cannot be null");
1396 OCResourcePayloadAddStringLL(&deviceInfo.types, env->GetStringUTFChars(jStr, nullptr));
1397 if (env->ExceptionCheck())
1399 delete deviceInfo.deviceName;
1403 env->DeleteLocalRef(jStr);
1406 catch (std::exception &e)
1408 ThrowOcException(JNI_EXCEPTION, "Failed to construct device info");
1414 OCStackResult result = OCPlatform::registerDeviceInfo(deviceInfo);
1416 delete deviceInfo.deviceName;
1418 if (OC_STACK_OK != result)
1420 ThrowOcException(result, "Failed to register device info");
1424 catch (OCException& e)
1426 LOGE("%s", e.reason().c_str());
1427 ThrowOcException(e.code(), e.reason().c_str());
1432 * Class: org_iotivity_base_OcPlatform
1433 * Method: registerPlatformInfo0
1434 * 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
1436 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_registerPlatformInfo0(
1439 jstring jPlatformID,
1440 jstring jManufacturerName,
1441 jstring jManufacturerUrl,
1442 jstring jModelNumber,
1443 jstring jDateOfManufacture,
1444 jstring jPlatformVersion,
1445 jstring jOperatingSystemVersion,
1446 jstring jHardwareVersion,
1447 jstring jFirmwareVersion,
1448 jstring jSupportUrl,
1449 jstring jSystemTime)
1451 LOGI("OcPlatform_registerPlatformInfo");
1454 std::string platformID;
1455 std::string manufacturerName;
1456 std::string manufacturerUrl;
1457 std::string modelNumber;
1458 std::string dateOfManufacture;
1459 std::string platformVersion;
1460 std::string operatingSystemVersion;
1461 std::string hardwareVersion;
1462 std::string firmwareVersion;
1463 std::string supportUrl;
1464 std::string systemTime;
1468 platformID = env->GetStringUTFChars(jPlatformID, nullptr);
1470 if (jManufacturerName)
1472 manufacturerName = env->GetStringUTFChars(jManufacturerName, nullptr);
1474 if (jManufacturerUrl)
1476 manufacturerUrl = env->GetStringUTFChars(jManufacturerUrl, nullptr);
1480 modelNumber = env->GetStringUTFChars(jModelNumber, nullptr);
1482 if (jDateOfManufacture)
1484 dateOfManufacture = env->GetStringUTFChars(jDateOfManufacture, nullptr);
1486 if (jPlatformVersion)
1488 platformVersion = env->GetStringUTFChars(jPlatformVersion, nullptr);
1490 if (jOperatingSystemVersion)
1492 operatingSystemVersion = env->GetStringUTFChars(jOperatingSystemVersion, nullptr);
1494 if (jHardwareVersion)
1496 hardwareVersion = env->GetStringUTFChars(jHardwareVersion, nullptr);
1498 if (jFirmwareVersion)
1500 firmwareVersion = env->GetStringUTFChars(jFirmwareVersion, nullptr);
1504 supportUrl = env->GetStringUTFChars(jSupportUrl, nullptr);
1508 systemTime = env->GetStringUTFChars(jSystemTime, nullptr);
1511 OCPlatformInfo platformInfo;
1514 DuplicateString(&platformInfo.platformID, platformID);
1515 DuplicateString(&platformInfo.manufacturerName, manufacturerName);
1516 DuplicateString(&platformInfo.manufacturerUrl, manufacturerUrl);
1517 DuplicateString(&platformInfo.modelNumber, modelNumber);
1518 DuplicateString(&platformInfo.dateOfManufacture, dateOfManufacture);
1519 DuplicateString(&platformInfo.platformVersion, platformVersion);
1520 DuplicateString(&platformInfo.operatingSystemVersion, operatingSystemVersion);
1521 DuplicateString(&platformInfo.hardwareVersion, hardwareVersion);
1522 DuplicateString(&platformInfo.firmwareVersion, firmwareVersion);
1523 DuplicateString(&platformInfo.supportUrl, supportUrl);
1524 DuplicateString(&platformInfo.systemTime, systemTime);
1526 catch (std::exception &e)
1528 ThrowOcException(JNI_EXCEPTION, "Failed to construct platform info");
1532 // __android_log_print(ANDROID_LOG_INFO, "Rahul", "platformID = %s", platformID);
1535 OCStackResult result = OCPlatform::registerPlatformInfo(platformInfo);
1537 delete platformInfo.platformID;
1538 delete platformInfo.manufacturerName;
1539 delete platformInfo.manufacturerUrl;
1540 delete platformInfo.modelNumber;
1541 delete platformInfo.dateOfManufacture;
1542 delete platformInfo.platformVersion;
1543 delete platformInfo.operatingSystemVersion;
1544 delete platformInfo.hardwareVersion;
1545 delete platformInfo.firmwareVersion;
1546 delete platformInfo.supportUrl;
1547 delete platformInfo.systemTime;
1549 if (OC_STACK_OK != result)
1551 ThrowOcException(result, "Failed to register platform info");
1555 catch (OCException& e)
1557 LOGE("Error is due to %s", e.reason().c_str());
1558 ThrowOcException(e.code(), e.reason().c_str());
1563 * Class: org_iotivity_base_OcPlatform
1564 * Method: unregisterResource0
1565 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V
1567 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unregisterResource0(
1568 JNIEnv *env, jclass clazz, jobject jResourceHandle)
1570 LOGI("OcPlatform_unregisterResource");
1571 if (!jResourceHandle)
1573 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1576 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1577 env, jResourceHandle);
1578 if (!jniOcResourceHandle)
1585 OCResourceHandle resHandle = jniOcResourceHandle->getOCResourceHandle();
1586 OCStackResult result = OCPlatform::unregisterResource(resHandle);
1587 if (OC_STACK_OK != result)
1589 ThrowOcException(result, "Failed to unregister resource");
1592 catch (OCException& e)
1594 LOGE("%s", e.reason().c_str());
1595 ThrowOcException(e.code(), e.reason().c_str());
1600 * Class: org_iotivity_base_OcPlatform
1601 * Method: bindResource0
1602 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
1604 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResource0
1605 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobject jResourceHandle)
1607 LOGI("OcPlatform_bindResource");
1608 if (!jResourceCollectionHandle)
1610 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1613 if (!jResourceHandle)
1615 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1618 JniOcResourceHandle* jniOcResourceCollectionHandle =
1619 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1620 if (!jniOcResourceCollectionHandle)
1625 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1626 env, jResourceHandle);
1627 if (!jniOcResourceHandle)
1634 OCStackResult result = OCPlatform::bindResource(
1635 jniOcResourceCollectionHandle->getOCResourceHandle(),
1636 jniOcResourceHandle->getOCResourceHandle()
1639 if (OC_STACK_OK != result)
1641 ThrowOcException(result, "Failed to bind resource");
1644 catch (OCException& e)
1646 LOGE("%s", e.reason().c_str());
1647 ThrowOcException(e.code(), e.reason().c_str());
1652 * Class: org_iotivity_base_OcPlatform
1653 * Method: bindResources0
1654 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
1656 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResources0(
1659 jobject jResourceCollectionHandle,
1660 jobjectArray jResourceHandleArray)
1662 LOGI("OcPlatform_bindResources");
1664 if (!jResourceCollectionHandle)
1666 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1669 if (!jResourceHandleArray)
1671 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
1675 JniOcResourceHandle* jniOcResourceCollectionHandle =
1676 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1677 if (!jniOcResourceCollectionHandle)
1682 std::vector<OCResourceHandle> resourceHandleList;
1683 int len = env->GetArrayLength(jResourceHandleArray);
1684 for (int i = 0; i < len; ++i)
1686 jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
1687 if (!jResourceHandle)
1689 ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
1693 JniOcResourceHandle* jniOcResourceHandle =
1694 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1695 if (!jniOcResourceHandle)
1700 resourceHandleList.push_back(
1701 jniOcResourceHandle->getOCResourceHandle());
1706 OCStackResult result = OCPlatform::bindResources(
1707 jniOcResourceCollectionHandle->getOCResourceHandle(),
1711 if (OC_STACK_OK != result)
1713 ThrowOcException(result, "Failed to bind resources");
1716 catch (OCException& e)
1718 LOGE("%s", e.reason().c_str());
1719 ThrowOcException(e.code(), e.reason().c_str());
1724 * Class: org_iotivity_base_OcPlatform
1725 * Method: unbindResource0
1726 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
1728 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResource0(
1731 jobject jResourceCollectionHandle,
1732 jobject jResourceHandle)
1734 LOGI("OcPlatform_unbindResource");
1735 if (!jResourceCollectionHandle)
1737 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1740 if (!jResourceHandle)
1742 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1746 JniOcResourceHandle* jniOcResourceCollectionHandle =
1747 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1748 if (!jniOcResourceCollectionHandle)
1753 JniOcResourceHandle* jniOcResourceHandle =
1754 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1755 if (!jniOcResourceHandle)
1762 OCStackResult result = OCPlatform::unbindResource(
1763 jniOcResourceCollectionHandle->getOCResourceHandle(),
1764 jniOcResourceHandle->getOCResourceHandle());
1766 if (OC_STACK_OK != result)
1768 ThrowOcException(result, "Failed to unbind resource");
1771 catch (OCException& e)
1773 LOGE("%s", e.reason().c_str());
1774 ThrowOcException(e.code(), e.reason().c_str());
1779 * Class: org_iotivity_base_OcPlatform
1780 * Method: unbindResources0
1781 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
1783 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResources0(
1786 jobject jResourceCollectionHandle,
1787 jobjectArray jResourceHandleArray)
1789 LOGI("OcPlatform_unbindResources");
1790 if (!jResourceCollectionHandle)
1792 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1795 if (!jResourceHandleArray)
1797 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
1801 JniOcResourceHandle* jniOcResourceCollectionHandle =
1802 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1803 if (!jniOcResourceCollectionHandle)
1808 std::vector<OCResourceHandle> resourceHandleList;
1809 int len = env->GetArrayLength(jResourceHandleArray);
1810 for (int i = 0; i < len; ++i)
1812 jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
1813 if (!jResourceHandle)
1815 ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
1819 JniOcResourceHandle* jniOcResourceHandle =
1820 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1821 if (!jniOcResourceHandle)
1826 resourceHandleList.push_back(
1827 jniOcResourceHandle->getOCResourceHandle());
1832 OCStackResult result = OCPlatform::unbindResources(
1833 jniOcResourceCollectionHandle->getOCResourceHandle(),
1837 if (OC_STACK_OK != result)
1839 ThrowOcException(result, "Failed to unbind resources");
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: bindTypeToResource0
1852 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
1854 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindTypeToResource0(
1857 jobject jResourceHandle,
1858 jstring jResourceTypeName)
1860 LOGI("OcPlatform_bindTypeToResource");
1861 if (!jResourceHandle)
1863 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1866 std::string typeName;
1867 if (jResourceTypeName)
1869 typeName = env->GetStringUTFChars(jResourceTypeName, nullptr);
1872 JniOcResourceHandle* jniOcResourceHandle =
1873 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1874 if (!jniOcResourceHandle)
1881 OCStackResult result = OCPlatform::bindTypeToResource(
1882 jniOcResourceHandle->getOCResourceHandle(),
1886 if (OC_STACK_OK != result)
1888 ThrowOcException(result, "Failed to bind type to resource");
1891 catch (OCException& e)
1893 LOGE("%s", e.reason().c_str());
1894 ThrowOcException(e.code(), e.reason().c_str());
1899 * Class: org_iotivity_base_OcPlatform
1900 * Method: bindInterfaceToResource0
1901 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
1903 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindInterfaceToResource0
1904 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jstring jResourceInterfaceName)
1906 LOGI("OcPlatform_bindInterfaceToResource");
1907 if (!jResourceHandle)
1909 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1912 std::string interfaceName;
1913 if (jResourceInterfaceName)
1915 interfaceName = env->GetStringUTFChars(jResourceInterfaceName, nullptr);
1918 JniOcResourceHandle* jniOcResourceHandle =
1919 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1920 if (!jniOcResourceHandle)
1927 OCStackResult result = OCPlatform::bindInterfaceToResource(
1928 jniOcResourceHandle->getOCResourceHandle(),
1932 if (OC_STACK_OK != result)
1934 ThrowOcException(result, "Failed to bind interface to resource");
1937 catch (OCException& e)
1939 LOGE("%s", e.reason().c_str());
1940 ThrowOcException(e.code(), e.reason().c_str());
1945 * Class: org_iotivity_base_OcPlatform
1946 * Method: startPresence0
1949 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_startPresence0(
1950 JNIEnv *env, jclass clazz, jint ttl)
1952 LOGI("OcPlatform_startPresence");
1956 OCStackResult result = OCPlatform::startPresence((unsigned int)ttl);
1958 if (OC_STACK_OK != result)
1960 ThrowOcException(result, "Failed to start presence");
1963 catch (OCException& e)
1965 LOGE("%s", e.reason().c_str());
1966 ThrowOcException(e.code(), e.reason().c_str());
1971 * Class: org_iotivity_base_OcPlatform
1972 * Method: stopPresence0
1975 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_stopPresence0(
1976 JNIEnv *env, jclass clazz)
1978 LOGI("OcPlatform_stopPresence");
1982 OCStackResult result = OCPlatform::stopPresence();
1984 if (OC_STACK_OK != result)
1986 ThrowOcException(result, "Failed to stop presence");
1989 catch (OCException& e)
1991 LOGE("%s", e.reason().c_str());
1992 ThrowOcException(e.code(), e.reason().c_str());
1997 * Class: org_iotivity_base_OcPlatform
1998 * Method: subscribePresence0
1999 * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
2001 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence0(
2005 jint jConnectivityType,
2008 LOGD("OcPlatform_subscribePresence");
2012 host = env->GetStringUTFChars(jHost, nullptr);
2016 ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
2020 JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
2022 SubscribeCallback subscribeCallback =
2023 [onPresenceListener](OCStackResult result,
2024 const unsigned int nonce,
2025 const std::string& hostAddress)
2027 onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
2030 OCPlatform::OCPresenceHandle presenceHandle;
2033 OCStackResult result = OCPlatform::subscribePresence(
2036 static_cast<OCConnectivityType>(jConnectivityType),
2039 if (OC_STACK_OK != result)
2041 ThrowOcException(result, "subscribe presence has failed");
2044 catch (OCException& e)
2046 LOGE("%s", e.reason().c_str());
2047 ThrowOcException(e.code(), e.reason().c_str());
2051 JniOcPresenceHandle* jniPresenceHandle =
2052 new JniOcPresenceHandle(onPresenceListener, presenceHandle);
2053 jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
2054 jobject jPresenceHandle =
2055 env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
2056 if (!jPresenceHandle)
2058 LOGE("Failed to create OcPresenceHandle");
2059 delete jniPresenceHandle;
2061 return jPresenceHandle;
2065 * Class: org_iotivity_base_OcPlatform
2066 * Method: subscribePresence1
2067 * Signature: (Ljava/lang/String;Ljava/lang/String;I
2068 Lorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
2070 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence1(
2074 jstring jResourceType,
2075 jint jConnectivityType,
2078 LOGD("OcPlatform_subscribePresence1");
2082 host = env->GetStringUTFChars(jHost, nullptr);
2084 std::string resourceType;
2087 resourceType = env->GetStringUTFChars(jResourceType, nullptr);
2091 ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
2095 JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
2097 SubscribeCallback subscribeCallback = [onPresenceListener](OCStackResult result,
2098 const unsigned int nonce, const std::string& hostAddress)
2100 onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
2103 OCPlatform::OCPresenceHandle presenceHandle;
2106 OCStackResult result = OCPlatform::subscribePresence(
2110 static_cast<OCConnectivityType>(jConnectivityType),
2113 if (OC_STACK_OK != result)
2115 ThrowOcException(result, "subscribe presence has failed");
2118 catch (OCException& e)
2120 LOGE("%s", e.reason().c_str());
2121 ThrowOcException(e.code(), e.reason().c_str());
2125 JniOcPresenceHandle* jniPresenceHandle =
2126 new JniOcPresenceHandle(onPresenceListener, presenceHandle);
2127 jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
2128 jobject jPresenceHandle =
2129 env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
2130 if (!jPresenceHandle)
2132 LOGE("Failed to create OcPresenceHandle");
2133 delete jniPresenceHandle;
2135 return jPresenceHandle;
2139 * Class: org_iotivity_base_OcPlatform
2140 * Method: unsubscribePresence0
2141 * Signature: (Lorg/iotivity/base/OcPresenceHandle;)V
2143 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unsubscribePresence0(
2144 JNIEnv *env, jclass clazz, jobject jPresenceHandle)
2146 LOGD("OcPlatform_unsubscribePresence");
2147 if (!jPresenceHandle)
2149 ThrowOcException(OC_STACK_INVALID_PARAM, "presenceHandle cannot be null");
2152 JniOcPresenceHandle* jniPresenceHandle =
2153 JniOcPresenceHandle::getJniOcPresenceHandlePtr(env, jPresenceHandle);
2154 if (!jniPresenceHandle)
2159 OCPresenceHandle presenceHandle = jniPresenceHandle->getOCPresenceHandle();
2163 OCStackResult result = OCPlatform::unsubscribePresence(presenceHandle);
2165 if (OC_STACK_OK != result)
2167 ThrowOcException(result, "unsubscribe presence has failed");
2170 jweak jwOnPresenceListener =
2171 jniPresenceHandle->getJniOnPresenceListener()->getJWListener();
2172 if (jwOnPresenceListener)
2174 RemoveOnPresenceListener(env, jwOnPresenceListener);
2177 catch (OCException& e)
2179 LOGE("%s", e.reason().c_str());
2180 ThrowOcException(e.code(), e.reason().c_str());
2185 * Class: org_iotivity_base_OcPlatform
2186 * Method: constructResourceObject0
2187 * Signature: (Ljava/lang/String;Ljava/lang/String;IZ[Ljava/lang/String;[Ljava/lang/String;)
2188 Lorg/iotivity/base/OcResource;
2190 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_constructResourceObject0(
2195 jint jConnectivityType,
2196 jboolean jIsObservable,
2197 jobjectArray jResourceTypeArray,
2198 jobjectArray jInterfaceArray)
2200 LOGD("OcPlatform_constructResourceObject");
2204 host = env->GetStringUTFChars(jHost, nullptr);
2209 uri = env->GetStringUTFChars(jUri, nullptr);
2211 if (!jResourceTypeArray)
2213 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceTypeList cannot be null");
2216 if (!jInterfaceArray)
2218 ThrowOcException(OC_STACK_INVALID_PARAM, "interfaceList cannot be null");
2222 std::vector<std::string> resourceTypes;
2223 JniUtils::convertJavaStrArrToStrVector(env, jResourceTypeArray, resourceTypes);
2225 std::vector<std::string> interfaces;
2226 JniUtils::convertJavaStrArrToStrVector(env, jInterfaceArray, interfaces);
2228 std::shared_ptr<OCResource> resource = OCPlatform::constructResourceObject(
2231 static_cast<OCConnectivityType>(jConnectivityType),
2232 static_cast<bool>(jIsObservable),
2238 ThrowOcException(OC_STACK_ERROR, "Failed to create OCResource");
2242 JniOcResource *jniOcResource = new JniOcResource(resource);
2243 jlong handle = reinterpret_cast<jlong>(jniOcResource);
2245 jobject jResource = env->NewObject(g_cls_OcResource, g_mid_OcResource_ctor);
2248 delete jniOcResource;
2251 SetHandle<JniOcResource>(env, jResource, jniOcResource);
2252 if (env->ExceptionCheck())
2254 delete jniOcResource;
2261 * Class: org_iotivity_base_OcPlatform
2262 * Method: sendResponse0
2263 * Signature: (Lorg/iotivity/base/OcResourceResponse;)V
2265 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_sendResponse0(
2266 JNIEnv *env, jclass clazz, jobject jResourceResponse)
2268 LOGD("OcPlatform_sendResponse");
2269 if (!jResourceResponse)
2271 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
2275 JniOcResourceResponse *jniResponse =
2276 JniOcResourceResponse::getJniOcResourceResponsePtr(env, jResourceResponse);
2284 OCStackResult result =
2285 OCPlatform::sendResponse(jniResponse->getOCResourceResponse());
2287 if (OC_STACK_OK != result)
2289 ThrowOcException(result, "failed to send response");
2292 catch (OCException& e)
2294 LOGE("%s", e.reason().c_str());
2295 ThrowOcException(e.code(), e.reason().c_str());