2 * //******************************************************************
\r
4 * // Copyright 2015 Intel Corporation.
\r
6 * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
\r
8 * // Licensed under the Apache License, Version 2.0 (the "License");
\r
9 * // you may not use this file except in compliance with the License.
\r
10 * // You may obtain a copy of the License at
\r
12 * // http://www.apache.org/licenses/LICENSE-2.0
\r
14 * // Unless required by applicable law or agreed to in writing, software
\r
15 * // distributed under the License is distributed on an "AS IS" BASIS,
\r
16 * // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
\r
17 * // See the License for the specific language governing permissions and
\r
18 * // limitations under the License.
\r
20 * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
\r
22 #include "JniOcPlatform.h"
\r
23 #include "OCPlatform.h"
\r
24 #include "JniOcResource.h"
\r
25 #include "JniOcResourceHandle.h"
\r
26 #include "JniOcPresenceHandle.h"
\r
27 #include "JniOcResourceResponse.h"
\r
28 #include "JniUtils.h"
\r
32 JniOnResourceFoundListener* AddOnResourceFoundListener(JNIEnv* env, jobject jListener)
\r
34 JniOnResourceFoundListener *onResourceFoundListener = NULL;
\r
36 resourceFoundMapLock.lock();
\r
38 for (auto it = onResourceFoundListenerMap.begin(); it != onResourceFoundListenerMap.end(); ++it)
\r
40 if (env->IsSameObject(jListener, it->first))
\r
42 auto refPair = it->second;
\r
43 onResourceFoundListener = refPair.first;
\r
45 it->second = refPair;
\r
46 onResourceFoundListenerMap.insert(*it);
\r
47 LOGD("OnResourceFoundListener: ref. count incremented");
\r
52 if (!onResourceFoundListener)
\r
54 onResourceFoundListener = new JniOnResourceFoundListener(env, jListener, RemoveOnResourceFoundListener);
\r
55 jobject jgListener = env->NewGlobalRef(jListener);
\r
57 onResourceFoundListenerMap.insert(std::pair < jobject, std::pair < JniOnResourceFoundListener*,
\r
58 int >> (jgListener, std::pair<JniOnResourceFoundListener*, int>(onResourceFoundListener, 1)));
\r
59 LOGD("OnResourceFoundListener: new listener");
\r
61 resourceFoundMapLock.unlock();
\r
62 return onResourceFoundListener;
\r
65 void RemoveOnResourceFoundListener(JNIEnv* env, jobject jListener)
\r
67 resourceFoundMapLock.lock();
\r
69 for (auto it = onResourceFoundListenerMap.begin(); it != onResourceFoundListenerMap.end(); ++it)
\r
71 if (env->IsSameObject(jListener, it->first))
\r
73 auto refPair = it->second;
\r
74 if (refPair.second > 1)
\r
77 it->second = refPair;
\r
78 onResourceFoundListenerMap.insert(*it);
\r
79 LOGI("OnResourceFoundListener: ref. count decremented");
\r
83 env->DeleteGlobalRef(it->first);
\r
84 JniOnResourceFoundListener* listener = refPair.first;
\r
86 onResourceFoundListenerMap.erase(it);
\r
87 LOGI("OnResourceFoundListener removed");
\r
92 resourceFoundMapLock.unlock();
\r
95 JniOnDeviceInfoListener* AddOnDeviceInfoListener(JNIEnv* env, jobject jListener)
\r
97 JniOnDeviceInfoListener *onDeviceInfoListener = NULL;
\r
99 deviceInfoMapLock.lock();
\r
101 for (auto it = onDeviceInfoListenerMap.begin(); it != onDeviceInfoListenerMap.end(); ++it)
\r
103 if (env->IsSameObject(jListener, it->first))
\r
105 auto refPair = it->second;
\r
106 onDeviceInfoListener = refPair.first;
\r
108 it->second = refPair;
\r
109 onDeviceInfoListenerMap.insert(*it);
\r
110 LOGD("OnDeviceInfoListener: ref. count incremented");
\r
115 if (!onDeviceInfoListener)
\r
117 onDeviceInfoListener = new JniOnDeviceInfoListener(env, jListener, RemoveOnDeviceInfoListener);
\r
118 jobject jgListener = env->NewGlobalRef(jListener);
\r
120 onDeviceInfoListenerMap.insert(std::pair < jobject, std::pair < JniOnDeviceInfoListener*,
\r
121 int >> (jgListener, std::pair<JniOnDeviceInfoListener*, int>(onDeviceInfoListener, 1)));
\r
122 LOGI("OnDeviceInfoListener: new listener");
\r
125 deviceInfoMapLock.unlock();
\r
126 return onDeviceInfoListener;
\r
129 void RemoveOnDeviceInfoListener(JNIEnv* env, jobject jListener)
\r
131 deviceInfoMapLock.lock();
\r
132 bool isFound = false;
\r
133 for (auto it = onDeviceInfoListenerMap.begin(); it != onDeviceInfoListenerMap.end(); ++it)
\r
135 if (env->IsSameObject(jListener, it->first))
\r
137 auto refPair = it->second;
\r
138 if (refPair.second > 1)
\r
141 it->second = refPair;
\r
142 onDeviceInfoListenerMap.insert(*it);
\r
143 LOGI("OnDeviceInfoListener: ref. count decremented");
\r
147 env->DeleteGlobalRef(it->first);
\r
148 JniOnDeviceInfoListener* listener = refPair.first;
\r
150 onDeviceInfoListenerMap.erase(it);
\r
152 LOGI("OnDeviceInfoListener removed");
\r
162 ThrowOcException(JNI_EXCEPTION, "OnDeviceInfoListenet not found");
\r
164 deviceInfoMapLock.unlock();
\r
167 JniOnPresenceListener* AddOnPresenceListener(JNIEnv* env, jobject jListener)
\r
169 JniOnPresenceListener *onPresenceListener = NULL;
\r
171 presenceMapLock.lock();
\r
173 for (auto it = onPresenceListenerMap.begin(); it != onPresenceListenerMap.end(); ++it)
\r
175 if (env->IsSameObject(jListener, it->first))
\r
177 auto refPair = it->second;
\r
178 onPresenceListener = refPair.first;
\r
180 it->second = refPair;
\r
181 onPresenceListenerMap.insert(*it);
\r
182 LOGD("OnPresenceListener: ref. count incremented");
\r
186 if (!onPresenceListener)
\r
188 onPresenceListener = new JniOnPresenceListener(env, jListener, RemoveOnPresenceListener);
\r
189 jobject jgListener = env->NewGlobalRef(jListener);
\r
190 onPresenceListenerMap.insert(std::pair < jobject, std::pair < JniOnPresenceListener*,
\r
191 int >> (jgListener, std::pair<JniOnPresenceListener*, int>(onPresenceListener, 1)));
\r
192 LOGI("OnPresenceListener: new listener");
\r
194 presenceMapLock.unlock();
\r
195 return onPresenceListener;
\r
198 void RemoveOnPresenceListener(JNIEnv* env, jobject jListener)
\r
200 presenceMapLock.lock();
\r
201 bool isFound = false;
\r
202 for (auto it = onPresenceListenerMap.begin(); it != onPresenceListenerMap.end(); ++it)
\r
204 if (env->IsSameObject(jListener, it->first))
\r
206 auto refPair = it->second;
\r
207 if (refPair.second > 1)
\r
210 it->second = refPair;
\r
211 onPresenceListenerMap.insert(*it);
\r
212 LOGI("OnPresenceListener: ref. count decremented");
\r
216 env->DeleteGlobalRef(it->first);
\r
217 JniOnPresenceListener* listener = refPair.first;
\r
219 onPresenceListenerMap.erase(it);
\r
220 LOGI("OnPresenceListener is removed");
\r
228 ThrowOcException(JNI_EXCEPTION, "OnPresenceListener not found");
\r
230 presenceMapLock.unlock();
\r
234 * Class: org_iotivity_base_OcPlatform
\r
235 * Method: configure
\r
236 * Signature: (IILjava/lang/String;II)V
\r
238 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_configure
\r
239 (JNIEnv *env, jclass clazz, jint jServiceType, jint jModeType, jstring jIpAddress, jint jPort, jint jQOS)
\r
241 LOGI("OcPlatform_configure");
\r
243 std::string ipAddress;
\r
246 ipAddress = env->GetStringUTFChars(jIpAddress, NULL);
\r
251 port = static_cast<uint16_t>(jPort);
\r
253 PlatformConfig cfg{
\r
254 JniUtils::getServiceType(env, jServiceType),
\r
255 JniUtils::getModeType(env, jModeType),
\r
258 JniUtils::getQOS(env, static_cast<int>(jQOS))
\r
261 OCPlatform::Configure(cfg);
\r
265 * Class: org_iotivity_base_OcPlatform
\r
266 * Method: notifyAllObservers0
\r
267 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V
\r
269 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyAllObservers0
\r
270 (JNIEnv *env, jclass clazz, jobject jResourceHandle)
\r
272 LOGI("OcPlatform_notifyAllObservers");
\r
273 if (!jResourceHandle)
\r
275 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
279 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
280 env, jResourceHandle);
\r
281 if (!jniOcResourceHandle) return;
\r
285 OCStackResult result = OCPlatform::notifyAllObservers(jniOcResourceHandle->getOCResourceHandle());
\r
287 if (OC_STACK_OK != result)
\r
289 ThrowOcException(result, "Failed to notify all observers");
\r
293 catch (OCException& e)
\r
295 LOGE("%s", e.reason().c_str());
\r
296 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
301 * Class: org_iotivity_base_OcPlatform
\r
302 * Method: notifyAllObservers1
\r
303 * Signature: (Lorg/iotivity/base/OcResourceHandle;I)V
\r
305 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyAllObservers1
\r
306 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jint jQoS)
\r
308 LOGI("OcPlatform_notifyAllObservers1");
\r
310 if (!jResourceHandle)
\r
312 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
316 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
317 env, jResourceHandle);
\r
318 if (!jniOcResourceHandle) return;
\r
321 OCStackResult result = OCPlatform::notifyAllObservers(
\r
322 jniOcResourceHandle->getOCResourceHandle(),
\r
323 JniUtils::getQOS(env, static_cast<int>(jQoS)));
\r
325 if (OC_STACK_OK != result)
\r
327 ThrowOcException(result, "Failed to notify all observers");
\r
331 catch (OCException& e)
\r
333 LOGE("%s", e.reason().c_str());
\r
334 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
339 * Class: org_iotivity_base_OcPlatform
\r
340 * Method: notifyListOfObservers2
\r
341 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Ljava/lang/Byte;Lorg/iotivity/base/OcResourceResponse;)V
\r
343 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyListOfObservers2
\r
344 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jbyteArray jObservationIdArr, jobject jResourceResponse)
\r
346 LOGD("OcPlatform_notifyListOfObservers2");
\r
347 if (!jResourceHandle)
\r
349 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
352 if (!jObservationIdArr)
\r
354 ThrowOcException(OC_STACK_INVALID_PARAM, "observationIdList cannot be null");
\r
357 if (!jResourceResponse)
\r
359 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
\r
363 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
364 env, jResourceHandle);
\r
365 if (!jniOcResourceHandle) return;
\r
367 JniOcResourceResponse* jniOcResourceResponse = JniOcResourceResponse::getJniOcResourceResponsePtr(
\r
368 env, jResourceResponse);
\r
369 if (!jniOcResourceResponse) return;
\r
371 int len = env->GetArrayLength(jObservationIdArr);
\r
372 uint8_t* bArr = (uint8_t*)env->GetByteArrayElements(jObservationIdArr, 0);
\r
374 ObservationIds observationIds;
\r
375 for (int i = 0; i < len; ++i)
\r
377 observationIds.push_back(bArr[i]);
\r
380 env->ReleaseByteArrayElements(jObservationIdArr, (jbyte*)bArr, 0);
\r
383 OCStackResult result = OCPlatform::notifyListOfObservers(
\r
384 jniOcResourceHandle->getOCResourceHandle(),
\r
386 jniOcResourceResponse->getOCResourceResponse());
\r
388 if (OC_STACK_OK != result)
\r
390 ThrowOcException(result, "Failed to notify all observers");
\r
393 catch (OCException& e)
\r
395 LOGE("%s", e.reason().c_str());
\r
396 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
401 * Class: org_iotivity_base_OcPlatform
\r
402 * Method: notifyListOfObservers3
\r
403 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Ljava/lang/Byte;Lorg/iotivity/base/OcResourceResponse;I)V
\r
405 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyListOfObservers3
\r
406 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jbyteArray jObservationIdArr, jobject jResourceResponse, jint jQoS)
\r
408 LOGD("OcPlatform_notifyListOfObservers3");
\r
409 if (!jResourceHandle)
\r
411 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
414 if (!jObservationIdArr)
\r
416 ThrowOcException(OC_STACK_INVALID_PARAM, "observationIdList cannot be null");
\r
419 if (!jResourceResponse)
\r
421 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
\r
425 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
426 env, jResourceHandle);
\r
427 if (!jniOcResourceHandle) return;
\r
429 JniOcResourceResponse* jniOcResourceResponse = JniOcResourceResponse::getJniOcResourceResponsePtr(
\r
430 env, jResourceResponse);
\r
431 if (!jniOcResourceResponse) return;
\r
433 int len = env->GetArrayLength(jObservationIdArr);
\r
434 uint8_t* bArr = (uint8_t*)env->GetByteArrayElements(jObservationIdArr, 0);
\r
436 ObservationIds observationIds;
\r
437 for (int i = 0; i < len; ++i)
\r
439 observationIds.push_back(bArr[i]);
\r
442 env->ReleaseByteArrayElements(jObservationIdArr, (jbyte*)bArr, 0);
\r
445 OCStackResult result = OCPlatform::notifyListOfObservers(
\r
446 jniOcResourceHandle->getOCResourceHandle(),
\r
448 jniOcResourceResponse->getOCResourceResponse(),
\r
449 JniUtils::getQOS(env, static_cast<int>(jQoS)));
\r
451 if (OC_STACK_OK != result)
\r
453 ThrowOcException(result, "Failed to notify all observers");
\r
456 catch (OCException& e)
\r
458 LOGE("%s", e.reason().c_str());
\r
459 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
464 * Class: org_iotivity_base_OcPlatform
\r
465 * Method: findResource0
\r
466 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnResourceFoundListener;)V
\r
468 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findResource0
\r
469 (JNIEnv *env, jclass clazz, jstring jHost, jstring jResourceUri, jint jConnectivityType, jobject jListener)
\r
471 LOGD("OcPlatform_findResource");
\r
475 host = env->GetStringUTFChars(jHost, NULL);
\r
477 std::string resourceUri;
\r
480 resourceUri = env->GetStringUTFChars(jResourceUri, NULL);
\r
484 ThrowOcException(OC_STACK_INVALID_PARAM, "onResourceFoundListener cannot be null");
\r
488 JniOnResourceFoundListener *onResFoundListener = AddOnResourceFoundListener(env, jListener);
\r
490 FindCallback findCallback = [onResFoundListener](std::shared_ptr<OCResource> resource)
\r
492 onResFoundListener->foundResourceCallback(resource);
\r
497 OCStackResult result = OCPlatform::findResource(
\r
500 JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
\r
503 if (OC_STACK_OK != result)
\r
505 ThrowOcException(result, "Find resource has failed");
\r
509 catch (OCException& e)
\r
511 LOGE("%s", e.reason().c_str());
\r
512 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
517 * Class: org_iotivity_base_OcPlatform
\r
518 * Method: findResource1
\r
519 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnResourceFoundListener;I)V
\r
521 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findResource1
\r
522 (JNIEnv *env, jclass clazz, jstring jHost, jstring jResourceUri, jint jConnectivityType, jobject jListener, jint jQoS)
\r
524 LOGD("OcPlatform_findResource");
\r
528 host = env->GetStringUTFChars(jHost, NULL);
\r
530 std::string resourceUri;
\r
533 resourceUri = env->GetStringUTFChars(jResourceUri, NULL);
\r
537 ThrowOcException(OC_STACK_INVALID_PARAM, "onResourceFoundListener cannot be null");
\r
540 JniOnResourceFoundListener *onResFoundListener = AddOnResourceFoundListener(env, jListener);
\r
542 FindCallback findCallback = [onResFoundListener](std::shared_ptr<OCResource> resource)
\r
544 onResFoundListener->foundResourceCallback(resource);
\r
549 OCStackResult result = OCPlatform::findResource(
\r
552 JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
\r
554 JniUtils::getQOS(env, static_cast<int>(jQoS)));
\r
556 if (OC_STACK_OK != result)
\r
558 ThrowOcException(result, "Find resource has failed");
\r
562 catch (OCException& e)
\r
564 LOGE("%s", e.reason().c_str());
\r
565 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
570 * Class: org_iotivity_base_OcPlatform
\r
571 * Method: getDeviceInfo0
\r
572 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeviceFoundListener;)V
\r
574 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDeviceInfo0
\r
575 (JNIEnv *env, jclass clazz, jstring jHost, jstring jResourceUri, jint jConnectivityType, jobject jListener)
\r
577 LOGD("OcPlatform_getDeviceInfo0");
\r
581 host = env->GetStringUTFChars(jHost, NULL);
\r
583 std::string resourceUri;
\r
586 resourceUri = env->GetStringUTFChars(jResourceUri, NULL);
\r
590 ThrowOcException(OC_STACK_INVALID_PARAM, "onDeviceFoundListener cannot be null");
\r
593 JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
\r
595 FindDeviceCallback findDeviceCallback = [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
\r
597 onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
\r
602 OCStackResult result = OCPlatform::getDeviceInfo(
\r
605 JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
\r
606 findDeviceCallback);
\r
608 if (OC_STACK_OK != result)
\r
610 ThrowOcException(result, "Find device has failed");
\r
613 catch (OCException& e)
\r
615 LOGE("%s", e.reason().c_str());
\r
616 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
621 * Class: org_iotivity_base_OcPlatform
\r
622 * Method: getDeviceInfo1
\r
623 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeviceFoundListener;I)V
\r
625 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDeviceInfo1
\r
626 (JNIEnv *env, jclass clazz, jstring jHost, jstring jResourceUri, jint jConnectivityType, jobject jListener, jint jQoS)
\r
628 LOGD("OcPlatform_getDeviceInfo1");
\r
632 host = env->GetStringUTFChars(jHost, NULL);
\r
634 std::string resourceUri;
\r
637 resourceUri = env->GetStringUTFChars(jResourceUri, NULL);
\r
641 ThrowOcException(OC_STACK_INVALID_PARAM, "onDeviceFoundListener cannot be null");
\r
644 JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
\r
646 FindDeviceCallback findDeviceCallback = [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
\r
648 onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
\r
653 OCStackResult result = OCPlatform::getDeviceInfo(
\r
656 JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
\r
657 findDeviceCallback,
\r
658 JniUtils::getQOS(env, static_cast<int>(jQoS)));
\r
660 if (OC_STACK_OK != result)
\r
662 ThrowOcException(result, "Find device has failed");
\r
665 catch (OCException& e)
\r
667 LOGE("%s", e.reason().c_str());
\r
668 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
673 * Class: org_iotivity_base_OcPlatform
\r
674 * Method: registerResource0
\r
675 * Signature: (Lorg/iotivity/base/OcResource;)Lorg/iotivity/base/OcResourceHandle;
\r
677 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_registerResource0
\r
678 (JNIEnv *env, jclass clazz, jobject jResource)
\r
680 LOGD("OcPlatform_registerResource");
\r
683 ThrowOcException(OC_STACK_INVALID_PARAM, "Resource cannot be null");
\r
686 JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, jResource);
\r
687 if (!resource) return nullptr;
\r
689 OCResourceHandle resourceHandle;
\r
692 OCStackResult result = OCPlatform::registerResource(
\r
694 resource->getOCResource());
\r
696 if (OC_STACK_OK != result)
\r
698 ThrowOcException(result, "register resource");
\r
701 catch (OCException& e)
\r
703 LOGE("%s", e.reason().c_str());
\r
704 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
708 JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);
\r
709 jlong handle = reinterpret_cast<jlong>(jniHandle);
\r
710 jobject jResourceHandle = env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);
\r
711 if (!jResourceHandle)
\r
713 LOGE("Failed to create OcResourceHandle");
\r
716 return jResourceHandle;
\r
720 * Class: org_iotivity_base_OcPlatform
\r
721 * Method: registerResource1
\r
722 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcPlatform/EntityHandler;I)Lorg/iotivity/base/OcResourceHandle;
\r
724 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_registerResource1
\r
725 (JNIEnv *env, jclass clazz, jstring jResourceUri, jstring jResourceTypeName, jstring jResourceInterface,
\r
726 jobject jListener, jint jResourceProperty)
\r
728 LOGI("OcPlatform_registerResource1");
\r
729 std::string resourceUri;
\r
732 resourceUri = env->GetStringUTFChars(jResourceUri, NULL);
\r
734 std::string resourceTypeName;
\r
735 if (jResourceTypeName)
\r
737 resourceTypeName = env->GetStringUTFChars(jResourceTypeName, NULL);
\r
739 std::string resourceInterface;
\r
740 if (jResourceInterface)
\r
742 resourceInterface = env->GetStringUTFChars(jResourceInterface, NULL);
\r
746 ThrowOcException(OC_STACK_INVALID_PARAM, "entityHandler cannot be null");
\r
749 JniEntityHandler* entityHandler = new JniEntityHandler(env, jListener);
\r
750 EntityHandler handleEntityCallback = [entityHandler](const std::shared_ptr<OCResourceRequest> request) ->
\r
751 OCEntityHandlerResult{
\r
752 return entityHandler->handleEntity(request);
\r
755 OCResourceHandle resourceHandle;
\r
758 OCStackResult result = OCPlatform::registerResource(
\r
763 handleEntityCallback,
\r
764 static_cast<int>(jResourceProperty));
\r
766 if (OC_STACK_OK != result)
\r
768 delete entityHandler;
\r
769 ThrowOcException(result, "register resource");
\r
773 catch (OCException& e)
\r
775 LOGE("%s", e.reason().c_str());
\r
776 delete entityHandler;
\r
777 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
781 JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);
\r
782 jlong handle = reinterpret_cast<jlong>(jniHandle);
\r
783 jobject jResourceHandle = env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);
\r
784 if (!jResourceHandle)
\r
786 LOGE("Failed to create OcResourceHandle");
\r
790 return jResourceHandle;
\r
794 * Class: org_iotivity_base_OcPlatform
\r
795 * Method: registerDeviceInfo0
\r
796 * 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
\r
798 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_registerDeviceInfo0
\r
801 jstring jDeviceName,
\r
803 jstring jDeviceUUID,
\r
804 jstring jContentType,
\r
806 jstring jManufacturerName,
\r
807 jstring jManufacturerUrl,
\r
808 jstring jModelNumber,
\r
809 jstring jDateOfManufacture,
\r
810 jstring jPlatformVersion,
\r
811 jstring jFirmwareVersion,
\r
812 jstring jSupportUrl)
\r
814 LOGI("OcPlatform_registerDeviceInfo");
\r
816 std::string deviceName;
\r
819 deviceName = env->GetStringUTFChars(jDeviceName, NULL);
\r
821 std::string hostName;
\r
824 hostName = env->GetStringUTFChars(jHostName, NULL);
\r
826 std::string deviceUUID;
\r
829 deviceUUID = env->GetStringUTFChars(jDeviceUUID, NULL);
\r
831 std::string contentType;
\r
834 contentType = env->GetStringUTFChars(jContentType, NULL);
\r
836 std::string version;
\r
839 version = env->GetStringUTFChars(jVersion, NULL);
\r
841 std::string manufacturerName;
\r
842 if (jManufacturerName)
\r
844 manufacturerName = env->GetStringUTFChars(jManufacturerName, NULL);
\r
846 std::string manufacturerUrl;
\r
847 if (jManufacturerUrl)
\r
849 manufacturerUrl = env->GetStringUTFChars(jManufacturerUrl, NULL);
\r
851 std::string modelNumber;
\r
854 modelNumber = env->GetStringUTFChars(jModelNumber, NULL);
\r
856 std::string dateOfManufacture;
\r
857 if (jDateOfManufacture)
\r
859 dateOfManufacture = env->GetStringUTFChars(jDateOfManufacture, NULL);
\r
861 std::string platformVersion;
\r
862 if (jPlatformVersion)
\r
864 platformVersion = env->GetStringUTFChars(jPlatformVersion, NULL);
\r
866 std::string firmwareVersion;
\r
867 if (jFirmwareVersion)
\r
869 firmwareVersion = env->GetStringUTFChars(jFirmwareVersion, NULL);
\r
871 std::string supportUrl;
\r
874 supportUrl = env->GetStringUTFChars(jSupportUrl, NULL);
\r
877 OCDeviceInfo deviceInfo;
\r
880 DuplicateString(&deviceInfo.contentType, contentType);
\r
881 DuplicateString(&deviceInfo.dateOfManufacture, dateOfManufacture);
\r
882 DuplicateString(&deviceInfo.deviceName, deviceName);
\r
883 DuplicateString(&deviceInfo.deviceUUID, deviceUUID);
\r
884 DuplicateString(&deviceInfo.firmwareVersion, firmwareVersion);
\r
885 DuplicateString(&deviceInfo.hostName, hostName);
\r
886 DuplicateString(&deviceInfo.manufacturerName, manufacturerName);
\r
887 DuplicateString(&deviceInfo.manufacturerUrl, manufacturerUrl);
\r
888 DuplicateString(&deviceInfo.modelNumber, modelNumber);
\r
889 DuplicateString(&deviceInfo.platformVersion, platformVersion);
\r
890 DuplicateString(&deviceInfo.supportUrl, supportUrl);
\r
891 DuplicateString(&deviceInfo.version, version);
\r
893 catch (std::exception &e)
\r
895 ThrowOcException(JNI_EXCEPTION, "Failed to register device info");
\r
901 OCStackResult result = OCPlatform::registerDeviceInfo(deviceInfo);
\r
903 delete deviceInfo.contentType;
\r
904 delete deviceInfo.dateOfManufacture;
\r
905 delete deviceInfo.deviceName;
\r
906 delete deviceInfo.deviceUUID;
\r
907 delete deviceInfo.firmwareVersion;
\r
908 delete deviceInfo.hostName;
\r
909 delete deviceInfo.manufacturerName;
\r
910 delete deviceInfo.manufacturerUrl;
\r
911 delete deviceInfo.modelNumber;
\r
912 delete deviceInfo.platformVersion;
\r
913 delete deviceInfo.supportUrl;
\r
914 delete deviceInfo.version;
\r
916 if (OC_STACK_OK != result)
\r
918 ThrowOcException(result, "Failed to register device info");
\r
922 catch (OCException& e)
\r
924 LOGE("%s", e.reason().c_str());
\r
925 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
930 * Class: org_iotivity_base_OcPlatform
\r
931 * Method: unregisterResource0
\r
932 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V
\r
934 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unregisterResource0
\r
935 (JNIEnv *env, jclass clazz, jobject jResourceHandle)
\r
937 LOGI("OcPlatform_unregisterResource");
\r
938 if (!jResourceHandle)
\r
940 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
943 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
944 env, jResourceHandle);
\r
945 if (!jniOcResourceHandle) return;
\r
949 OCResourceHandle resHandle = jniOcResourceHandle->getOCResourceHandle();
\r
950 OCStackResult result = OCPlatform::unregisterResource(resHandle);
\r
951 if (OC_STACK_OK != result)
\r
953 ThrowOcException(result, "Failed to unregister resource");
\r
956 catch (OCException& e)
\r
958 LOGE("%s", e.reason().c_str());
\r
959 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
964 * Class: org_iotivity_base_OcPlatform
\r
965 * Method: bindResource0
\r
966 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
\r
968 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResource0
\r
969 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobject jResourceHandle)
\r
971 LOGI("OcPlatform_bindResource");
\r
972 if (!jResourceCollectionHandle)
\r
974 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
\r
977 if (!jResourceHandle)
\r
979 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
982 JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
983 env, jResourceCollectionHandle);
\r
984 if (!jniOcResourceCollectionHandle) return;
\r
986 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
987 env, jResourceHandle);
\r
988 if (!jniOcResourceHandle) return;
\r
992 OCStackResult result = OCPlatform::bindResource(
\r
993 jniOcResourceCollectionHandle->getOCResourceHandle(),
\r
994 jniOcResourceHandle->getOCResourceHandle()
\r
997 if (OC_STACK_OK != result)
\r
999 ThrowOcException(result, "Failed to bind resource");
\r
1002 catch (OCException& e)
\r
1004 LOGE("%s", e.reason().c_str());
\r
1005 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1010 * Class: org_iotivity_base_OcPlatform
\r
1011 * Method: bindResources0
\r
1012 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
\r
1014 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResources0
\r
1015 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobjectArray jResourceHandleArray)
\r
1017 LOGI("OcPlatform_bindResources");
\r
1019 if (!jResourceCollectionHandle)
\r
1021 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
\r
1024 if (!jResourceHandleArray)
\r
1026 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
\r
1030 JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1031 env, jResourceCollectionHandle);
\r
1032 if (!jniOcResourceCollectionHandle) return;
\r
1034 std::vector<OCResourceHandle> resourceHandleList;
\r
1035 int len = env->GetArrayLength(jResourceHandleArray);
\r
1036 for (int i = 0; i < len; ++i)
\r
1038 jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
\r
1039 if (!jResourceHandle)
\r
1041 ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
\r
1045 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1046 env, jResourceHandle);
\r
1047 if (!jniOcResourceHandle) return;
\r
1049 resourceHandleList.push_back(
\r
1050 jniOcResourceHandle->getOCResourceHandle());
\r
1055 OCStackResult result = OCPlatform::bindResources(
\r
1056 jniOcResourceCollectionHandle->getOCResourceHandle(),
\r
1057 resourceHandleList
\r
1060 if (OC_STACK_OK != result)
\r
1062 ThrowOcException(result, "Failed to bind resources");
\r
1065 catch (OCException& e)
\r
1067 LOGE("%s", e.reason().c_str());
\r
1068 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1073 * Class: org_iotivity_base_OcPlatform
\r
1074 * Method: unbindResource0
\r
1075 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
\r
1077 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResource0
\r
1078 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobject jResourceHandle)
\r
1080 LOGI("OcPlatform_unbindResource");
\r
1081 if (!jResourceCollectionHandle)
\r
1083 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
\r
1086 if (!jResourceHandle)
\r
1088 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
1092 JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1093 env, jResourceCollectionHandle);
\r
1094 if (!jniOcResourceCollectionHandle) return;
\r
1096 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1097 env, jResourceHandle);
\r
1098 if (!jniOcResourceHandle) return;
\r
1102 OCStackResult result = OCPlatform::unbindResource(
\r
1103 jniOcResourceCollectionHandle->getOCResourceHandle(),
\r
1104 jniOcResourceHandle->getOCResourceHandle()
\r
1107 if (OC_STACK_OK != result)
\r
1109 ThrowOcException(result, "Failed to unbind resource");
\r
1112 catch (OCException& e)
\r
1114 LOGE("%s", e.reason().c_str());
\r
1115 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1120 * Class: org_iotivity_base_OcPlatform
\r
1121 * Method: unbindResources0
\r
1122 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
\r
1124 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResources0
\r
1125 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobjectArray jResourceHandleArray)
\r
1127 LOGI("OcPlatform_unbindResources");
\r
1128 if (!jResourceCollectionHandle)
\r
1130 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
\r
1133 if (!jResourceHandleArray)
\r
1135 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
\r
1139 JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1140 env, jResourceCollectionHandle);
\r
1141 if (!jniOcResourceCollectionHandle) return;
\r
1143 std::vector<OCResourceHandle> resourceHandleList;
\r
1144 int len = env->GetArrayLength(jResourceHandleArray);
\r
1145 for (int i = 0; i < len; ++i)
\r
1147 jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
\r
1148 if (!jResourceHandle)
\r
1150 ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
\r
1154 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1155 env, jResourceHandle);
\r
1156 if (!jniOcResourceHandle) return;
\r
1158 resourceHandleList.push_back(
\r
1159 jniOcResourceHandle->getOCResourceHandle());
\r
1164 OCStackResult result = OCPlatform::unbindResources(
\r
1165 jniOcResourceCollectionHandle->getOCResourceHandle(),
\r
1166 resourceHandleList
\r
1169 if (OC_STACK_OK != result)
\r
1171 ThrowOcException(result, "Failed to unbind resources");
\r
1174 catch (OCException& e)
\r
1176 LOGE("%s", e.reason().c_str());
\r
1177 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1182 * Class: org_iotivity_base_OcPlatform
\r
1183 * Method: bindTypeToResource0
\r
1184 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
\r
1186 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindTypeToResource0
\r
1187 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jstring jResourceTypeName)
\r
1189 LOGI("OcPlatform_bindTypeToResource");
\r
1190 if (!jResourceHandle)
\r
1192 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
1195 std::string typeName;
\r
1196 if (jResourceTypeName)
\r
1198 typeName = env->GetStringUTFChars(jResourceTypeName, NULL);
\r
1201 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1202 env, jResourceHandle);
\r
1203 if (!jniOcResourceHandle) return;
\r
1207 OCStackResult result = OCPlatform::bindTypeToResource(
\r
1208 jniOcResourceHandle->getOCResourceHandle(),
\r
1212 if (OC_STACK_OK != result)
\r
1214 ThrowOcException(result, "Failed to bind type to resource");
\r
1217 catch (OCException& e)
\r
1219 LOGE("%s", e.reason().c_str());
\r
1220 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1225 * Class: org_iotivity_base_OcPlatform
\r
1226 * Method: bindInterfaceToResource0
\r
1227 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
\r
1229 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindInterfaceToResource0
\r
1230 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jstring jResourceInterfaceName)
\r
1232 LOGI("OcPlatform_bindInterfaceToResource");
\r
1233 if (!jResourceHandle)
\r
1235 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
1238 std::string interfaceName;
\r
1239 if (jResourceInterfaceName)
\r
1241 interfaceName = env->GetStringUTFChars(jResourceInterfaceName, NULL);
\r
1244 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1245 env, jResourceHandle);
\r
1246 if (!jniOcResourceHandle) return;
\r
1250 OCStackResult result = OCPlatform::bindInterfaceToResource(
\r
1251 jniOcResourceHandle->getOCResourceHandle(),
\r
1255 if (OC_STACK_OK != result)
\r
1257 ThrowOcException(result, "Failed to bind interface to resource");
\r
1260 catch (OCException& e)
\r
1262 LOGE("%s", e.reason().c_str());
\r
1263 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1268 * Class: org_iotivity_base_OcPlatform
\r
1269 * Method: startPresence0
\r
1272 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_startPresence0
\r
1273 (JNIEnv *env, jclass clazz, jint ttl)
\r
1275 LOGI("OcPlatform_startPresence");
\r
1279 OCStackResult result = OCPlatform::startPresence((unsigned int)ttl);
\r
1281 if (OC_STACK_OK != result)
\r
1283 ThrowOcException(result, "Failed to start presence");
\r
1286 catch (OCException& e)
\r
1288 LOGE("%s", e.reason().c_str());
\r
1289 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1294 * Class: org_iotivity_base_OcPlatform
\r
1295 * Method: stopPresence0
\r
1298 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_stopPresence0
\r
1299 (JNIEnv *env, jclass clazz)
\r
1301 LOGI("OcPlatform_stopPresence");
\r
1305 OCStackResult result = OCPlatform::stopPresence();
\r
1307 if (OC_STACK_OK != result)
\r
1309 ThrowOcException(result, "Failed to stop presence");
\r
1312 catch (OCException& e)
\r
1314 LOGE("%s", e.reason().c_str());
\r
1315 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1320 * Class: org_iotivity_base_OcPlatform
\r
1321 * Method: subscribePresence0
\r
1322 * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
\r
1324 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence0
\r
1325 (JNIEnv *env, jclass clazz, jstring jHost, jint jConnectivityType, jobject jListener)
\r
1327 LOGD("OcPlatform_subscribePresence");
\r
1331 host = env->GetStringUTFChars(jHost, NULL);
\r
1335 ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
\r
1339 JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
\r
1341 SubscribeCallback subscribeCallback = [onPresenceListener](OCStackResult result, const unsigned int nonce,
\r
1342 const std::string& hostAddress)
\r
1344 onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
\r
1347 OCPlatform::OCPresenceHandle presenceHandle;
\r
1350 OCStackResult result = OCPlatform::subscribePresence(
\r
1353 JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
\r
1354 subscribeCallback);
\r
1356 if (OC_STACK_OK != result)
\r
1358 ThrowOcException(result, "subscribe presence has failed");
\r
1361 catch (OCException& e)
\r
1363 LOGE("%s", e.reason().c_str());
\r
1364 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1368 JniOcPresenceHandle* jniPresenceHandle = new JniOcPresenceHandle(onPresenceListener, presenceHandle);
\r
1369 jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
\r
1370 jobject jPresenceHandle = env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
\r
1371 if (!jPresenceHandle)
\r
1373 LOGE("Failed to create OcPresenceHandle");
\r
1374 delete jniPresenceHandle;
\r
1377 return jPresenceHandle;
\r
1381 * Class: org_iotivity_base_OcPlatform
\r
1382 * Method: subscribePresence1
\r
1383 * Signature: (Ljava/lang/String;Ljava/lang/String;I
\r
1384 Lorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
\r
1386 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence1
\r
1387 (JNIEnv *env, jclass clazz, jstring jHost, jstring jResourceType, jint jConnectivityType, jobject jListener)
\r
1389 LOGD("OcPlatform_subscribePresence1");
\r
1393 host = env->GetStringUTFChars(jHost, NULL);
\r
1395 std::string resourceType;
\r
1396 if (jResourceType)
\r
1398 resourceType = env->GetStringUTFChars(jResourceType, NULL);
\r
1402 ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
\r
1406 JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
\r
1408 SubscribeCallback subscribeCallback = [onPresenceListener](OCStackResult result,
\r
1409 const unsigned int nonce, const std::string& hostAddress)
\r
1411 onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
\r
1414 OCPlatform::OCPresenceHandle presenceHandle;
\r
1417 OCStackResult result = OCPlatform::subscribePresence(
\r
1421 JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
\r
1422 subscribeCallback);
\r
1424 if (OC_STACK_OK != result)
\r
1426 ThrowOcException(result, "subscribe presence has failed");
\r
1429 catch (OCException& e)
\r
1431 LOGE("%s", e.reason().c_str());
\r
1432 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1436 JniOcPresenceHandle* jniPresenceHandle = new JniOcPresenceHandle(onPresenceListener, presenceHandle);
\r
1437 jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
\r
1438 jobject jPresenceHandle = env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
\r
1439 if (!jPresenceHandle)
\r
1441 LOGE("Failed to create OcPresenceHandle");
\r
1442 delete jniPresenceHandle;
\r
1444 return jPresenceHandle;
\r
1448 * Class: org_iotivity_base_OcPlatform
\r
1449 * Method: unsubscribePresence0
\r
1450 * Signature: (Lorg/iotivity/base/OcPresenceHandle;)V
\r
1452 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unsubscribePresence0
\r
1453 (JNIEnv *env, jclass clazz, jobject jPresenceHandle)
\r
1455 LOGD("OcPlatform_unsubscribePresence");
\r
1456 if (!jPresenceHandle)
\r
1458 ThrowOcException(OC_STACK_INVALID_PARAM, "presenceHandle cannot be null");
\r
1461 JniOcPresenceHandle* jniPresenceHandle = JniOcPresenceHandle::getJniOcPresenceHandlePtr(env, jPresenceHandle);
\r
1462 if (!jniPresenceHandle) return;
\r
1464 OCPresenceHandle presenceHandle = jniPresenceHandle->getOCPresenceHandle();
\r
1468 OCStackResult result = OCPlatform::unsubscribePresence(presenceHandle);
\r
1470 if (OC_STACK_OK != result)
\r
1472 ThrowOcException(result, "unsubscribe presence has failed");
\r
1475 jweak jwOnPresenceListener = jniPresenceHandle->getJniOnPresenceListener()->getJWListener();
\r
1476 if (jwOnPresenceListener)
\r
1478 RemoveOnPresenceListener(env, jwOnPresenceListener);
\r
1481 catch (OCException& e)
\r
1483 LOGE("%s", e.reason().c_str());
\r
1484 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1489 * Class: org_iotivity_base_OcPlatform
\r
1490 * Method: constructResourceObject0
\r
1491 * Signature: (Ljava/lang/String;Ljava/lang/String;IZ[Ljava/lang/String;[Ljava/lang/String;)
\r
1492 Lorg/iotivity/base/OcResource;
\r
1494 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_constructResourceObject0
\r
1495 (JNIEnv *env, jclass clazz, jstring jHost, jstring jUri, jint jConnectivityType,
\r
1496 jboolean jIsObservable, jobjectArray jResourceTypeArray, jobjectArray jInterfaceArray)
\r
1498 LOGD("OcPlatform_constructResourceObject");
\r
1502 host = env->GetStringUTFChars(jHost, NULL);
\r
1507 uri = env->GetStringUTFChars(jUri, NULL);
\r
1509 if (!jResourceTypeArray)
\r
1511 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceTypeList cannot be null");
\r
1514 if (!jInterfaceArray)
\r
1516 ThrowOcException(OC_STACK_INVALID_PARAM, "interfaceList cannot be null");
\r
1520 std::vector<std::string> resourceTypes;
\r
1521 JniUtils::convertJavaStrArrToStrVector(env, jResourceTypeArray, resourceTypes);
\r
1523 std::vector<std::string> interfaces;
\r
1524 JniUtils::convertJavaStrArrToStrVector(env, jInterfaceArray, interfaces);
\r
1526 std::shared_ptr<OCResource> resource = OCPlatform::constructResourceObject(
\r
1529 JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
\r
1530 static_cast<bool>(jIsObservable),
\r
1536 ThrowOcException(OC_STACK_ERROR, "Failed to create OCResource");
\r
1540 JniOcResource *jniOcResource = new JniOcResource(resource);
\r
1541 jlong handle = reinterpret_cast<jlong>(jniOcResource);
\r
1543 jobject jResource = env->NewObject(g_cls_OcResource, g_mid_OcResource_ctor);
\r
1546 delete jniOcResource;
\r
1549 SetHandle<JniOcResource>(env, jResource, jniOcResource);
\r
1550 if (env->ExceptionCheck())
\r
1552 delete jniOcResource;
\r
1559 * Class: org_iotivity_base_OcPlatform
\r
1560 * Method: sendResponse0
\r
1561 * Signature: (Lorg/iotivity/base/OcResourceResponse;)V
\r
1563 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_sendResponse0
\r
1564 (JNIEnv *env, jclass clazz, jobject jResourceResponse)
\r
1566 LOGD("OcPlatform_sendResponse");
\r
1567 if (!jResourceResponse)
\r
1569 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
\r
1573 JniOcResourceResponse *jniResponse = JniOcResourceResponse::getJniOcResourceResponsePtr(
\r
1574 env, jResourceResponse);
\r
1575 if (!jniResponse) return;
\r
1579 OCStackResult result = OCPlatform::sendResponse(jniResponse->getOCResourceResponse());
\r
1581 if (OC_STACK_OK != result)
\r
1583 ThrowOcException(result, "failed to send response");
\r
1586 catch (OCException& e)
\r
1588 LOGE("%s", e.reason().c_str());
\r
1589 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r