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"
32 JniOnResourceFoundListener* AddOnResourceFoundListener(JNIEnv* env, jobject jListener)
34 JniOnResourceFoundListener *onResourceFoundListener = nullptr;
36 resourceFoundMapLock.lock();
38 for (auto it = onResourceFoundListenerMap.begin();
39 it != onResourceFoundListenerMap.end();
42 if (env->IsSameObject(jListener, it->first))
44 auto refPair = it->second;
45 onResourceFoundListener = refPair.first;
48 onResourceFoundListenerMap.insert(*it);
49 LOGD("OnResourceFoundListener: ref. count incremented");
54 if (!onResourceFoundListener)
56 onResourceFoundListener =
57 new JniOnResourceFoundListener(env, jListener, RemoveOnResourceFoundListener);
58 jobject jgListener = env->NewGlobalRef(jListener);
60 onResourceFoundListenerMap.insert(
62 std::pair<JniOnResourceFoundListener*, int >>(
64 std::pair<JniOnResourceFoundListener*, int>(onResourceFoundListener,
66 LOGD("OnResourceFoundListener: new listener");
68 resourceFoundMapLock.unlock();
69 return onResourceFoundListener;
72 void RemoveOnResourceFoundListener(JNIEnv* env, jobject jListener)
74 resourceFoundMapLock.lock();
76 for (auto it = onResourceFoundListenerMap.begin();
77 it != onResourceFoundListenerMap.end();
80 if (env->IsSameObject(jListener, it->first))
82 auto refPair = it->second;
83 if (refPair.second > 1)
87 onResourceFoundListenerMap.insert(*it);
88 LOGI("OnResourceFoundListener: ref. count decremented");
92 env->DeleteGlobalRef(it->first);
93 JniOnResourceFoundListener* listener = refPair.first;
95 onResourceFoundListenerMap.erase(it);
96 LOGI("OnResourceFoundListener removed");
101 resourceFoundMapLock.unlock();
104 JniOnDeviceInfoListener* AddOnDeviceInfoListener(JNIEnv* env, jobject jListener)
106 JniOnDeviceInfoListener *onDeviceInfoListener = nullptr;
108 deviceInfoMapLock.lock();
110 for (auto it = onDeviceInfoListenerMap.begin(); it != onDeviceInfoListenerMap.end(); ++it)
112 if (env->IsSameObject(jListener, it->first))
114 auto refPair = it->second;
115 onDeviceInfoListener = refPair.first;
117 it->second = refPair;
118 onDeviceInfoListenerMap.insert(*it);
119 LOGD("OnDeviceInfoListener: ref. count incremented");
124 if (!onDeviceInfoListener)
126 onDeviceInfoListener =
127 new JniOnDeviceInfoListener(env, jListener, RemoveOnDeviceInfoListener);
128 jobject jgListener = env->NewGlobalRef(jListener);
130 onDeviceInfoListenerMap.insert(
132 std::pair<JniOnDeviceInfoListener*, int>>(
134 std::pair<JniOnDeviceInfoListener*, int>(onDeviceInfoListener, 1)));
135 LOGI("OnDeviceInfoListener: new listener");
138 deviceInfoMapLock.unlock();
139 return onDeviceInfoListener;
142 void RemoveOnDeviceInfoListener(JNIEnv* env, jobject jListener)
144 deviceInfoMapLock.lock();
145 bool isFound = false;
146 for (auto it = onDeviceInfoListenerMap.begin(); it != onDeviceInfoListenerMap.end(); ++it)
148 if (env->IsSameObject(jListener, it->first))
150 auto refPair = it->second;
151 if (refPair.second > 1)
154 it->second = refPair;
155 onDeviceInfoListenerMap.insert(*it);
156 LOGI("OnDeviceInfoListener: ref. count decremented");
160 env->DeleteGlobalRef(it->first);
161 JniOnDeviceInfoListener* listener = refPair.first;
163 onDeviceInfoListenerMap.erase(it);
165 LOGI("OnDeviceInfoListener removed");
175 ThrowOcException(JNI_EXCEPTION, "OnDeviceInfoListenet not found");
177 deviceInfoMapLock.unlock();
180 JniOnPlatformInfoListener* AddOnPlatformInfoListener(JNIEnv* env, jobject jListener)
182 JniOnPlatformInfoListener *onPlatformInfoListener = nullptr;
184 platformInfoMapLock.lock();
186 for (auto it = onPlatformInfoListenerMap.begin(); it != onPlatformInfoListenerMap.end(); ++it)
188 if (env->IsSameObject(jListener, it->first))
190 auto refPair = it->second;
191 onPlatformInfoListener = refPair.first;
193 it->second = refPair;
194 onPlatformInfoListenerMap.insert(*it);
195 LOGD("OnPlatformInfoListener: ref. count incremented");
200 if (!onPlatformInfoListener)
202 onPlatformInfoListener =
203 new JniOnPlatformInfoListener(env, jListener, RemoveOnPlatformInfoListener);
204 jobject jgListener = env->NewGlobalRef(jListener);
206 onPlatformInfoListenerMap.insert(
207 std::pair<jobject, std::pair<JniOnPlatformInfoListener*, int>>(
209 std::pair<JniOnPlatformInfoListener*, int>(onPlatformInfoListener, 1)));
210 LOGI("OnPlatformInfoListener: new listener");
213 platformInfoMapLock.unlock();
214 return onPlatformInfoListener;
217 void RemoveOnPlatformInfoListener(JNIEnv* env, jobject jListener)
219 platformInfoMapLock.lock();
220 bool isFound = false;
221 for (auto it = onPlatformInfoListenerMap.begin(); it != onPlatformInfoListenerMap.end(); ++it)
223 if (env->IsSameObject(jListener, it->first))
225 auto refPair = it->second;
226 if (refPair.second > 1)
229 it->second = refPair;
230 onPlatformInfoListenerMap.insert(*it);
231 LOGI("OnPlatformInfoListener: ref. count decremented");
235 env->DeleteGlobalRef(it->first);
236 JniOnPlatformInfoListener* listener = refPair.first;
238 onPlatformInfoListenerMap.erase(it);
240 LOGI("OnPlatformInfoListener removed");
250 ThrowOcException(JNI_EXCEPTION, "OnPlatformInfoListenet not found");
252 platformInfoMapLock.unlock();
255 JniOnPresenceListener* AddOnPresenceListener(JNIEnv* env, jobject jListener)
257 JniOnPresenceListener *onPresenceListener = nullptr;
259 presenceMapLock.lock();
261 for (auto it = onPresenceListenerMap.begin(); it != onPresenceListenerMap.end(); ++it)
263 if (env->IsSameObject(jListener, it->first))
265 auto refPair = it->second;
266 onPresenceListener = refPair.first;
268 it->second = refPair;
269 onPresenceListenerMap.insert(*it);
270 LOGD("OnPresenceListener: ref. count incremented");
274 if (!onPresenceListener)
276 onPresenceListener = new JniOnPresenceListener(env, jListener, RemoveOnPresenceListener);
277 jobject jgListener = env->NewGlobalRef(jListener);
278 onPresenceListenerMap.insert(
279 std::pair<jobject, std::pair<JniOnPresenceListener*, int>>(
281 std::pair<JniOnPresenceListener*, int>(onPresenceListener, 1)));
282 LOGI("OnPresenceListener: new listener");
284 presenceMapLock.unlock();
285 return onPresenceListener;
288 void RemoveOnPresenceListener(JNIEnv* env, jobject jListener)
290 presenceMapLock.lock();
291 bool isFound = false;
292 for (auto it = onPresenceListenerMap.begin(); it != onPresenceListenerMap.end(); ++it)
294 if (env->IsSameObject(jListener, it->first))
296 auto refPair = it->second;
297 if (refPair.second > 1)
300 it->second = refPair;
301 onPresenceListenerMap.insert(*it);
302 LOGI("OnPresenceListener: ref. count decremented");
306 env->DeleteGlobalRef(it->first);
307 JniOnPresenceListener* listener = refPair.first;
309 onPresenceListenerMap.erase(it);
310 LOGI("OnPresenceListener is removed");
318 ThrowOcException(JNI_EXCEPTION, "OnPresenceListener not found");
320 presenceMapLock.unlock();
324 * Class: org_iotivity_base_OcPlatform
326 * Signature: (IILjava/lang/String;II)V
328 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_configure
329 (JNIEnv *env, jclass clazz, jint jServiceType, jint jModeType, jstring jIpAddress, jint jPort,
330 jint jQOS, jstring jDbPath)
332 LOGI("OcPlatform_configure");
334 std::string ipAddress;
338 ipAddress = env->GetStringUTFChars(jIpAddress, nullptr);
342 dbfile = env->GetStringUTFChars(jDbPath, nullptr);
343 JniOcSecurity::StoreDbPath(dbfile);
348 port = static_cast<uint16_t>(jPort);
352 JniUtils::getServiceType(env, jServiceType),
353 JniUtils::getModeType(env, jModeType),
356 JniUtils::getQOS(env, static_cast<int>(jQOS)),
357 JniOcSecurity::getOCPersistentStorage()
359 OCPlatform::Configure(cfg);
363 * Class: org_iotivity_base_OcPlatform
364 * Method: notifyAllObservers0
365 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V
367 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyAllObservers0
368 (JNIEnv *env, jclass clazz, jobject jResourceHandle)
370 LOGI("OcPlatform_notifyAllObservers");
371 if (!jResourceHandle)
373 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
377 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
378 env, jResourceHandle);
379 if (!jniOcResourceHandle) return;
383 OCStackResult result =
384 OCPlatform::notifyAllObservers(jniOcResourceHandle->getOCResourceHandle());
386 if (OC_STACK_OK != result)
388 ThrowOcException(result, "Failed to notify all observers");
392 catch (OCException& e)
394 LOGE("%s", e.reason().c_str());
395 ThrowOcException(e.code(), e.reason().c_str());
400 * Class: org_iotivity_base_OcPlatform
401 * Method: notifyAllObservers1
402 * Signature: (Lorg/iotivity/base/OcResourceHandle;I)V
404 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyAllObservers1
405 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jint jQoS)
407 LOGI("OcPlatform_notifyAllObservers1");
409 if (!jResourceHandle)
411 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
415 JniOcResourceHandle* jniOcResourceHandle =
416 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
417 if (!jniOcResourceHandle)
423 OCStackResult result = OCPlatform::notifyAllObservers(
424 jniOcResourceHandle->getOCResourceHandle(),
425 JniUtils::getQOS(env, static_cast<int>(jQoS)));
427 if (OC_STACK_OK != result)
429 ThrowOcException(result, "Failed to notify all observers");
433 catch (OCException& e)
435 LOGE("%s", e.reason().c_str());
436 ThrowOcException(e.code(), e.reason().c_str());
441 * Class: org_iotivity_base_OcPlatform
442 * Method: notifyListOfObservers2
443 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Ljava/lang/Byte;Lorg/iotivity/base/OcResourceResponse;)V
445 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyListOfObservers2(
448 jobject jResourceHandle,
449 jbyteArray jObservationIdArr,
450 jobject jResourceResponse)
452 LOGD("OcPlatform_notifyListOfObservers2");
453 if (!jResourceHandle)
455 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
458 if (!jObservationIdArr)
460 ThrowOcException(OC_STACK_INVALID_PARAM, "observationIdList cannot be null");
463 if (!jResourceResponse)
465 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
469 JniOcResourceHandle* jniOcResourceHandle =
470 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
471 if (!jniOcResourceHandle)
476 JniOcResourceResponse* jniOcResourceResponse =
477 JniOcResourceResponse::getJniOcResourceResponsePtr(env, jResourceResponse);
478 if (!jniOcResourceResponse)
483 int len = env->GetArrayLength(jObservationIdArr);
484 uint8_t* bArr = (uint8_t*)env->GetByteArrayElements(jObservationIdArr, 0);
486 ObservationIds observationIds;
487 for (int i = 0; i < len; ++i)
489 observationIds.push_back(bArr[i]);
492 env->ReleaseByteArrayElements(jObservationIdArr, (jbyte*)bArr, 0);
496 OCStackResult result = OCPlatform::notifyListOfObservers(
497 jniOcResourceHandle->getOCResourceHandle(),
499 jniOcResourceResponse->getOCResourceResponse());
501 if (OC_STACK_OK != result)
503 ThrowOcException(result, "Failed to notify all observers");
506 catch (OCException& e)
508 LOGE("%s", e.reason().c_str());
509 ThrowOcException(e.code(), e.reason().c_str());
514 * Class: org_iotivity_base_OcPlatform
515 * Method: notifyListOfObservers3
516 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Ljava/lang/Byte;Lorg/iotivity/base/OcResourceResponse;I)V
518 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyListOfObservers3(
521 jobject jResourceHandle,
522 jbyteArray jObservationIdArr,
523 jobject jResourceResponse,
526 LOGD("OcPlatform_notifyListOfObservers3");
527 if (!jResourceHandle)
529 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
532 if (!jObservationIdArr)
534 ThrowOcException(OC_STACK_INVALID_PARAM, "observationIdList cannot be null");
537 if (!jResourceResponse)
539 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
543 JniOcResourceHandle* jniOcResourceHandle =
544 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
545 if (!jniOcResourceHandle)
550 JniOcResourceResponse* jniOcResourceResponse =
551 JniOcResourceResponse::getJniOcResourceResponsePtr(env, jResourceResponse);
552 if (!jniOcResourceResponse)
557 int len = env->GetArrayLength(jObservationIdArr);
558 uint8_t* bArr = (uint8_t*)env->GetByteArrayElements(jObservationIdArr, 0);
560 ObservationIds observationIds;
561 for (int i = 0; i < len; ++i)
563 observationIds.push_back(bArr[i]);
566 env->ReleaseByteArrayElements(jObservationIdArr, (jbyte*)bArr, 0);
570 OCStackResult result = OCPlatform::notifyListOfObservers(
571 jniOcResourceHandle->getOCResourceHandle(),
573 jniOcResourceResponse->getOCResourceResponse(),
574 JniUtils::getQOS(env, static_cast<int>(jQoS)));
576 if (OC_STACK_OK != result)
578 ThrowOcException(result, "Failed to notify all observers");
581 catch (OCException& e)
583 LOGE("%s", e.reason().c_str());
584 ThrowOcException(e.code(), e.reason().c_str());
589 * Class: org_iotivity_base_OcPlatform
590 * Method: findResource0
591 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnResourceFoundListener;)V
593 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findResource0(
597 jstring jResourceUri,
598 jint jConnectivityType,
601 LOGD("OcPlatform_findResource");
605 host = env->GetStringUTFChars(jHost, nullptr);
607 std::string resourceUri;
610 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
614 ThrowOcException(OC_STACK_INVALID_PARAM, "onResourceFoundListener cannot be null");
618 JniOnResourceFoundListener *onResFoundListener = AddOnResourceFoundListener(env, jListener);
620 FindCallback findCallback = [onResFoundListener](std::shared_ptr<OCResource> resource)
622 onResFoundListener->foundResourceCallback(resource);
627 OCStackResult result = OCPlatform::findResource(
630 static_cast<OCConnectivityType>(jConnectivityType),
633 if (OC_STACK_OK != result)
635 ThrowOcException(result, "Find resource has failed");
639 catch (OCException& e)
641 LOGE("%s", e.reason().c_str());
642 ThrowOcException(e.code(), e.reason().c_str());
647 * Class: org_iotivity_base_OcPlatform
648 * Method: findResource1
649 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnResourceFoundListener;I)V
651 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findResource1(
655 jstring jResourceUri,
656 jint jConnectivityType,
660 LOGD("OcPlatform_findResource");
664 host = env->GetStringUTFChars(jHost, nullptr);
666 std::string resourceUri;
669 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
673 ThrowOcException(OC_STACK_INVALID_PARAM, "onResourceFoundListener cannot be null");
676 JniOnResourceFoundListener *onResFoundListener = AddOnResourceFoundListener(env, jListener);
678 FindCallback findCallback = [onResFoundListener](std::shared_ptr<OCResource> resource)
680 onResFoundListener->foundResourceCallback(resource);
685 OCStackResult result = OCPlatform::findResource(
688 static_cast<OCConnectivityType>(jConnectivityType),
690 JniUtils::getQOS(env, static_cast<int>(jQoS)));
692 if (OC_STACK_OK != result)
694 ThrowOcException(result, "Find resource has failed");
698 catch (OCException& e)
700 LOGE("%s", e.reason().c_str());
701 ThrowOcException(e.code(), e.reason().c_str());
706 * Class: org_iotivity_base_OcPlatform
707 * Method: getDeviceInfo0
708 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeviceFoundListener;)V
710 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDeviceInfo0(
714 jstring jResourceUri,
715 jint jConnectivityType,
718 LOGD("OcPlatform_getDeviceInfo0");
722 host = env->GetStringUTFChars(jHost, nullptr);
724 std::string resourceUri;
727 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
731 ThrowOcException(OC_STACK_INVALID_PARAM, "onDeviceFoundListener cannot be null");
734 JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
736 FindDeviceCallback findDeviceCallback =
737 [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
739 onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
744 OCStackResult result = OCPlatform::getDeviceInfo(
747 static_cast<OCConnectivityType>(jConnectivityType),
750 if (OC_STACK_OK != result)
752 ThrowOcException(result, "Find device has failed");
755 catch (OCException& e)
757 LOGE("%s", e.reason().c_str());
758 ThrowOcException(e.code(), e.reason().c_str());
763 * Class: org_iotivity_base_OcPlatform
764 * Method: getDeviceInfo1
765 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeviceFoundListener;I)V
767 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDeviceInfo1(
771 jstring jResourceUri,
772 jint jConnectivityType,
776 LOGD("OcPlatform_getDeviceInfo1");
780 host = env->GetStringUTFChars(jHost, nullptr);
782 std::string resourceUri;
785 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
789 ThrowOcException(OC_STACK_INVALID_PARAM, "onDeviceFoundListener cannot be null");
792 JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
794 FindDeviceCallback findDeviceCallback =
795 [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
797 onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
802 OCStackResult result = OCPlatform::getDeviceInfo(
805 static_cast<OCConnectivityType>(jConnectivityType),
807 JniUtils::getQOS(env, static_cast<int>(jQoS)));
809 if (OC_STACK_OK != result)
811 ThrowOcException(result, "Find device has failed");
814 catch (OCException& e)
816 LOGE("%s", e.reason().c_str());
817 ThrowOcException(e.code(), e.reason().c_str());
822 * Class: org_iotivity_base_OcPlatform
823 * Method: getPlatformInfo0
824 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPlatformFoundListener;)V
826 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getPlatformInfo0(
830 jstring jResourceUri,
831 jint jConnectivityType,
834 LOGD("OcPlatform_getPlatformInfo0");
838 host = env->GetStringUTFChars(jHost, nullptr);
840 std::string resourceUri;
843 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
847 ThrowOcException(OC_STACK_INVALID_PARAM, "onPlatformFoundListener cannot be null");
850 JniOnPlatformInfoListener *onPlatformInfoListener = AddOnPlatformInfoListener(env, jListener);
852 FindPlatformCallback findPlatformCallback =
853 [onPlatformInfoListener](const OCRepresentation& ocRepresentation)
855 onPlatformInfoListener->foundPlatformCallback(ocRepresentation);
860 OCStackResult result = OCPlatform::getPlatformInfo(
863 static_cast<OCConnectivityType>(jConnectivityType),
864 findPlatformCallback);
866 if (OC_STACK_OK != result)
868 ThrowOcException(result, "Find platform has failed");
871 catch (OCException& e)
873 LOGE("%s", e.reason().c_str());
874 ThrowOcException(e.code(), e.reason().c_str());
879 * Class: org_iotivity_base_OcPlatform
880 * Method: getPlatformInfo1
881 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPlatformFoundListener;I)V
883 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getPlatformInfo1(
887 jstring jResourceUri,
888 jint jConnectivityType,
892 LOGD("OcPlatform_getPlatformInfo1");
896 host = env->GetStringUTFChars(jHost, nullptr);
898 std::string resourceUri;
901 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
905 ThrowOcException(OC_STACK_INVALID_PARAM, "onPlatformFoundListener cannot be null");
908 JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
910 FindDeviceCallback findDeviceCallback =
911 [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
913 onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
918 OCStackResult result = OCPlatform::getPlatformInfo(
921 static_cast<OCConnectivityType>(jConnectivityType),
923 JniUtils::getQOS(env, static_cast<int>(jQoS)));
925 if (OC_STACK_OK != result)
927 ThrowOcException(result, "Find platform has failed");
930 catch (OCException& e)
932 LOGE("%s", e.reason().c_str());
933 ThrowOcException(e.code(), e.reason().c_str());
938 * Class: org_iotivity_base_OcPlatform
939 * Method: registerResource0
940 * Signature: (Lorg/iotivity/base/OcResource;)Lorg/iotivity/base/OcResourceHandle;
942 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_registerResource0(
943 JNIEnv *env, jclass clazz, jobject jResource)
945 LOGD("OcPlatform_registerResource");
948 ThrowOcException(OC_STACK_INVALID_PARAM, "Resource cannot be null");
951 JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, jResource);
952 if (!resource) return nullptr;
954 OCResourceHandle resourceHandle;
957 OCStackResult result = OCPlatform::registerResource(
959 resource->getOCResource());
961 if (OC_STACK_OK != result)
963 ThrowOcException(result, "register resource");
966 catch (OCException& e)
968 LOGE("%s", e.reason().c_str());
969 ThrowOcException(e.code(), e.reason().c_str());
972 JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);
973 jlong handle = reinterpret_cast<jlong>(jniHandle);
974 jobject jResourceHandle =
975 env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);
977 if (!jResourceHandle)
979 LOGE("Failed to create OcResourceHandle");
982 return jResourceHandle;
986 * Class: org_iotivity_base_OcPlatform
987 * Method: registerResource1
988 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcPlatform/EntityHandler;I)Lorg/iotivity/base/OcResourceHandle;
990 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_registerResource1(
993 jstring jResourceUri,
994 jstring jResourceTypeName,
995 jstring jResourceInterface,
996 jobject jListener, jint jResourceProperty)
998 LOGI("OcPlatform_registerResource1");
999 std::string resourceUri;
1002 resourceUri = env->GetStringUTFChars(jResourceUri, nullptr);
1004 std::string resourceTypeName;
1005 if (jResourceTypeName)
1007 resourceTypeName = env->GetStringUTFChars(jResourceTypeName, nullptr);
1009 std::string resourceInterface;
1010 if (jResourceInterface)
1012 resourceInterface = env->GetStringUTFChars(jResourceInterface, nullptr);
1014 JniEntityHandler* entityHandler = NULL;
1015 EntityHandler handleEntityCallback = NULL;
1018 entityHandler = new JniEntityHandler(env, jListener);
1019 handleEntityCallback =
1020 [entityHandler](const std::shared_ptr<OCResourceRequest> request) -> OCEntityHandlerResult
1022 return entityHandler->handleEntity(request);
1026 OCResourceHandle resourceHandle;
1029 OCStackResult result = OCPlatform::registerResource(
1034 handleEntityCallback,
1035 static_cast<int>(jResourceProperty));
1037 if (OC_STACK_OK != result)
1039 delete entityHandler;
1040 ThrowOcException(result, "register resource");
1044 catch (OCException& e)
1046 LOGE("%s", e.reason().c_str());
1047 delete entityHandler;
1048 ThrowOcException(e.code(), e.reason().c_str());
1052 JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);
1053 jlong handle = reinterpret_cast<jlong>(jniHandle);
1054 jobject jResourceHandle =
1055 env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);
1056 if (!jResourceHandle)
1058 LOGE("Failed to create OcResourceHandle");
1062 return jResourceHandle;
1066 * Class: org_iotivity_base_OcPlatform
1067 * Method: registerDeviceInfo0
1068 * 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
1070 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_registerDeviceInfo0(
1073 jstring jDeviceName)
1075 LOGI("OcPlatform_registerDeviceInfo");
1077 std::string deviceName;
1080 deviceName = env->GetStringUTFChars(jDeviceName, nullptr);
1083 OCDeviceInfo deviceInfo;
1086 DuplicateString(&deviceInfo.deviceName, deviceName);
1088 catch (std::exception &e)
1090 ThrowOcException(JNI_EXCEPTION, "Failed to construct device info");
1096 OCStackResult result = OCPlatform::registerDeviceInfo(deviceInfo);
1098 delete deviceInfo.deviceName;
1100 if (OC_STACK_OK != result)
1102 ThrowOcException(result, "Failed to register device info");
1106 catch (OCException& e)
1108 LOGE("%s", e.reason().c_str());
1109 ThrowOcException(e.code(), e.reason().c_str());
1114 * Class: org_iotivity_base_OcPlatform
1115 * Method: registerPlatformInfo0
1116 * 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
1118 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_registerPlatformInfo0(
1121 jstring jPlatformID,
1122 jstring jManufacturerName,
1123 jstring jManufacturerUrl,
1124 jstring jModelNumber,
1125 jstring jDateOfManufacture,
1126 jstring jPlatformVersion,
1127 jstring jOperatingSystemVersion,
1128 jstring jHardwareVersion,
1129 jstring jFirmwareVersion,
1130 jstring jSupportUrl,
1131 jstring jSystemTime)
1133 LOGI("OcPlatform_registerPlatformInfo");
1136 std::string platformID;
1137 std::string manufacturerName;
1138 std::string manufacturerUrl;
1139 std::string modelNumber;
1140 std::string dateOfManufacture;
1141 std::string platformVersion;
1142 std::string operatingSystemVersion;
1143 std::string hardwareVersion;
1144 std::string firmwareVersion;
1145 std::string supportUrl;
1146 std::string systemTime;
1150 platformID = env->GetStringUTFChars(jPlatformID, nullptr);
1152 if (jManufacturerName)
1154 manufacturerName = env->GetStringUTFChars(jManufacturerName, nullptr);
1156 if (jManufacturerUrl)
1158 manufacturerUrl = env->GetStringUTFChars(jManufacturerUrl, nullptr);
1162 modelNumber = env->GetStringUTFChars(jModelNumber, nullptr);
1164 if (jDateOfManufacture)
1166 dateOfManufacture = env->GetStringUTFChars(jDateOfManufacture, nullptr);
1168 if (jPlatformVersion)
1170 platformVersion = env->GetStringUTFChars(jPlatformVersion, nullptr);
1172 if (jOperatingSystemVersion)
1174 operatingSystemVersion = env->GetStringUTFChars(jOperatingSystemVersion, nullptr);
1176 if (jHardwareVersion)
1178 hardwareVersion = env->GetStringUTFChars(jHardwareVersion, nullptr);
1180 if (jFirmwareVersion)
1182 firmwareVersion = env->GetStringUTFChars(jFirmwareVersion, nullptr);
1186 supportUrl = env->GetStringUTFChars(jSupportUrl, nullptr);
1190 systemTime = env->GetStringUTFChars(jSystemTime, nullptr);
1193 OCPlatformInfo platformInfo;
1196 DuplicateString(&platformInfo.platformID, platformID);
1197 DuplicateString(&platformInfo.manufacturerName, manufacturerName);
1198 DuplicateString(&platformInfo.manufacturerUrl, manufacturerUrl);
1199 DuplicateString(&platformInfo.modelNumber, modelNumber);
1200 DuplicateString(&platformInfo.dateOfManufacture, dateOfManufacture);
1201 DuplicateString(&platformInfo.platformVersion, platformVersion);
1202 DuplicateString(&platformInfo.operatingSystemVersion, operatingSystemVersion);
1203 DuplicateString(&platformInfo.hardwareVersion, hardwareVersion);
1204 DuplicateString(&platformInfo.firmwareVersion, firmwareVersion);
1205 DuplicateString(&platformInfo.supportUrl, supportUrl);
1206 DuplicateString(&platformInfo.systemTime, systemTime);
1208 catch (std::exception &e)
1210 ThrowOcException(JNI_EXCEPTION, "Failed to construct platform info");
1214 // __android_log_print(ANDROID_LOG_INFO, "Rahul", "platformID = %s", platformID);
1217 OCStackResult result = OCPlatform::registerPlatformInfo(platformInfo);
1219 delete platformInfo.platformID;
1220 delete platformInfo.manufacturerName;
1221 delete platformInfo.manufacturerUrl;
1222 delete platformInfo.modelNumber;
1223 delete platformInfo.dateOfManufacture;
1224 delete platformInfo.platformVersion;
1225 delete platformInfo.operatingSystemVersion;
1226 delete platformInfo.hardwareVersion;
1227 delete platformInfo.firmwareVersion;
1228 delete platformInfo.supportUrl;
1229 delete platformInfo.systemTime;
1231 if (OC_STACK_OK != result)
1233 ThrowOcException(result, "Failed to register platform info");
1237 catch (OCException& e)
1239 LOGE("Error is due to %s", e.reason().c_str());
1240 ThrowOcException(e.code(), e.reason().c_str());
1245 * Class: org_iotivity_base_OcPlatform
1246 * Method: unregisterResource0
1247 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V
1249 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unregisterResource0(
1250 JNIEnv *env, jclass clazz, jobject jResourceHandle)
1252 LOGI("OcPlatform_unregisterResource");
1253 if (!jResourceHandle)
1255 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1258 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1259 env, jResourceHandle);
1260 if (!jniOcResourceHandle)
1267 OCResourceHandle resHandle = jniOcResourceHandle->getOCResourceHandle();
1268 OCStackResult result = OCPlatform::unregisterResource(resHandle);
1269 if (OC_STACK_OK != result)
1271 ThrowOcException(result, "Failed to unregister resource");
1274 catch (OCException& e)
1276 LOGE("%s", e.reason().c_str());
1277 ThrowOcException(e.code(), e.reason().c_str());
1282 * Class: org_iotivity_base_OcPlatform
1283 * Method: bindResource0
1284 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
1286 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResource0
1287 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobject jResourceHandle)
1289 LOGI("OcPlatform_bindResource");
1290 if (!jResourceCollectionHandle)
1292 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1295 if (!jResourceHandle)
1297 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1300 JniOcResourceHandle* jniOcResourceCollectionHandle =
1301 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1302 if (!jniOcResourceCollectionHandle) return;
1304 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
1305 env, jResourceHandle);
1306 if (!jniOcResourceHandle)
1313 OCStackResult result = OCPlatform::bindResource(
1314 jniOcResourceCollectionHandle->getOCResourceHandle(),
1315 jniOcResourceHandle->getOCResourceHandle()
1318 if (OC_STACK_OK != result)
1320 ThrowOcException(result, "Failed to bind resource");
1323 catch (OCException& e)
1325 LOGE("%s", e.reason().c_str());
1326 ThrowOcException(e.code(), e.reason().c_str());
1331 * Class: org_iotivity_base_OcPlatform
1332 * Method: bindResources0
1333 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
1335 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResources0(
1338 jobject jResourceCollectionHandle,
1339 jobjectArray jResourceHandleArray)
1341 LOGI("OcPlatform_bindResources");
1343 if (!jResourceCollectionHandle)
1345 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1348 if (!jResourceHandleArray)
1350 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
1354 JniOcResourceHandle* jniOcResourceCollectionHandle =
1355 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1356 if (!jniOcResourceCollectionHandle)
1361 std::vector<OCResourceHandle> resourceHandleList;
1362 int len = env->GetArrayLength(jResourceHandleArray);
1363 for (int i = 0; i < len; ++i)
1365 jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
1366 if (!jResourceHandle)
1368 ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
1372 JniOcResourceHandle* jniOcResourceHandle =
1373 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1374 if (!jniOcResourceHandle)
1379 resourceHandleList.push_back(
1380 jniOcResourceHandle->getOCResourceHandle());
1385 OCStackResult result = OCPlatform::bindResources(
1386 jniOcResourceCollectionHandle->getOCResourceHandle(),
1390 if (OC_STACK_OK != result)
1392 ThrowOcException(result, "Failed to bind resources");
1395 catch (OCException& e)
1397 LOGE("%s", e.reason().c_str());
1398 ThrowOcException(e.code(), e.reason().c_str());
1403 * Class: org_iotivity_base_OcPlatform
1404 * Method: unbindResource0
1405 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
1407 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResource0(
1410 jobject jResourceCollectionHandle,
1411 jobject jResourceHandle)
1413 LOGI("OcPlatform_unbindResource");
1414 if (!jResourceCollectionHandle)
1416 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1419 if (!jResourceHandle)
1421 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1425 JniOcResourceHandle* jniOcResourceCollectionHandle =
1426 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1427 if (!jniOcResourceCollectionHandle)
1432 JniOcResourceHandle* jniOcResourceHandle =
1433 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1434 if (!jniOcResourceHandle)
1441 OCStackResult result = OCPlatform::unbindResource(
1442 jniOcResourceCollectionHandle->getOCResourceHandle(),
1443 jniOcResourceHandle->getOCResourceHandle());
1445 if (OC_STACK_OK != result)
1447 ThrowOcException(result, "Failed to unbind resource");
1450 catch (OCException& e)
1452 LOGE("%s", e.reason().c_str());
1453 ThrowOcException(e.code(), e.reason().c_str());
1458 * Class: org_iotivity_base_OcPlatform
1459 * Method: unbindResources0
1460 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
1462 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResources0(
1465 jobject jResourceCollectionHandle,
1466 jobjectArray jResourceHandleArray)
1468 LOGI("OcPlatform_unbindResources");
1469 if (!jResourceCollectionHandle)
1471 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
1474 if (!jResourceHandleArray)
1476 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
1480 JniOcResourceHandle* jniOcResourceCollectionHandle =
1481 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceCollectionHandle);
1482 if (!jniOcResourceCollectionHandle)
1487 std::vector<OCResourceHandle> resourceHandleList;
1488 int len = env->GetArrayLength(jResourceHandleArray);
1489 for (int i = 0; i < len; ++i)
1491 jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
1492 if (!jResourceHandle)
1494 ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
1498 JniOcResourceHandle* jniOcResourceHandle =
1499 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1500 if (!jniOcResourceHandle)
1505 resourceHandleList.push_back(
1506 jniOcResourceHandle->getOCResourceHandle());
1511 OCStackResult result = OCPlatform::unbindResources(
1512 jniOcResourceCollectionHandle->getOCResourceHandle(),
1516 if (OC_STACK_OK != result)
1518 ThrowOcException(result, "Failed to unbind resources");
1521 catch (OCException& e)
1523 LOGE("%s", e.reason().c_str());
1524 ThrowOcException(e.code(), e.reason().c_str());
1529 * Class: org_iotivity_base_OcPlatform
1530 * Method: bindTypeToResource0
1531 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
1533 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindTypeToResource0(
1536 jobject jResourceHandle,
1537 jstring jResourceTypeName)
1539 LOGI("OcPlatform_bindTypeToResource");
1540 if (!jResourceHandle)
1542 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1545 std::string typeName;
1546 if (jResourceTypeName)
1548 typeName = env->GetStringUTFChars(jResourceTypeName, nullptr);
1551 JniOcResourceHandle* jniOcResourceHandle =
1552 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1553 if (!jniOcResourceHandle) return;
1557 OCStackResult result = OCPlatform::bindTypeToResource(
1558 jniOcResourceHandle->getOCResourceHandle(),
1562 if (OC_STACK_OK != result)
1564 ThrowOcException(result, "Failed to bind type to resource");
1567 catch (OCException& e)
1569 LOGE("%s", e.reason().c_str());
1570 ThrowOcException(e.code(), e.reason().c_str());
1575 * Class: org_iotivity_base_OcPlatform
1576 * Method: bindInterfaceToResource0
1577 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
1579 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindInterfaceToResource0
1580 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jstring jResourceInterfaceName)
1582 LOGI("OcPlatform_bindInterfaceToResource");
1583 if (!jResourceHandle)
1585 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
1588 std::string interfaceName;
1589 if (jResourceInterfaceName)
1591 interfaceName = env->GetStringUTFChars(jResourceInterfaceName, nullptr);
1594 JniOcResourceHandle* jniOcResourceHandle =
1595 JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
1596 if (!jniOcResourceHandle)
1603 OCStackResult result = OCPlatform::bindInterfaceToResource(
1604 jniOcResourceHandle->getOCResourceHandle(),
1608 if (OC_STACK_OK != result)
1610 ThrowOcException(result, "Failed to bind interface to resource");
1613 catch (OCException& e)
1615 LOGE("%s", e.reason().c_str());
1616 ThrowOcException(e.code(), e.reason().c_str());
1621 * Class: org_iotivity_base_OcPlatform
1622 * Method: startPresence0
1625 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_startPresence0(
1626 JNIEnv *env, jclass clazz, jint ttl)
1628 LOGI("OcPlatform_startPresence");
1632 OCStackResult result = OCPlatform::startPresence((unsigned int)ttl);
1634 if (OC_STACK_OK != result)
1636 ThrowOcException(result, "Failed to start presence");
1639 catch (OCException& e)
1641 LOGE("%s", e.reason().c_str());
1642 ThrowOcException(e.code(), e.reason().c_str());
1647 * Class: org_iotivity_base_OcPlatform
1648 * Method: stopPresence0
1651 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_stopPresence0(
1652 JNIEnv *env, jclass clazz)
1654 LOGI("OcPlatform_stopPresence");
1658 OCStackResult result = OCPlatform::stopPresence();
1660 if (OC_STACK_OK != result)
1662 ThrowOcException(result, "Failed to stop presence");
1665 catch (OCException& e)
1667 LOGE("%s", e.reason().c_str());
1668 ThrowOcException(e.code(), e.reason().c_str());
1673 * Class: org_iotivity_base_OcPlatform
1674 * Method: subscribePresence0
1675 * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
1677 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence0(
1681 jint jConnectivityType,
1684 LOGD("OcPlatform_subscribePresence");
1688 host = env->GetStringUTFChars(jHost, nullptr);
1692 ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
1696 JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
1698 SubscribeCallback subscribeCallback =
1699 [onPresenceListener](OCStackResult result,
1700 const unsigned int nonce,
1701 const std::string& hostAddress)
1703 onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
1706 OCPlatform::OCPresenceHandle presenceHandle;
1709 OCStackResult result = OCPlatform::subscribePresence(
1712 static_cast<OCConnectivityType>(jConnectivityType),
1715 if (OC_STACK_OK != result)
1717 ThrowOcException(result, "subscribe presence has failed");
1720 catch (OCException& e)
1722 LOGE("%s", e.reason().c_str());
1723 ThrowOcException(e.code(), e.reason().c_str());
1727 JniOcPresenceHandle* jniPresenceHandle =
1728 new JniOcPresenceHandle(onPresenceListener, presenceHandle);
1729 jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
1730 jobject jPresenceHandle =
1731 env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
1732 if (!jPresenceHandle)
1734 LOGE("Failed to create OcPresenceHandle");
1735 delete jniPresenceHandle;
1737 return jPresenceHandle;
1741 * Class: org_iotivity_base_OcPlatform
1742 * Method: subscribePresence1
1743 * Signature: (Ljava/lang/String;Ljava/lang/String;I
1744 Lorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
1746 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence1(
1750 jstring jResourceType,
1751 jint jConnectivityType,
1754 LOGD("OcPlatform_subscribePresence1");
1758 host = env->GetStringUTFChars(jHost, nullptr);
1760 std::string resourceType;
1763 resourceType = env->GetStringUTFChars(jResourceType, nullptr);
1767 ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
1771 JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
1773 SubscribeCallback subscribeCallback = [onPresenceListener](OCStackResult result,
1774 const unsigned int nonce, const std::string& hostAddress)
1776 onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
1779 OCPlatform::OCPresenceHandle presenceHandle;
1782 OCStackResult result = OCPlatform::subscribePresence(
1786 static_cast<OCConnectivityType>(jConnectivityType),
1789 if (OC_STACK_OK != result)
1791 ThrowOcException(result, "subscribe presence has failed");
1794 catch (OCException& e)
1796 LOGE("%s", e.reason().c_str());
1797 ThrowOcException(e.code(), e.reason().c_str());
1801 JniOcPresenceHandle* jniPresenceHandle =
1802 new JniOcPresenceHandle(onPresenceListener, presenceHandle);
1803 jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
1804 jobject jPresenceHandle =
1805 env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
1806 if (!jPresenceHandle)
1808 LOGE("Failed to create OcPresenceHandle");
1809 delete jniPresenceHandle;
1811 return jPresenceHandle;
1815 * Class: org_iotivity_base_OcPlatform
1816 * Method: unsubscribePresence0
1817 * Signature: (Lorg/iotivity/base/OcPresenceHandle;)V
1819 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unsubscribePresence0(
1820 JNIEnv *env, jclass clazz, jobject jPresenceHandle)
1822 LOGD("OcPlatform_unsubscribePresence");
1823 if (!jPresenceHandle)
1825 ThrowOcException(OC_STACK_INVALID_PARAM, "presenceHandle cannot be null");
1828 JniOcPresenceHandle* jniPresenceHandle =
1829 JniOcPresenceHandle::getJniOcPresenceHandlePtr(env, jPresenceHandle);
1830 if (!jniPresenceHandle)
1835 OCPresenceHandle presenceHandle = jniPresenceHandle->getOCPresenceHandle();
1839 OCStackResult result = OCPlatform::unsubscribePresence(presenceHandle);
1841 if (OC_STACK_OK != result)
1843 ThrowOcException(result, "unsubscribe presence has failed");
1846 jweak jwOnPresenceListener =
1847 jniPresenceHandle->getJniOnPresenceListener()->getJWListener();
1848 if (jwOnPresenceListener)
1850 RemoveOnPresenceListener(env, jwOnPresenceListener);
1853 catch (OCException& e)
1855 LOGE("%s", e.reason().c_str());
1856 ThrowOcException(e.code(), e.reason().c_str());
1861 * Class: org_iotivity_base_OcPlatform
1862 * Method: constructResourceObject0
1863 * Signature: (Ljava/lang/String;Ljava/lang/String;IZ[Ljava/lang/String;[Ljava/lang/String;)
1864 Lorg/iotivity/base/OcResource;
1866 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_constructResourceObject0(
1871 jint jConnectivityType,
1872 jboolean jIsObservable,
1873 jobjectArray jResourceTypeArray,
1874 jobjectArray jInterfaceArray)
1876 LOGD("OcPlatform_constructResourceObject");
1880 host = env->GetStringUTFChars(jHost, nullptr);
1885 uri = env->GetStringUTFChars(jUri, nullptr);
1887 if (!jResourceTypeArray)
1889 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceTypeList cannot be null");
1892 if (!jInterfaceArray)
1894 ThrowOcException(OC_STACK_INVALID_PARAM, "interfaceList cannot be null");
1898 std::vector<std::string> resourceTypes;
1899 JniUtils::convertJavaStrArrToStrVector(env, jResourceTypeArray, resourceTypes);
1901 std::vector<std::string> interfaces;
1902 JniUtils::convertJavaStrArrToStrVector(env, jInterfaceArray, interfaces);
1904 std::shared_ptr<OCResource> resource = OCPlatform::constructResourceObject(
1907 static_cast<OCConnectivityType>(jConnectivityType),
1908 static_cast<bool>(jIsObservable),
1914 ThrowOcException(OC_STACK_ERROR, "Failed to create OCResource");
1918 JniOcResource *jniOcResource = new JniOcResource(resource);
1919 jlong handle = reinterpret_cast<jlong>(jniOcResource);
1921 jobject jResource = env->NewObject(g_cls_OcResource, g_mid_OcResource_ctor);
1924 delete jniOcResource;
1927 SetHandle<JniOcResource>(env, jResource, jniOcResource);
1928 if (env->ExceptionCheck())
1930 delete jniOcResource;
1937 * Class: org_iotivity_base_OcPlatform
1938 * Method: sendResponse0
1939 * Signature: (Lorg/iotivity/base/OcResourceResponse;)V
1941 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_sendResponse0(
1942 JNIEnv *env, jclass clazz, jobject jResourceResponse)
1944 LOGD("OcPlatform_sendResponse");
1945 if (!jResourceResponse)
1947 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
1951 JniOcResourceResponse *jniResponse =
1952 JniOcResourceResponse::getJniOcResourceResponsePtr(env, jResourceResponse);
1953 if (!jniResponse) return;
1957 OCStackResult result =
1958 OCPlatform::sendResponse(jniResponse->getOCResourceResponse());
1960 if (OC_STACK_OK != result)
1962 ThrowOcException(result, "failed to send response");
1965 catch (OCException& e)
1967 LOGE("%s", e.reason().c_str());
1968 ThrowOcException(e.code(), e.reason().c_str());