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 "JniOcSecurity.h"
29 #include "JniUtils.h"
\r
33 JniOnResourceFoundListener* AddOnResourceFoundListener(JNIEnv* env, jobject jListener)
\r
35 JniOnResourceFoundListener *onResourceFoundListener = NULL;
\r
37 resourceFoundMapLock.lock();
\r
39 for (auto it = onResourceFoundListenerMap.begin(); it != onResourceFoundListenerMap.end(); ++it)
\r
41 if (env->IsSameObject(jListener, it->first))
\r
43 auto refPair = it->second;
\r
44 onResourceFoundListener = refPair.first;
\r
46 it->second = refPair;
\r
47 onResourceFoundListenerMap.insert(*it);
\r
48 LOGD("OnResourceFoundListener: ref. count incremented");
\r
53 if (!onResourceFoundListener)
\r
55 onResourceFoundListener = new JniOnResourceFoundListener(env, jListener, RemoveOnResourceFoundListener);
\r
56 jobject jgListener = env->NewGlobalRef(jListener);
\r
58 onResourceFoundListenerMap.insert(std::pair < jobject, std::pair < JniOnResourceFoundListener*,
\r
59 int >> (jgListener, std::pair<JniOnResourceFoundListener*, int>(onResourceFoundListener, 1)));
\r
60 LOGD("OnResourceFoundListener: new listener");
\r
62 resourceFoundMapLock.unlock();
\r
63 return onResourceFoundListener;
\r
66 void RemoveOnResourceFoundListener(JNIEnv* env, jobject jListener)
\r
68 resourceFoundMapLock.lock();
\r
70 for (auto it = onResourceFoundListenerMap.begin(); it != onResourceFoundListenerMap.end(); ++it)
\r
72 if (env->IsSameObject(jListener, it->first))
\r
74 auto refPair = it->second;
\r
75 if (refPair.second > 1)
\r
78 it->second = refPair;
\r
79 onResourceFoundListenerMap.insert(*it);
\r
80 LOGI("OnResourceFoundListener: ref. count decremented");
\r
84 env->DeleteGlobalRef(it->first);
\r
85 JniOnResourceFoundListener* listener = refPair.first;
\r
87 onResourceFoundListenerMap.erase(it);
\r
88 LOGI("OnResourceFoundListener removed");
\r
93 resourceFoundMapLock.unlock();
\r
96 JniOnDeviceInfoListener* AddOnDeviceInfoListener(JNIEnv* env, jobject jListener)
\r
98 JniOnDeviceInfoListener *onDeviceInfoListener = NULL;
\r
100 deviceInfoMapLock.lock();
\r
102 for (auto it = onDeviceInfoListenerMap.begin(); it != onDeviceInfoListenerMap.end(); ++it)
\r
104 if (env->IsSameObject(jListener, it->first))
\r
106 auto refPair = it->second;
\r
107 onDeviceInfoListener = refPair.first;
\r
109 it->second = refPair;
\r
110 onDeviceInfoListenerMap.insert(*it);
\r
111 LOGD("OnDeviceInfoListener: ref. count incremented");
\r
116 if (!onDeviceInfoListener)
\r
118 onDeviceInfoListener = new JniOnDeviceInfoListener(env, jListener, RemoveOnDeviceInfoListener);
\r
119 jobject jgListener = env->NewGlobalRef(jListener);
\r
121 onDeviceInfoListenerMap.insert(std::pair < jobject, std::pair < JniOnDeviceInfoListener*,
\r
122 int >> (jgListener, std::pair<JniOnDeviceInfoListener*, int>(onDeviceInfoListener, 1)));
\r
123 LOGI("OnDeviceInfoListener: new listener");
\r
126 deviceInfoMapLock.unlock();
\r
127 return onDeviceInfoListener;
\r
130 void RemoveOnDeviceInfoListener(JNIEnv* env, jobject jListener)
\r
132 deviceInfoMapLock.lock();
\r
133 bool isFound = false;
\r
134 for (auto it = onDeviceInfoListenerMap.begin(); it != onDeviceInfoListenerMap.end(); ++it)
\r
136 if (env->IsSameObject(jListener, it->first))
\r
138 auto refPair = it->second;
\r
139 if (refPair.second > 1)
\r
142 it->second = refPair;
\r
143 onDeviceInfoListenerMap.insert(*it);
\r
144 LOGI("OnDeviceInfoListener: ref. count decremented");
\r
148 env->DeleteGlobalRef(it->first);
\r
149 JniOnDeviceInfoListener* listener = refPair.first;
\r
151 onDeviceInfoListenerMap.erase(it);
\r
153 LOGI("OnDeviceInfoListener removed");
\r
163 ThrowOcException(JNI_EXCEPTION, "OnDeviceInfoListenet not found");
\r
165 deviceInfoMapLock.unlock();
\r
168 JniOnPlatformInfoListener* AddOnPlatformInfoListener(JNIEnv* env, jobject jListener)
170 JniOnPlatformInfoListener *onPlatformInfoListener = NULL;
172 platformInfoMapLock.lock();
174 for (auto it = onPlatformInfoListenerMap.begin(); it != onPlatformInfoListenerMap.end(); ++it)
176 if (env->IsSameObject(jListener, it->first))
178 auto refPair = it->second;
179 onPlatformInfoListener = refPair.first;
181 it->second = refPair;
182 onPlatformInfoListenerMap.insert(*it);
183 LOGD("OnPlatformInfoListener: ref. count incremented");
188 if (!onPlatformInfoListener)
190 onPlatformInfoListener = new JniOnPlatformInfoListener(env, jListener, RemoveOnPlatformInfoListener);
191 jobject jgListener = env->NewGlobalRef(jListener);
193 onPlatformInfoListenerMap.insert(std::pair < jobject, std::pair < JniOnPlatformInfoListener*,
194 int >> (jgListener, std::pair<JniOnPlatformInfoListener*, int>(onPlatformInfoListener, 1)));
195 LOGI("OnPlatformInfoListener: new listener");
198 platformInfoMapLock.unlock();
199 return onPlatformInfoListener;
202 void RemoveOnPlatformInfoListener(JNIEnv* env, jobject jListener)
204 platformInfoMapLock.lock();
205 bool isFound = false;
206 for (auto it = onPlatformInfoListenerMap.begin(); it != onPlatformInfoListenerMap.end(); ++it)
208 if (env->IsSameObject(jListener, it->first))
210 auto refPair = it->second;
211 if (refPair.second > 1)
214 it->second = refPair;
215 onPlatformInfoListenerMap.insert(*it);
216 LOGI("OnPlatformInfoListener: ref. count decremented");
220 env->DeleteGlobalRef(it->first);
221 JniOnPlatformInfoListener* listener = refPair.first;
223 onPlatformInfoListenerMap.erase(it);
225 LOGI("OnPlatformInfoListener removed");
235 ThrowOcException(JNI_EXCEPTION, "OnPlatformInfoListenet not found");
237 platformInfoMapLock.unlock();
240 JniOnPresenceListener* AddOnPresenceListener(JNIEnv* env, jobject jListener)
\r
242 JniOnPresenceListener *onPresenceListener = NULL;
\r
244 presenceMapLock.lock();
\r
246 for (auto it = onPresenceListenerMap.begin(); it != onPresenceListenerMap.end(); ++it)
\r
248 if (env->IsSameObject(jListener, it->first))
\r
250 auto refPair = it->second;
\r
251 onPresenceListener = refPair.first;
\r
253 it->second = refPair;
\r
254 onPresenceListenerMap.insert(*it);
\r
255 LOGD("OnPresenceListener: ref. count incremented");
\r
259 if (!onPresenceListener)
\r
261 onPresenceListener = new JniOnPresenceListener(env, jListener, RemoveOnPresenceListener);
\r
262 jobject jgListener = env->NewGlobalRef(jListener);
\r
263 onPresenceListenerMap.insert(std::pair < jobject, std::pair < JniOnPresenceListener*,
\r
264 int >> (jgListener, std::pair<JniOnPresenceListener*, int>(onPresenceListener, 1)));
\r
265 LOGI("OnPresenceListener: new listener");
\r
267 presenceMapLock.unlock();
\r
268 return onPresenceListener;
\r
271 void RemoveOnPresenceListener(JNIEnv* env, jobject jListener)
\r
273 presenceMapLock.lock();
\r
274 bool isFound = false;
\r
275 for (auto it = onPresenceListenerMap.begin(); it != onPresenceListenerMap.end(); ++it)
\r
277 if (env->IsSameObject(jListener, it->first))
\r
279 auto refPair = it->second;
\r
280 if (refPair.second > 1)
\r
283 it->second = refPair;
\r
284 onPresenceListenerMap.insert(*it);
\r
285 LOGI("OnPresenceListener: ref. count decremented");
\r
289 env->DeleteGlobalRef(it->first);
\r
290 JniOnPresenceListener* listener = refPair.first;
\r
292 onPresenceListenerMap.erase(it);
\r
293 LOGI("OnPresenceListener is removed");
\r
301 ThrowOcException(JNI_EXCEPTION, "OnPresenceListener not found");
\r
303 presenceMapLock.unlock();
\r
307 * Class: org_iotivity_base_OcPlatform
\r
308 * Method: configure
\r
309 * Signature: (IILjava/lang/String;II)V
\r
311 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_configure
\r
312 (JNIEnv *env, jclass clazz, jint jServiceType, jint jModeType, jstring jIpAddress, jint jPort,
313 jint jQOS, jstring jDbPath)
315 LOGI("OcPlatform_configure");
\r
317 std::string ipAddress;
\r
321 ipAddress = env->GetStringUTFChars(jIpAddress, NULL);
\r
325 dbfile = env->GetStringUTFChars(jDbPath, nullptr);
326 JniOcSecurity::StoreDbPath(dbfile);
331 port = static_cast<uint16_t>(jPort);
\r
333 PlatformConfig cfg{
\r
334 JniUtils::getServiceType(env, jServiceType),
\r
335 JniUtils::getModeType(env, jModeType),
\r
338 JniUtils::getQOS(env, static_cast<int>(jQOS)),
339 JniOcSecurity::getOCPersistentStorage()
342 OCPlatform::Configure(cfg);
\r
346 * Class: org_iotivity_base_OcPlatform
\r
347 * Method: notifyAllObservers0
\r
348 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V
\r
350 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyAllObservers0
\r
351 (JNIEnv *env, jclass clazz, jobject jResourceHandle)
\r
353 LOGI("OcPlatform_notifyAllObservers");
\r
354 if (!jResourceHandle)
\r
356 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
360 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
361 env, jResourceHandle);
\r
362 if (!jniOcResourceHandle) return;
\r
366 OCStackResult result = OCPlatform::notifyAllObservers(jniOcResourceHandle->getOCResourceHandle());
\r
368 if (OC_STACK_OK != result)
\r
370 ThrowOcException(result, "Failed to notify all observers");
\r
374 catch (OCException& e)
\r
376 LOGE("%s", e.reason().c_str());
\r
377 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
382 * Class: org_iotivity_base_OcPlatform
\r
383 * Method: notifyAllObservers1
\r
384 * Signature: (Lorg/iotivity/base/OcResourceHandle;I)V
\r
386 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyAllObservers1
\r
387 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jint jQoS)
\r
389 LOGI("OcPlatform_notifyAllObservers1");
\r
391 if (!jResourceHandle)
\r
393 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
397 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
398 env, jResourceHandle);
\r
399 if (!jniOcResourceHandle) return;
\r
402 OCStackResult result = OCPlatform::notifyAllObservers(
\r
403 jniOcResourceHandle->getOCResourceHandle(),
\r
404 JniUtils::getQOS(env, static_cast<int>(jQoS)));
\r
406 if (OC_STACK_OK != result)
\r
408 ThrowOcException(result, "Failed to notify all observers");
\r
412 catch (OCException& e)
\r
414 LOGE("%s", e.reason().c_str());
\r
415 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
420 * Class: org_iotivity_base_OcPlatform
\r
421 * Method: notifyListOfObservers2
\r
422 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Ljava/lang/Byte;Lorg/iotivity/base/OcResourceResponse;)V
\r
424 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyListOfObservers2
\r
425 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jbyteArray jObservationIdArr, jobject jResourceResponse)
\r
427 LOGD("OcPlatform_notifyListOfObservers2");
\r
428 if (!jResourceHandle)
\r
430 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
433 if (!jObservationIdArr)
\r
435 ThrowOcException(OC_STACK_INVALID_PARAM, "observationIdList cannot be null");
\r
438 if (!jResourceResponse)
\r
440 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
\r
444 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
445 env, jResourceHandle);
\r
446 if (!jniOcResourceHandle) return;
\r
448 JniOcResourceResponse* jniOcResourceResponse = JniOcResourceResponse::getJniOcResourceResponsePtr(
\r
449 env, jResourceResponse);
\r
450 if (!jniOcResourceResponse) return;
\r
452 int len = env->GetArrayLength(jObservationIdArr);
\r
453 uint8_t* bArr = (uint8_t*)env->GetByteArrayElements(jObservationIdArr, 0);
\r
455 ObservationIds observationIds;
\r
456 for (int i = 0; i < len; ++i)
\r
458 observationIds.push_back(bArr[i]);
\r
461 env->ReleaseByteArrayElements(jObservationIdArr, (jbyte*)bArr, 0);
\r
464 OCStackResult result = OCPlatform::notifyListOfObservers(
\r
465 jniOcResourceHandle->getOCResourceHandle(),
\r
467 jniOcResourceResponse->getOCResourceResponse());
\r
469 if (OC_STACK_OK != result)
\r
471 ThrowOcException(result, "Failed to notify all observers");
\r
474 catch (OCException& e)
\r
476 LOGE("%s", e.reason().c_str());
\r
477 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
482 * Class: org_iotivity_base_OcPlatform
\r
483 * Method: notifyListOfObservers3
\r
484 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Ljava/lang/Byte;Lorg/iotivity/base/OcResourceResponse;I)V
\r
486 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_notifyListOfObservers3
\r
487 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jbyteArray jObservationIdArr, jobject jResourceResponse, jint jQoS)
\r
489 LOGD("OcPlatform_notifyListOfObservers3");
\r
490 if (!jResourceHandle)
\r
492 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
495 if (!jObservationIdArr)
\r
497 ThrowOcException(OC_STACK_INVALID_PARAM, "observationIdList cannot be null");
\r
500 if (!jResourceResponse)
\r
502 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
\r
506 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
507 env, jResourceHandle);
\r
508 if (!jniOcResourceHandle) return;
\r
510 JniOcResourceResponse* jniOcResourceResponse = JniOcResourceResponse::getJniOcResourceResponsePtr(
\r
511 env, jResourceResponse);
\r
512 if (!jniOcResourceResponse) return;
\r
514 int len = env->GetArrayLength(jObservationIdArr);
\r
515 uint8_t* bArr = (uint8_t*)env->GetByteArrayElements(jObservationIdArr, 0);
\r
517 ObservationIds observationIds;
\r
518 for (int i = 0; i < len; ++i)
\r
520 observationIds.push_back(bArr[i]);
\r
523 env->ReleaseByteArrayElements(jObservationIdArr, (jbyte*)bArr, 0);
\r
526 OCStackResult result = OCPlatform::notifyListOfObservers(
\r
527 jniOcResourceHandle->getOCResourceHandle(),
\r
529 jniOcResourceResponse->getOCResourceResponse(),
\r
530 JniUtils::getQOS(env, static_cast<int>(jQoS)));
\r
532 if (OC_STACK_OK != result)
\r
534 ThrowOcException(result, "Failed to notify all observers");
\r
537 catch (OCException& e)
\r
539 LOGE("%s", e.reason().c_str());
\r
540 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
545 * Class: org_iotivity_base_OcPlatform
\r
546 * Method: findResource0
\r
547 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnResourceFoundListener;)V
\r
549 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findResource0
\r
550 (JNIEnv *env, jclass clazz, jstring jHost, jstring jResourceUri, jint jConnectivityType, jobject jListener)
\r
552 LOGD("OcPlatform_findResource");
\r
556 host = env->GetStringUTFChars(jHost, NULL);
\r
558 std::string resourceUri;
\r
561 resourceUri = env->GetStringUTFChars(jResourceUri, NULL);
\r
565 ThrowOcException(OC_STACK_INVALID_PARAM, "onResourceFoundListener cannot be null");
\r
569 JniOnResourceFoundListener *onResFoundListener = AddOnResourceFoundListener(env, jListener);
\r
571 FindCallback findCallback = [onResFoundListener](std::shared_ptr<OCResource> resource)
\r
573 onResFoundListener->foundResourceCallback(resource);
\r
578 OCStackResult result = OCPlatform::findResource(
\r
581 JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
\r
584 if (OC_STACK_OK != result)
\r
586 ThrowOcException(result, "Find resource has failed");
\r
590 catch (OCException& e)
\r
592 LOGE("%s", e.reason().c_str());
\r
593 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
598 * Class: org_iotivity_base_OcPlatform
\r
599 * Method: findResource1
\r
600 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnResourceFoundListener;I)V
\r
602 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findResource1
\r
603 (JNIEnv *env, jclass clazz, jstring jHost, jstring jResourceUri, jint jConnectivityType, jobject jListener, jint jQoS)
\r
605 LOGD("OcPlatform_findResource");
\r
609 host = env->GetStringUTFChars(jHost, NULL);
\r
611 std::string resourceUri;
\r
614 resourceUri = env->GetStringUTFChars(jResourceUri, NULL);
\r
618 ThrowOcException(OC_STACK_INVALID_PARAM, "onResourceFoundListener cannot be null");
\r
621 JniOnResourceFoundListener *onResFoundListener = AddOnResourceFoundListener(env, jListener);
\r
623 FindCallback findCallback = [onResFoundListener](std::shared_ptr<OCResource> resource)
\r
625 onResFoundListener->foundResourceCallback(resource);
\r
630 OCStackResult result = OCPlatform::findResource(
\r
633 JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
\r
635 JniUtils::getQOS(env, static_cast<int>(jQoS)));
\r
637 if (OC_STACK_OK != result)
\r
639 ThrowOcException(result, "Find resource has failed");
\r
643 catch (OCException& e)
\r
645 LOGE("%s", e.reason().c_str());
\r
646 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
651 * Class: org_iotivity_base_OcPlatform
\r
652 * Method: getDeviceInfo0
\r
653 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeviceFoundListener;)V
\r
655 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDeviceInfo0
\r
656 (JNIEnv *env, jclass clazz, jstring jHost, jstring jResourceUri, jint jConnectivityType, jobject jListener)
\r
658 LOGD("OcPlatform_getDeviceInfo0");
\r
662 host = env->GetStringUTFChars(jHost, NULL);
\r
664 std::string resourceUri;
\r
667 resourceUri = env->GetStringUTFChars(jResourceUri, NULL);
\r
671 ThrowOcException(OC_STACK_INVALID_PARAM, "onDeviceFoundListener cannot be null");
\r
674 JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
\r
676 FindDeviceCallback findDeviceCallback = [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
\r
678 onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
\r
683 OCStackResult result = OCPlatform::getDeviceInfo(
\r
686 JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
\r
687 findDeviceCallback);
\r
689 if (OC_STACK_OK != result)
\r
691 ThrowOcException(result, "Find device has failed");
\r
694 catch (OCException& e)
\r
696 LOGE("%s", e.reason().c_str());
\r
697 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
702 * Class: org_iotivity_base_OcPlatform
\r
703 * Method: getDeviceInfo1
\r
704 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeviceFoundListener;I)V
\r
706 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getDeviceInfo1
\r
707 (JNIEnv *env, jclass clazz, jstring jHost, jstring jResourceUri, jint jConnectivityType, jobject jListener, jint jQoS)
\r
709 LOGD("OcPlatform_getDeviceInfo1");
\r
713 host = env->GetStringUTFChars(jHost, NULL);
\r
715 std::string resourceUri;
\r
718 resourceUri = env->GetStringUTFChars(jResourceUri, NULL);
\r
722 ThrowOcException(OC_STACK_INVALID_PARAM, "onDeviceFoundListener cannot be null");
\r
725 JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
\r
727 FindDeviceCallback findDeviceCallback = [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
\r
729 onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
\r
734 OCStackResult result = OCPlatform::getDeviceInfo(
\r
737 JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
\r
738 findDeviceCallback,
\r
739 JniUtils::getQOS(env, static_cast<int>(jQoS)));
\r
741 if (OC_STACK_OK != result)
\r
743 ThrowOcException(result, "Find device has failed");
\r
746 catch (OCException& e)
748 LOGE("%s", e.reason().c_str());
749 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
754 * Class: org_iotivity_base_OcPlatform
755 * Method: getPlatformInfo0
756 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPlatformFoundListener;)V
758 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getPlatformInfo0
759 (JNIEnv *env, jclass clazz, jstring jHost, jstring jResourceUri, jint jConnectivityType, jobject jListener)
761 LOGD("OcPlatform_getPlatformInfo0");
765 host = env->GetStringUTFChars(jHost, NULL);
767 std::string resourceUri;
770 resourceUri = env->GetStringUTFChars(jResourceUri, NULL);
774 ThrowOcException(OC_STACK_INVALID_PARAM, "onPlatformFoundListener cannot be null");
777 JniOnPlatformInfoListener *onPlatformInfoListener = AddOnPlatformInfoListener(env, jListener);
779 FindPlatformCallback findPlatformCallback = [onPlatformInfoListener](const OCRepresentation& ocRepresentation)
781 onPlatformInfoListener->foundPlatformCallback(ocRepresentation);
786 OCStackResult result = OCPlatform::getPlatformInfo(
789 JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
790 findPlatformCallback);
792 if (OC_STACK_OK != result)
794 ThrowOcException(result, "Find platform has failed");
797 catch (OCException& e)
799 LOGE("%s", e.reason().c_str());
800 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
805 * Class: org_iotivity_base_OcPlatform
806 * Method: getPlatformInfo1
807 * Signature: (Ljava/lang/String;Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPlatformFoundListener;I)V
809 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getPlatformInfo1
810 (JNIEnv *env, jclass clazz, jstring jHost, jstring jResourceUri, jint jConnectivityType, jobject jListener, jint jQoS)
812 LOGD("OcPlatform_getPlatformInfo1");
816 host = env->GetStringUTFChars(jHost, NULL);
818 std::string resourceUri;
821 resourceUri = env->GetStringUTFChars(jResourceUri, NULL);
825 ThrowOcException(OC_STACK_INVALID_PARAM, "onPlatformFoundListener cannot be null");
828 JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
830 FindDeviceCallback findDeviceCallback = [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
832 onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
837 OCStackResult result = OCPlatform::getPlatformInfo(
840 JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
842 JniUtils::getQOS(env, static_cast<int>(jQoS)));
844 if (OC_STACK_OK != result)
846 ThrowOcException(result, "Find platform has failed");
849 catch (OCException& e)
\r
851 LOGE("%s", e.reason().c_str());
\r
852 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
857 * Class: org_iotivity_base_OcPlatform
\r
858 * Method: registerResource0
\r
859 * Signature: (Lorg/iotivity/base/OcResource;)Lorg/iotivity/base/OcResourceHandle;
\r
861 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_registerResource0
\r
862 (JNIEnv *env, jclass clazz, jobject jResource)
\r
864 LOGD("OcPlatform_registerResource");
\r
867 ThrowOcException(OC_STACK_INVALID_PARAM, "Resource cannot be null");
\r
870 JniOcResource *resource = JniOcResource::getJniOcResourcePtr(env, jResource);
\r
871 if (!resource) return nullptr;
\r
872 LOGD("OcPlatform_registerResource1");
873 OCResourceHandle resourceHandle;
\r
876 LOGD("OcPlatform_registerResource2");
877 OCStackResult result = OCPlatform::registerResource(
\r
879 resource->getOCResource());
\r
880 LOGD("OcPlatform_registerResource3");
882 if (OC_STACK_OK != result)
\r
884 ThrowOcException(result, "register resource");
\r
887 catch (OCException& e)
\r
889 LOGE("%s", e.reason().c_str());
\r
890 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
893 LOGD("OcPlatform_registerResource4");
894 JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);
\r
895 jlong handle = reinterpret_cast<jlong>(jniHandle);
\r
896 jobject jResourceHandle = env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);
\r
897 LOGD("OcPlatform_registerResource5");
898 if (!jResourceHandle)
\r
900 LOGE("Failed to create OcResourceHandle");
\r
903 return jResourceHandle;
\r
907 * Class: org_iotivity_base_OcPlatform
\r
908 * Method: registerResource1
\r
909 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcPlatform/EntityHandler;I)Lorg/iotivity/base/OcResourceHandle;
\r
911 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_registerResource1
\r
912 (JNIEnv *env, jclass clazz, jstring jResourceUri, jstring jResourceTypeName, jstring jResourceInterface,
\r
913 jobject jListener, jint jResourceProperty)
\r
915 LOGI("OcPlatform_registerResource1");
\r
916 std::string resourceUri;
\r
919 resourceUri = env->GetStringUTFChars(jResourceUri, NULL);
\r
921 std::string resourceTypeName;
\r
922 if (jResourceTypeName)
\r
924 resourceTypeName = env->GetStringUTFChars(jResourceTypeName, NULL);
\r
926 std::string resourceInterface;
\r
927 if (jResourceInterface)
\r
929 resourceInterface = env->GetStringUTFChars(jResourceInterface, NULL);
\r
933 ThrowOcException(OC_STACK_INVALID_PARAM, "entityHandler cannot be null");
\r
936 JniEntityHandler* entityHandler = new JniEntityHandler(env, jListener);
\r
937 EntityHandler handleEntityCallback = [entityHandler](const std::shared_ptr<OCResourceRequest> request) ->
\r
938 OCEntityHandlerResult{
\r
939 return entityHandler->handleEntity(request);
\r
942 OCResourceHandle resourceHandle;
\r
945 OCStackResult result = OCPlatform::registerResource(
\r
950 handleEntityCallback,
\r
951 static_cast<int>(jResourceProperty));
\r
953 if (OC_STACK_OK != result)
\r
955 delete entityHandler;
\r
956 ThrowOcException(result, "register resource");
\r
960 catch (OCException& e)
\r
962 LOGE("%s", e.reason().c_str());
\r
963 delete entityHandler;
\r
964 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
968 JniOcResourceHandle* jniHandle = new JniOcResourceHandle(resourceHandle);
\r
969 jlong handle = reinterpret_cast<jlong>(jniHandle);
\r
970 jobject jResourceHandle = env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);
\r
971 if (!jResourceHandle)
\r
973 LOGE("Failed to create OcResourceHandle");
\r
977 return jResourceHandle;
\r
981 * Class: org_iotivity_base_OcPlatform
\r
982 * Method: registerDeviceInfo0
\r
983 * 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
985 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_registerDeviceInfo0
\r
988 jstring jDeviceName)
\r
990 LOGI("OcPlatform_registerDeviceInfo");
\r
992 std::string deviceName;
\r
995 deviceName = env->GetStringUTFChars(jDeviceName, NULL);
\r
998 OCDeviceInfo deviceInfo;
\r
1001 DuplicateString(&deviceInfo.deviceName, deviceName);
\r
1003 catch (std::exception &e)
\r
1005 ThrowOcException(JNI_EXCEPTION, "Failed to construct device info");
\r
1011 OCStackResult result = OCPlatform::registerDeviceInfo(deviceInfo);
\r
1013 delete deviceInfo.deviceName;
\r
1015 if (OC_STACK_OK != result)
\r
1017 ThrowOcException(result, "Failed to register device info");
\r
1021 catch (OCException& e)
\r
1023 LOGE("%s", e.reason().c_str());
\r
1024 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1029 * Class: org_iotivity_base_OcPlatform
\r
1030 * Method: registerPlatformInfo0
1031 * 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
1033 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_registerPlatformInfo0
1036 jstring jPlatformID,
1037 jstring jManufacturerName,
1038 jstring jManufacturerUrl,
1039 jstring jModelNumber,
1040 jstring jDateOfManufacture,
1041 jstring jPlatformVersion,
1042 jstring jOperatingSystemVersion,
1043 jstring jHardwareVersion,
1044 jstring jFirmwareVersion,
1045 jstring jSupportUrl,
1046 jstring jSystemTime)
1048 LOGI("OcPlatform_registerPlatformInfo");
1051 std::string platformID;
1052 std::string manufacturerName;
1053 std::string manufacturerUrl;
1054 std::string modelNumber;
1055 std::string dateOfManufacture;
1056 std::string platformVersion;
1057 std::string operatingSystemVersion;
1058 std::string hardwareVersion;
1059 std::string firmwareVersion;
1060 std::string supportUrl;
1061 std::string systemTime;
1065 platformID = env->GetStringUTFChars(jPlatformID, NULL);
1067 if (jManufacturerName)
1069 manufacturerName = env->GetStringUTFChars(jManufacturerName, NULL);
1071 if (jManufacturerUrl)
1073 manufacturerUrl = env->GetStringUTFChars(jManufacturerUrl, NULL);
1077 modelNumber = env->GetStringUTFChars(jModelNumber, NULL);
1079 if (jDateOfManufacture)
1081 dateOfManufacture = env->GetStringUTFChars(jDateOfManufacture, NULL);
1083 if (jPlatformVersion)
1085 platformVersion = env->GetStringUTFChars(jPlatformVersion, NULL);
1087 if (jOperatingSystemVersion)
1089 operatingSystemVersion = env->GetStringUTFChars(jOperatingSystemVersion, NULL);
1091 if (jHardwareVersion)
1093 hardwareVersion = env->GetStringUTFChars(jHardwareVersion, NULL);
1095 if (jFirmwareVersion)
1097 firmwareVersion = env->GetStringUTFChars(jFirmwareVersion, NULL);
1101 supportUrl = env->GetStringUTFChars(jSupportUrl, NULL);
1105 systemTime = env->GetStringUTFChars(jSystemTime, NULL);
1108 OCPlatformInfo platformInfo;
1111 DuplicateString(&platformInfo.platformID, platformID);
1112 DuplicateString(&platformInfo.manufacturerName, manufacturerName);
1113 DuplicateString(&platformInfo.manufacturerUrl, manufacturerUrl);
1114 DuplicateString(&platformInfo.modelNumber, modelNumber);
1115 DuplicateString(&platformInfo.dateOfManufacture, dateOfManufacture);
1116 DuplicateString(&platformInfo.platformVersion, platformVersion);
1117 DuplicateString(&platformInfo.operatingSystemVersion, operatingSystemVersion);
1118 DuplicateString(&platformInfo.hardwareVersion, hardwareVersion);
1119 DuplicateString(&platformInfo.firmwareVersion, firmwareVersion);
1120 DuplicateString(&platformInfo.supportUrl, supportUrl);
1121 DuplicateString(&platformInfo.systemTime, systemTime);
1123 catch (std::exception &e)
1125 ThrowOcException(JNI_EXCEPTION, "Failed to construct platform info");
1129 // __android_log_print(ANDROID_LOG_INFO, "Rahul", "platformID = %s", platformID);
1132 OCStackResult result = OCPlatform::registerPlatformInfo(platformInfo);
1134 delete platformInfo.platformID;
1135 delete platformInfo.manufacturerName;
1136 delete platformInfo.manufacturerUrl;
1137 delete platformInfo.modelNumber;
1138 delete platformInfo.dateOfManufacture;
1139 delete platformInfo.platformVersion;
1140 delete platformInfo.operatingSystemVersion;
1141 delete platformInfo.hardwareVersion;
1142 delete platformInfo.firmwareVersion;
1143 delete platformInfo.supportUrl;
1144 delete platformInfo.systemTime;
1146 if (OC_STACK_OK != result)
1148 ThrowOcException(result, "Failed to register platform info");
1152 catch (OCException& e)
1154 LOGE("Error is due to %s", e.reason().c_str());
1155 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
1163 * Class: org_iotivity_base_OcPlatform
1164 * Method: unregisterResource0
\r
1165 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V
\r
1167 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unregisterResource0
\r
1168 (JNIEnv *env, jclass clazz, jobject jResourceHandle)
\r
1170 LOGI("OcPlatform_unregisterResource");
\r
1171 if (!jResourceHandle)
\r
1173 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
1176 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1177 env, jResourceHandle);
\r
1178 if (!jniOcResourceHandle) return;
\r
1182 OCResourceHandle resHandle = jniOcResourceHandle->getOCResourceHandle();
\r
1183 OCStackResult result = OCPlatform::unregisterResource(resHandle);
\r
1184 if (OC_STACK_OK != result)
\r
1186 ThrowOcException(result, "Failed to unregister resource");
\r
1189 catch (OCException& e)
\r
1191 LOGE("%s", e.reason().c_str());
\r
1192 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1197 * Class: org_iotivity_base_OcPlatform
\r
1198 * Method: bindResource0
\r
1199 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
\r
1201 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResource0
\r
1202 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobject jResourceHandle)
\r
1204 LOGI("OcPlatform_bindResource");
\r
1205 if (!jResourceCollectionHandle)
\r
1207 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
\r
1210 if (!jResourceHandle)
\r
1212 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
1215 JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1216 env, jResourceCollectionHandle);
\r
1217 if (!jniOcResourceCollectionHandle) return;
\r
1219 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1220 env, jResourceHandle);
\r
1221 if (!jniOcResourceHandle) return;
\r
1225 OCStackResult result = OCPlatform::bindResource(
\r
1226 jniOcResourceCollectionHandle->getOCResourceHandle(),
\r
1227 jniOcResourceHandle->getOCResourceHandle()
\r
1230 if (OC_STACK_OK != result)
\r
1232 ThrowOcException(result, "Failed to bind resource");
\r
1235 catch (OCException& e)
\r
1237 LOGE("%s", e.reason().c_str());
\r
1238 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1243 * Class: org_iotivity_base_OcPlatform
\r
1244 * Method: bindResources0
\r
1245 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
\r
1247 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindResources0
\r
1248 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobjectArray jResourceHandleArray)
\r
1250 LOGI("OcPlatform_bindResources");
\r
1252 if (!jResourceCollectionHandle)
\r
1254 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
\r
1257 if (!jResourceHandleArray)
\r
1259 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
\r
1263 JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1264 env, jResourceCollectionHandle);
\r
1265 if (!jniOcResourceCollectionHandle) return;
\r
1267 std::vector<OCResourceHandle> resourceHandleList;
\r
1268 int len = env->GetArrayLength(jResourceHandleArray);
\r
1269 for (int i = 0; i < len; ++i)
\r
1271 jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
\r
1272 if (!jResourceHandle)
\r
1274 ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
\r
1278 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1279 env, jResourceHandle);
\r
1280 if (!jniOcResourceHandle) return;
\r
1282 resourceHandleList.push_back(
\r
1283 jniOcResourceHandle->getOCResourceHandle());
\r
1288 OCStackResult result = OCPlatform::bindResources(
\r
1289 jniOcResourceCollectionHandle->getOCResourceHandle(),
\r
1290 resourceHandleList
\r
1293 if (OC_STACK_OK != result)
\r
1295 ThrowOcException(result, "Failed to bind resources");
\r
1298 catch (OCException& e)
\r
1300 LOGE("%s", e.reason().c_str());
\r
1301 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1306 * Class: org_iotivity_base_OcPlatform
\r
1307 * Method: unbindResource0
\r
1308 * Signature: (Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcResourceHandle;)V
\r
1310 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResource0
\r
1311 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobject jResourceHandle)
\r
1313 LOGI("OcPlatform_unbindResource");
\r
1314 if (!jResourceCollectionHandle)
\r
1316 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
\r
1319 if (!jResourceHandle)
\r
1321 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
1325 JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1326 env, jResourceCollectionHandle);
\r
1327 if (!jniOcResourceCollectionHandle) return;
\r
1329 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1330 env, jResourceHandle);
\r
1331 if (!jniOcResourceHandle) return;
\r
1335 OCStackResult result = OCPlatform::unbindResource(
\r
1336 jniOcResourceCollectionHandle->getOCResourceHandle(),
\r
1337 jniOcResourceHandle->getOCResourceHandle()
\r
1340 if (OC_STACK_OK != result)
\r
1342 ThrowOcException(result, "Failed to unbind resource");
\r
1345 catch (OCException& e)
\r
1347 LOGE("%s", e.reason().c_str());
\r
1348 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1353 * Class: org_iotivity_base_OcPlatform
\r
1354 * Method: unbindResources0
\r
1355 * Signature: (Lorg/iotivity/base/OcResourceHandle;[Lorg/iotivity/base/OcResourceHandle;)V
\r
1357 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unbindResources0
\r
1358 (JNIEnv *env, jclass clazz, jobject jResourceCollectionHandle, jobjectArray jResourceHandleArray)
\r
1360 LOGI("OcPlatform_unbindResources");
\r
1361 if (!jResourceCollectionHandle)
\r
1363 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceCollectionHandle cannot be null");
\r
1366 if (!jResourceHandleArray)
\r
1368 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
\r
1372 JniOcResourceHandle* jniOcResourceCollectionHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1373 env, jResourceCollectionHandle);
\r
1374 if (!jniOcResourceCollectionHandle) return;
\r
1376 std::vector<OCResourceHandle> resourceHandleList;
\r
1377 int len = env->GetArrayLength(jResourceHandleArray);
\r
1378 for (int i = 0; i < len; ++i)
\r
1380 jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
\r
1381 if (!jResourceHandle)
\r
1383 ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
\r
1387 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1388 env, jResourceHandle);
\r
1389 if (!jniOcResourceHandle) return;
\r
1391 resourceHandleList.push_back(
\r
1392 jniOcResourceHandle->getOCResourceHandle());
\r
1397 OCStackResult result = OCPlatform::unbindResources(
\r
1398 jniOcResourceCollectionHandle->getOCResourceHandle(),
\r
1399 resourceHandleList
\r
1402 if (OC_STACK_OK != result)
\r
1404 ThrowOcException(result, "Failed to unbind resources");
\r
1407 catch (OCException& e)
\r
1409 LOGE("%s", e.reason().c_str());
\r
1410 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1415 * Class: org_iotivity_base_OcPlatform
\r
1416 * Method: bindTypeToResource0
\r
1417 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
\r
1419 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindTypeToResource0
\r
1420 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jstring jResourceTypeName)
\r
1422 LOGI("OcPlatform_bindTypeToResource");
\r
1423 if (!jResourceHandle)
\r
1425 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
1428 std::string typeName;
\r
1429 if (jResourceTypeName)
\r
1431 typeName = env->GetStringUTFChars(jResourceTypeName, NULL);
\r
1434 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1435 env, jResourceHandle);
\r
1436 if (!jniOcResourceHandle) return;
\r
1440 OCStackResult result = OCPlatform::bindTypeToResource(
\r
1441 jniOcResourceHandle->getOCResourceHandle(),
\r
1445 if (OC_STACK_OK != result)
\r
1447 ThrowOcException(result, "Failed to bind type to resource");
\r
1450 catch (OCException& e)
\r
1452 LOGE("%s", e.reason().c_str());
\r
1453 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1458 * Class: org_iotivity_base_OcPlatform
\r
1459 * Method: bindInterfaceToResource0
\r
1460 * Signature: (Lorg/iotivity/base/OcResourceHandle;Ljava/lang/String;)V
\r
1462 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_bindInterfaceToResource0
\r
1463 (JNIEnv *env, jclass clazz, jobject jResourceHandle, jstring jResourceInterfaceName)
\r
1465 LOGI("OcPlatform_bindInterfaceToResource");
\r
1466 if (!jResourceHandle)
\r
1468 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
\r
1471 std::string interfaceName;
\r
1472 if (jResourceInterfaceName)
\r
1474 interfaceName = env->GetStringUTFChars(jResourceInterfaceName, NULL);
\r
1477 JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(
\r
1478 env, jResourceHandle);
\r
1479 if (!jniOcResourceHandle) return;
\r
1483 OCStackResult result = OCPlatform::bindInterfaceToResource(
\r
1484 jniOcResourceHandle->getOCResourceHandle(),
\r
1488 if (OC_STACK_OK != result)
\r
1490 ThrowOcException(result, "Failed to bind interface to resource");
\r
1493 catch (OCException& e)
\r
1495 LOGE("%s", e.reason().c_str());
\r
1496 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1501 * Class: org_iotivity_base_OcPlatform
\r
1502 * Method: startPresence0
\r
1505 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_startPresence0
\r
1506 (JNIEnv *env, jclass clazz, jint ttl)
\r
1508 LOGI("OcPlatform_startPresence");
\r
1512 OCStackResult result = OCPlatform::startPresence((unsigned int)ttl);
\r
1514 if (OC_STACK_OK != result)
\r
1516 ThrowOcException(result, "Failed to start presence");
\r
1519 catch (OCException& e)
\r
1521 LOGE("%s", e.reason().c_str());
\r
1522 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1527 * Class: org_iotivity_base_OcPlatform
\r
1528 * Method: stopPresence0
\r
1531 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_stopPresence0
\r
1532 (JNIEnv *env, jclass clazz)
\r
1534 LOGI("OcPlatform_stopPresence");
\r
1538 OCStackResult result = OCPlatform::stopPresence();
\r
1540 if (OC_STACK_OK != result)
\r
1542 ThrowOcException(result, "Failed to stop presence");
\r
1545 catch (OCException& e)
\r
1547 LOGE("%s", e.reason().c_str());
\r
1548 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1553 * Class: org_iotivity_base_OcPlatform
\r
1554 * Method: subscribePresence0
\r
1555 * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
\r
1557 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence0
\r
1558 (JNIEnv *env, jclass clazz, jstring jHost, jint jConnectivityType, jobject jListener)
\r
1560 LOGD("OcPlatform_subscribePresence");
\r
1564 host = env->GetStringUTFChars(jHost, NULL);
\r
1568 ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
\r
1572 JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
\r
1574 SubscribeCallback subscribeCallback = [onPresenceListener](OCStackResult result, const unsigned int nonce,
\r
1575 const std::string& hostAddress)
\r
1577 onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
\r
1580 OCPlatform::OCPresenceHandle presenceHandle;
\r
1583 OCStackResult result = OCPlatform::subscribePresence(
\r
1586 JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
\r
1587 subscribeCallback);
\r
1589 if (OC_STACK_OK != result)
\r
1591 ThrowOcException(result, "subscribe presence has failed");
\r
1594 catch (OCException& e)
\r
1596 LOGE("%s", e.reason().c_str());
\r
1597 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1601 JniOcPresenceHandle* jniPresenceHandle = new JniOcPresenceHandle(onPresenceListener, presenceHandle);
\r
1602 jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
\r
1603 jobject jPresenceHandle = env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
\r
1604 if (!jPresenceHandle)
\r
1606 LOGE("Failed to create OcPresenceHandle");
\r
1607 delete jniPresenceHandle;
\r
1609 return jPresenceHandle;
\r
1613 * Class: org_iotivity_base_OcPlatform
\r
1614 * Method: subscribePresence1
\r
1615 * Signature: (Ljava/lang/String;Ljava/lang/String;I
\r
1616 Lorg/iotivity/base/OcPlatform/OnPresenceListener;)Lorg/iotivity/base/OcPresenceHandle;
\r
1618 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_subscribePresence1
\r
1619 (JNIEnv *env, jclass clazz, jstring jHost, jstring jResourceType, jint jConnectivityType, jobject jListener)
\r
1621 LOGD("OcPlatform_subscribePresence1");
\r
1625 host = env->GetStringUTFChars(jHost, NULL);
\r
1627 std::string resourceType;
\r
1628 if (jResourceType)
\r
1630 resourceType = env->GetStringUTFChars(jResourceType, NULL);
\r
1634 ThrowOcException(OC_STACK_INVALID_PARAM, "onPresenceListener cannot be null");
\r
1638 JniOnPresenceListener *onPresenceListener = AddOnPresenceListener(env, jListener);
\r
1640 SubscribeCallback subscribeCallback = [onPresenceListener](OCStackResult result,
\r
1641 const unsigned int nonce, const std::string& hostAddress)
\r
1643 onPresenceListener->onPresenceCallback(result, nonce, hostAddress);
\r
1646 OCPlatform::OCPresenceHandle presenceHandle;
\r
1649 OCStackResult result = OCPlatform::subscribePresence(
\r
1653 JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
\r
1654 subscribeCallback);
\r
1656 if (OC_STACK_OK != result)
\r
1658 ThrowOcException(result, "subscribe presence has failed");
\r
1661 catch (OCException& e)
\r
1663 LOGE("%s", e.reason().c_str());
\r
1664 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1668 JniOcPresenceHandle* jniPresenceHandle = new JniOcPresenceHandle(onPresenceListener, presenceHandle);
\r
1669 jlong jhandle = reinterpret_cast<jlong>(jniPresenceHandle);
\r
1670 jobject jPresenceHandle = env->NewObject(g_cls_OcPresenceHandle, g_mid_OcPresenceHandle_N_ctor, jhandle);
\r
1671 if (!jPresenceHandle)
\r
1673 LOGE("Failed to create OcPresenceHandle");
\r
1674 delete jniPresenceHandle;
\r
1676 return jPresenceHandle;
\r
1680 * Class: org_iotivity_base_OcPlatform
\r
1681 * Method: unsubscribePresence0
\r
1682 * Signature: (Lorg/iotivity/base/OcPresenceHandle;)V
\r
1684 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_unsubscribePresence0
\r
1685 (JNIEnv *env, jclass clazz, jobject jPresenceHandle)
\r
1687 LOGD("OcPlatform_unsubscribePresence");
\r
1688 if (!jPresenceHandle)
\r
1690 ThrowOcException(OC_STACK_INVALID_PARAM, "presenceHandle cannot be null");
\r
1693 JniOcPresenceHandle* jniPresenceHandle = JniOcPresenceHandle::getJniOcPresenceHandlePtr(env, jPresenceHandle);
\r
1694 if (!jniPresenceHandle) return;
\r
1696 OCPresenceHandle presenceHandle = jniPresenceHandle->getOCPresenceHandle();
\r
1700 OCStackResult result = OCPlatform::unsubscribePresence(presenceHandle);
\r
1702 if (OC_STACK_OK != result)
\r
1704 ThrowOcException(result, "unsubscribe presence has failed");
\r
1707 jweak jwOnPresenceListener = jniPresenceHandle->getJniOnPresenceListener()->getJWListener();
\r
1708 if (jwOnPresenceListener)
\r
1710 RemoveOnPresenceListener(env, jwOnPresenceListener);
\r
1713 catch (OCException& e)
\r
1715 LOGE("%s", e.reason().c_str());
\r
1716 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r
1721 * Class: org_iotivity_base_OcPlatform
\r
1722 * Method: constructResourceObject0
\r
1723 * Signature: (Ljava/lang/String;Ljava/lang/String;IZ[Ljava/lang/String;[Ljava/lang/String;)
\r
1724 Lorg/iotivity/base/OcResource;
\r
1726 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_constructResourceObject0
\r
1727 (JNIEnv *env, jclass clazz, jstring jHost, jstring jUri, jint jConnectivityType,
\r
1728 jboolean jIsObservable, jobjectArray jResourceTypeArray, jobjectArray jInterfaceArray)
\r
1730 LOGD("OcPlatform_constructResourceObject");
\r
1734 host = env->GetStringUTFChars(jHost, NULL);
\r
1739 uri = env->GetStringUTFChars(jUri, NULL);
\r
1741 if (!jResourceTypeArray)
\r
1743 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceTypeList cannot be null");
\r
1746 if (!jInterfaceArray)
\r
1748 ThrowOcException(OC_STACK_INVALID_PARAM, "interfaceList cannot be null");
\r
1752 std::vector<std::string> resourceTypes;
\r
1753 JniUtils::convertJavaStrArrToStrVector(env, jResourceTypeArray, resourceTypes);
\r
1755 std::vector<std::string> interfaces;
\r
1756 JniUtils::convertJavaStrArrToStrVector(env, jInterfaceArray, interfaces);
\r
1758 std::shared_ptr<OCResource> resource = OCPlatform::constructResourceObject(
\r
1761 JniUtils::getConnectivityType(env, static_cast<int>(jConnectivityType)),
\r
1762 static_cast<bool>(jIsObservable),
\r
1768 ThrowOcException(OC_STACK_ERROR, "Failed to create OCResource");
\r
1772 JniOcResource *jniOcResource = new JniOcResource(resource);
\r
1773 jlong handle = reinterpret_cast<jlong>(jniOcResource);
\r
1775 jobject jResource = env->NewObject(g_cls_OcResource, g_mid_OcResource_ctor);
\r
1778 delete jniOcResource;
\r
1781 SetHandle<JniOcResource>(env, jResource, jniOcResource);
\r
1782 if (env->ExceptionCheck())
\r
1784 delete jniOcResource;
\r
1791 * Class: org_iotivity_base_OcPlatform
\r
1792 * Method: sendResponse0
\r
1793 * Signature: (Lorg/iotivity/base/OcResourceResponse;)V
\r
1795 JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_sendResponse0
\r
1796 (JNIEnv *env, jclass clazz, jobject jResourceResponse)
\r
1798 LOGD("OcPlatform_sendResponse");
\r
1799 if (!jResourceResponse)
\r
1801 ThrowOcException(OC_STACK_INVALID_PARAM, "resourceResponse cannot be null");
\r
1805 JniOcResourceResponse *jniResponse = JniOcResourceResponse::getJniOcResourceResponsePtr(
\r
1806 env, jResourceResponse);
\r
1807 if (!jniResponse) return;
\r
1811 OCStackResult result = OCPlatform::sendResponse(jniResponse->getOCResourceResponse());
\r
1813 if (OC_STACK_OK != result)
\r
1815 ThrowOcException(result, "failed to send response");
\r
1818 catch (OCException& e)
\r
1820 LOGE("%s", e.reason().c_str());
\r
1821 ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
\r