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 LOGI("OcPlatform_registerDeviceInfo");
\r
805 std::string deviceName;
\r
808 deviceName = env->GetStringUTFChars(jDeviceName, NULL);
\r
811 OCDeviceInfo deviceInfo;
\r
814 DuplicateString(&deviceInfo.deviceName, deviceName);
\r
816 catch (std::exception &e)
\r
818 ThrowOcException(JNI_EXCEPTION, "Failed to construct device info");
\r
824 OCStackResult result = OCPlatform::registerDeviceInfo(deviceInfo);
\r
826 delete deviceInfo.deviceName;
\r
828 if (OC_STACK_OK != result)
\r
830 ThrowOcException(result, "Failed to register device info");
\r
834 catch (OCException& e)
\r
836 LOGE("%s", e.reason().c_str());
\r
837 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
842 * Class: org_iotivity_base_OcPlatform
\r
843 * Method: unregisterResource0
\r
844 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V
\r
846 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unregisterResource0
\r
847 (JNIEnv *env, jclass clazz, jobject jResourceHandle)
\r
849 LOGI("OcPlatform_unregisterResource");
\r
850 if (!jResourceHandle)
\r
852 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
855 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
856 env, jResourceHandle);
\r
857 if (!jniOcResourceHandle) return;
\r
861 OCResourceHandle resHandle = jniOcResourceHandle->getOCResourceHandle();
\r
862 OCStackResult result = OCPlatform::unregisterResource(resHandle);
\r
863 if (OC_STACK_OK != result)
\r
865 ThrowOcException(result, "Failed to unregister resource");
\r
868 catch (OCException& e)
\r
870 LOGE("%s", e.reason().c_str());
\r
871 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
876 * Class: org_iotivity_base_OcPlatform
\r
877 * Method: bindResource0
\r
878 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
\r
880 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResource0
\r
881 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobject jResourceHandle)
\r
883 LOGI("OcPlatform_bindResource");
\r
884 if (!jResourceCollectionHandle)
\r
886 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
\r
889 if (!jResourceHandle)
\r
891 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
894 JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
895 env, jResourceCollectionHandle);
\r
896 if (!jniOcResourceCollectionHandle) return;
\r
898 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
899 env, jResourceHandle);
\r
900 if (!jniOcResourceHandle) return;
\r
904 OCStackResult result = OCPlatform::bindResource(
\r
905 jniOcResourceCollectionHandle->getOCResourceHandle(),
\r
906 jniOcResourceHandle->getOCResourceHandle()
\r
909 if (OC_STACK_OK != result)
\r
911 ThrowOcException(result, "Failed to bind resource");
\r
914 catch (OCException& e)
\r
916 LOGE("%s", e.reason().c_str());
\r
917 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
922 * Class: org_iotivity_base_OcPlatform
\r
923 * Method: bindResources0
\r
924 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
\r
926 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResources0
\r
927 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobjectArray jResourceHandleArray)
\r
929 LOGI("OcPlatform_bindResources");
\r
931 if (!jResourceCollectionHandle)
\r
933 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
\r
936 if (!jResourceHandleArray)
\r
938 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
\r
942 JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
943 env, jResourceCollectionHandle);
\r
944 if (!jniOcResourceCollectionHandle) return;
\r
946 std::vector<OCResourceHandle> resourceHandleList;
\r
947 int len = env->GetArrayLength(jResourceHandleArray);
\r
948 for (int i = 0; i < len; ++i)
\r
950 jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
\r
951 if (!jResourceHandle)
\r
953 ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
\r
957 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
958 env, jResourceHandle);
\r
959 if (!jniOcResourceHandle) return;
\r
961 resourceHandleList.push_back(
\r
962 jniOcResourceHandle->getOCResourceHandle());
\r
967 OCStackResult result = OCPlatform::bindResources(
\r
968 jniOcResourceCollectionHandle->getOCResourceHandle(),
\r
972 if (OC_STACK_OK != result)
\r
974 ThrowOcException(result, "Failed to bind resources");
\r
977 catch (OCException& e)
\r
979 LOGE("%s", e.reason().c_str());
\r
980 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
985 * Class: org_iotivity_base_OcPlatform
\r
986 * Method: unbindResource0
\r
987 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
\r
989 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResource0
\r
990 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobject jResourceHandle)
\r
992 LOGI("OcPlatform_unbindResource");
\r
993 if (!jResourceCollectionHandle)
\r
995 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
\r
998 if (!jResourceHandle)
\r
1000 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
1004 JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1005 env, jResourceCollectionHandle);
\r
1006 if (!jniOcResourceCollectionHandle) return;
\r
1008 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1009 env, jResourceHandle);
\r
1010 if (!jniOcResourceHandle) return;
\r
1014 OCStackResult result = OCPlatform::unbindResource(
\r
1015 jniOcResourceCollectionHandle->getOCResourceHandle(),
\r
1016 jniOcResourceHandle->getOCResourceHandle()
\r
1019 if (OC_STACK_OK != result)
\r
1021 ThrowOcException(result, "Failed to unbind resource");
\r
1024 catch (OCException& e)
\r
1026 LOGE("%s", e.reason().c_str());
\r
1027 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1032 * Class: org_iotivity_base_OcPlatform
\r
1033 * Method: unbindResources0
\r
1034 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
\r
1036 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResources0
\r
1037 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobjectArray jResourceHandleArray)
\r
1039 LOGI("OcPlatform_unbindResources");
\r
1040 if (!jResourceCollectionHandle)
\r
1042 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
\r
1045 if (!jResourceHandleArray)
\r
1047 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
\r
1051 JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1052 env, jResourceCollectionHandle);
\r
1053 if (!jniOcResourceCollectionHandle) return;
\r
1055 std::vector<OCResourceHandle> resourceHandleList;
\r
1056 int len = env->GetArrayLength(jResourceHandleArray);
\r
1057 for (int i = 0; i < len; ++i)
\r
1059 jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
\r
1060 if (!jResourceHandle)
\r
1062 ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
\r
1066 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1067 env, jResourceHandle);
\r
1068 if (!jniOcResourceHandle) return;
\r
1070 resourceHandleList.push_back(
\r
1071 jniOcResourceHandle->getOCResourceHandle());
\r
1076 OCStackResult result = OCPlatform::unbindResources(
\r
1077 jniOcResourceCollectionHandle->getOCResourceHandle(),
\r
1078 resourceHandleList
\r
1081 if (OC_STACK_OK != result)
\r
1083 ThrowOcException(result, "Failed to unbind resources");
\r
1086 catch (OCException& e)
\r
1088 LOGE("%s", e.reason().c_str());
\r
1089 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1094 * Class: org_iotivity_base_OcPlatform
\r
1095 * Method: bindTypeToResource0
\r
1096 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
\r
1098 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindTypeToResource0
\r
1099 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jstring jResourceTypeName)
\r
1101 LOGI("OcPlatform_bindTypeToResource");
\r
1102 if (!jResourceHandle)
\r
1104 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
1107 std::string typeName;
\r
1108 if (jResourceTypeName)
\r
1110 typeName = env->GetStringUTFChars(jResourceTypeName, NULL);
\r
1113 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1114 env, jResourceHandle);
\r
1115 if (!jniOcResourceHandle) return;
\r
1119 OCStackResult result = OCPlatform::bindTypeToResource(
\r
1120 jniOcResourceHandle->getOCResourceHandle(),
\r
1124 if (OC_STACK_OK != result)
\r
1126 ThrowOcException(result, "Failed to bind type to resource");
\r
1129 catch (OCException& e)
\r
1131 LOGE("%s", e.reason().c_str());
\r
1132 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1137 * Class: org_iotivity_base_OcPlatform
\r
1138 * Method: bindInterfaceToResource0
\r
1139 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
\r
1141 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindInterfaceToResource0
\r
1142 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jstring jResourceInterfaceName)
\r
1144 LOGI("OcPlatform_bindInterfaceToResource");
\r
1145 if (!jResourceHandle)
\r
1147 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
1150 std::string interfaceName;
\r
1151 if (jResourceInterfaceName)
\r
1153 interfaceName = env->GetStringUTFChars(jResourceInterfaceName, NULL);
\r
1156 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1157 env, jResourceHandle);
\r
1158 if (!jniOcResourceHandle) return;
\r
1162 OCStackResult result = OCPlatform::bindInterfaceToResource(
\r
1163 jniOcResourceHandle->getOCResourceHandle(),
\r
1167 if (OC_STACK_OK != result)
\r
1169 ThrowOcException(result, "Failed to bind interface to resource");
\r
1172 catch (OCException& e)
\r
1174 LOGE("%s", e.reason().c_str());
\r
1175 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1180 * Class: org_iotivity_base_OcPlatform
\r
1181 * Method: startPresence0
\r
1184 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_startPresence0
\r
1185 (JNIEnv *env, jclass clazz, jint ttl)
\r
1187 LOGI("OcPlatform_startPresence");
\r
1191 OCStackResult result = OCPlatform::startPresence((unsigned int)ttl);
\r
1193 if (OC_STACK_OK != result)
\r
1195 ThrowOcException(result, "Failed to start presence");
\r
1198 catch (OCException& e)
\r
1200 LOGE("%s", e.reason().c_str());
\r
1201 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1206 * Class: org_iotivity_base_OcPlatform
\r
1207 * Method: stopPresence0
\r
1210 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_stopPresence0
\r
1211 (JNIEnv *env, jclass clazz)
\r
1213 LOGI("OcPlatform_stopPresence");
\r
1217 OCStackResult result = OCPlatform::stopPresence();
\r
1219 if (OC_STACK_OK != result)
\r
1221 ThrowOcException(result, "Failed to stop presence");
\r
1224 catch (OCException& e)
\r
1226 LOGE("%s", e.reason().c_str());
\r
1227 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1232 * Class: org_iotivity_base_OcPlatform
\r
1233 * Method: subscribePresence0
\r
1234 * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
\r
1236 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence0
\r
1237 (JNIEnv *env, jclass clazz, jstring jHost, jint jConnectivityType, jobject jListener)
\r
1239 LOGD("OcPlatform_subscribePresence");
\r
1243 host = env->GetStringUTFChars(jHost, NULL);
\r
1247 ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
\r
1251 JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
\r
1253 SubscribeCallback subscribeCallback = [onPresenceListener](OCStackResult result, const unsigned int nonce,
\r
1254 const std::string& hostAddress)
\r
1256 onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
\r
1259 OCPlatform::OCPresenceHandle presenceHandle;
\r
1262 OCStackResult result = OCPlatform::subscribePresence(
\r
1265 JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
\r
1266 subscribeCallback);
\r
1268 if (OC_STACK_OK != result)
\r
1270 ThrowOcException(result, "subscribe presence has failed");
\r
1273 catch (OCException& e)
\r
1275 LOGE("%s", e.reason().c_str());
\r
1276 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1280 JniOcPresenceHandle* jniPresenceHandle = new JniOcPresenceHandle(onPresenceListener, presenceHandle);
\r
1281 jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
\r
1282 jobject jPresenceHandle = env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
\r
1283 if (!jPresenceHandle)
\r
1285 LOGE("Failed to create OcPresenceHandle");
\r
1286 delete jniPresenceHandle;
\r
1289 return jPresenceHandle;
\r
1293 * Class: org_iotivity_base_OcPlatform
\r
1294 * Method: subscribePresence1
\r
1295 * Signature: (Ljava/lang/String;Ljava/lang/String;I
\r
1296 Lorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
\r
1298 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence1
\r
1299 (JNIEnv *env, jclass clazz, jstring jHost, jstring jResourceType, jint jConnectivityType, jobject jListener)
\r
1301 LOGD("OcPlatform_subscribePresence1");
\r
1305 host = env->GetStringUTFChars(jHost, NULL);
\r
1307 std::string resourceType;
\r
1308 if (jResourceType)
\r
1310 resourceType = env->GetStringUTFChars(jResourceType, NULL);
\r
1314 ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
\r
1318 JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
\r
1320 SubscribeCallback subscribeCallback = [onPresenceListener](OCStackResult result,
\r
1321 const unsigned int nonce, const std::string& hostAddress)
\r
1323 onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
\r
1326 OCPlatform::OCPresenceHandle presenceHandle;
\r
1329 OCStackResult result = OCPlatform::subscribePresence(
\r
1333 JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
\r
1334 subscribeCallback);
\r
1336 if (OC_STACK_OK != result)
\r
1338 ThrowOcException(result, "subscribe presence has failed");
\r
1341 catch (OCException& e)
\r
1343 LOGE("%s", e.reason().c_str());
\r
1344 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1348 JniOcPresenceHandle* jniPresenceHandle = new JniOcPresenceHandle(onPresenceListener, presenceHandle);
\r
1349 jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
\r
1350 jobject jPresenceHandle = env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
\r
1351 if (!jPresenceHandle)
\r
1353 LOGE("Failed to create OcPresenceHandle");
\r
1354 delete jniPresenceHandle;
\r
1356 return jPresenceHandle;
\r
1360 * Class: org_iotivity_base_OcPlatform
\r
1361 * Method: unsubscribePresence0
\r
1362 * Signature: (Lorg/iotivity/base/OcPresenceHandle;)V
\r
1364 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unsubscribePresence0
\r
1365 (JNIEnv *env, jclass clazz, jobject jPresenceHandle)
\r
1367 LOGD("OcPlatform_unsubscribePresence");
\r
1368 if (!jPresenceHandle)
\r
1370 ThrowOcException(OC_STACK_INVALID_PARAM, "presenceHandle cannot be null");
\r
1373 JniOcPresenceHandle* jniPresenceHandle = JniOcPresenceHandle::getJniOcPresenceHandlePtr(env, jPresenceHandle);
\r
1374 if (!jniPresenceHandle) return;
\r
1376 OCPresenceHandle presenceHandle = jniPresenceHandle->getOCPresenceHandle();
\r
1380 OCStackResult result = OCPlatform::unsubscribePresence(presenceHandle);
\r
1382 if (OC_STACK_OK != result)
\r
1384 ThrowOcException(result, "unsubscribe presence has failed");
\r
1387 jweak jwOnPresenceListener = jniPresenceHandle->getJniOnPresenceListener()->getJWListener();
\r
1388 if (jwOnPresenceListener)
\r
1390 RemoveOnPresenceListener(env, jwOnPresenceListener);
\r
1393 catch (OCException& e)
\r
1395 LOGE("%s", e.reason().c_str());
\r
1396 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1401 * Class: org_iotivity_base_OcPlatform
\r
1402 * Method: constructResourceObject0
\r
1403 * Signature: (Ljava/lang/String;Ljava/lang/String;IZ[Ljava/lang/String;[Ljava/lang/String;)
\r
1404 Lorg/iotivity/base/OcResource;
\r
1406 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_constructResourceObject0
\r
1407 (JNIEnv *env, jclass clazz, jstring jHost, jstring jUri, jint jConnectivityType,
\r
1408 jboolean jIsObservable, jobjectArray jResourceTypeArray, jobjectArray jInterfaceArray)
\r
1410 LOGD("OcPlatform_constructResourceObject");
\r
1414 host = env->GetStringUTFChars(jHost, NULL);
\r
1419 uri = env->GetStringUTFChars(jUri, NULL);
\r
1421 if (!jResourceTypeArray)
\r
1423 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceTypeList cannot be null");
\r
1426 if (!jInterfaceArray)
\r
1428 ThrowOcException(OC_STACK_INVALID_PARAM, "interfaceList cannot be null");
\r
1432 std::vector<std::string> resourceTypes;
\r
1433 JniUtils::convertJavaStrArrToStrVector(env, jResourceTypeArray, resourceTypes);
\r
1435 std::vector<std::string> interfaces;
\r
1436 JniUtils::convertJavaStrArrToStrVector(env, jInterfaceArray, interfaces);
\r
1438 std::shared_ptr<OCResource> resource = OCPlatform::constructResourceObject(
\r
1441 JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
\r
1442 static_cast<bool>(jIsObservable),
\r
1448 ThrowOcException(OC_STACK_ERROR, "Failed to create OCResource");
\r
1452 JniOcResource *jniOcResource = new JniOcResource(resource);
\r
1453 jlong handle = reinterpret_cast<jlong>(jniOcResource);
\r
1455 jobject jResource = env->NewObject(g_cls_OcResource, g_mid_OcResource_ctor);
\r
1458 delete jniOcResource;
\r
1461 SetHandle<JniOcResource>(env, jResource, jniOcResource);
\r
1462 if (env->ExceptionCheck())
\r
1464 delete jniOcResource;
\r
1471 * Class: org_iotivity_base_OcPlatform
\r
1472 * Method: sendResponse0
\r
1473 * Signature: (Lorg/iotivity/base/OcResourceResponse;)V
\r
1475 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_sendResponse0
\r
1476 (JNIEnv *env, jclass clazz, jobject jResourceResponse)
\r
1478 LOGD("OcPlatform_sendResponse");
\r
1479 if (!jResourceResponse)
\r
1481 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
\r
1485 JniOcResourceResponse *jniResponse = JniOcResourceResponse::getJniOcResourceResponsePtr(
\r
1486 env, jResourceResponse);
\r
1487 if (!jniResponse) return;
\r
1491 OCStackResult result = OCPlatform::sendResponse(jniResponse->getOCResourceResponse());
\r
1493 if (OC_STACK_OK != result)
\r
1495 ThrowOcException(result, "failed to send response");
\r
1498 catch (OCException& e)
\r
1500 LOGE("%s", e.reason().c_str());
\r
1501 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r