#include "JniOcResourceHandle.h"
#include "JniOcPresenceHandle.h"
#include "JniOcResourceResponse.h"
+#include "JniOcRepresentation.h"
#include "JniOcSecurity.h"
#include "JniOcDirectPairDevice.h"
#include "JniUtils.h"
#include "ocpayload.h"
+#include "RDClient.h"
#ifdef WITH_CLOUD
#include "JniOcAccountManager.h"
#endif
+#define AES_KEY_SIZE 32
+
using namespace OC;
JniOnResourceFoundListener* AddOnResourceFoundListener(JNIEnv* env, jobject jListener)
}
if (!onObserveListener)
{
- onObserveListener = new JniOnObserveListener(env, jListener, (JniOcResource*)nullptr);
+ onObserveListener = new JniOnObserveListener(env, jListener, nullptr);
jobject jgListener = env->NewGlobalRef(jListener);
onObserveListenerMap.insert(
std::pair<jobject, std::pair<JniOnObserveListener*, int>>(
directPairingListenerMapLock.unlock();
}
-JniOnPublishResourceListener* AddOnPublishResourceListener(JNIEnv* env, jobject jListener)
-{
- if (!env)
- {
- LOGD("env is null");
- return nullptr;
- }
-
- JniOnPublishResourceListener *onPublishResourceListener = nullptr;
-
- publishResourceListenerMapLock.lock();
-
- for (auto it = onPublishResourceListenerMap.begin(); it !=
- onPublishResourceListenerMap.end(); ++it)
- {
- if (env->IsSameObject(jListener, it->first))
- {
- auto refPair = it->second;
- onPublishResourceListener = refPair.first;
- refPair.second++;
- it->second = refPair;
- onPublishResourceListenerMap.insert(*it);
- LOGD("onPublishResourceListener: ref. count incremented");
- break;
- }
- }
- if (!onPublishResourceListener)
- {
- onPublishResourceListener = new JniOnPublishResourceListener(env, jListener,
- RemoveOnPublishResourceListener);
- jobject jgListener = env->NewGlobalRef(jListener);
- onPublishResourceListenerMap.insert(
- std::pair<jobject, std::pair<JniOnPublishResourceListener*, int>>(
- jgListener,
- std::pair<JniOnPublishResourceListener*, int>(onPublishResourceListener, 1)));
- LOGI("onPublishResourceListener: new listener");
- }
- publishResourceListenerMapLock.unlock();
- return onPublishResourceListener;
-}
-
-void RemoveOnPublishResourceListener(JNIEnv* env, jobject jListener)
-{
- if (!env)
- {
- LOGE("env is null");
- return;
- }
-
- publishResourceListenerMapLock.lock();
- bool isFound = false;
- for (auto it = onPublishResourceListenerMap.begin(); it !=
- onPublishResourceListenerMap.end(); ++it)
- {
- if (env->IsSameObject(jListener, it->first))
- {
- auto refPair = it->second;
- if (refPair.second > 1)
- {
- refPair.second--;
- it->second = refPair;
- onPublishResourceListenerMap.insert(*it);
- LOGI("onPublishResourceListener: ref. count decremented");
- }
- else
- {
- env->DeleteGlobalRef(it->first);
- JniOnPublishResourceListener* listener = refPair.first;
- delete listener;
- onPublishResourceListenerMap.erase(it);
- LOGI("onPublishResourceListener is removed");
- }
- isFound = true;
- break;
- }
- }
- if (!isFound)
- {
- ThrowOcException(JNI_EXCEPTION, "onPublishResourceListener not found");
- }
- publishResourceListenerMapLock.unlock();
-}
-
-JniOnDeleteResourceListener* AddOnDeleteResourceListener(JNIEnv* env, jobject jListener)
+#ifdef TCP_ADAPTER
+JniKeepAliveListener* AddKeepAliveListener(JNIEnv* env, jobject jListener)
{
- if (!env)
- {
- LOGD("env is null");
- return nullptr;
- }
-
- JniOnDeleteResourceListener *onDeleteResourceListener = nullptr;
+ JniKeepAliveListener *KeepAliveListener = nullptr;
- deleteResourceListenerMapLock.lock();
+ KeepAliveListenerMapLock.lock();
- for (auto it = onDeleteResourceListenerMap.begin(); it !=
- onDeleteResourceListenerMap.end(); ++it)
+ for (auto it = KeepAliveListenerMap.begin(); it !=
+ KeepAliveListenerMap.end(); ++it)
{
if (env->IsSameObject(jListener, it->first))
{
auto refPair = it->second;
- onDeleteResourceListener = refPair.first;
+ KeepAliveListener = refPair.first;
refPair.second++;
it->second = refPair;
- onDeleteResourceListenerMap.insert(*it);
- LOGD("onDeleteResourceListener: ref. count incremented");
+ KeepAliveListenerMap.insert(*it);
+ LOGD("KeepAliveListener: ref. count incremented");
break;
}
}
- if (!onDeleteResourceListener)
+ if (!KeepAliveListener)
{
- onDeleteResourceListener = new JniOnDeleteResourceListener(env, jListener,
- RemoveOnDeleteResourceListener);
- jobject jgListener = env->NewGlobalRef(jListener);
- onDeleteResourceListenerMap.insert(
- std::pair<jobject, std::pair<JniOnDeleteResourceListener*, int>>(
- jgListener,
- std::pair<JniOnDeleteResourceListener*, int>(onDeleteResourceListener, 1)));
- LOGI("onDeleteResourceListener: new listener");
+ KeepAliveListener = new JniKeepAliveListener(env, jListener, RemoveKeepAliveListener);
+ jobject jgListener = env->NewGlobalRef(jListener);
+ KeepAliveListenerMap.insert(std::pair<jobject, std::pair<JniKeepAliveListener*, int>>(
+ jgListener,
+ std::pair<JniKeepAliveListener*, int>(KeepAliveListener, 1)));
+ LOGI("KeepAliveListener: new listener");
}
- deleteResourceListenerMapLock.unlock();
- return onDeleteResourceListener;
+ KeepAliveListenerMapLock.unlock();
+ return KeepAliveListener;
}
-
-void RemoveOnDeleteResourceListener(JNIEnv* env, jobject jListener)
+#endif
+#ifdef TCP_ADAPTER
+void RemoveKeepAliveListener(JNIEnv* env, jobject jListener)
{
- if (!env)
- {
- LOGE("env is null");
- return;
- }
-
- deleteResourceListenerMapLock.lock();
+ KeepAliveListenerMapLock.lock();
bool isFound = false;
- for (auto it = onDeleteResourceListenerMap.begin(); it !=
- onDeleteResourceListenerMap.end(); ++it)
+ for (auto it = KeepAliveListenerMap.begin(); it !=
+ KeepAliveListenerMap.end(); ++it)
{
if (env->IsSameObject(jListener, it->first))
{
{
refPair.second--;
it->second = refPair;
- onDeleteResourceListenerMap.insert(*it);
- LOGI("onDeleteResourceListener: ref. count decremented");
+ KeepAliveListenerMap.insert(*it);
+ LOGI("KeepAliveListener: ref.count decremented");
}
else
{
env->DeleteGlobalRef(it->first);
- JniOnDeleteResourceListener* listener = refPair.first;
+ JniKeepAliveListener* listener = refPair.first;
delete listener;
- onDeleteResourceListenerMap.erase(it);
- LOGI("onDeleteResourceListener is removed");
+ KeepAliveListenerMap.erase(it);
+ LOGI("KeepAliveListener is removed");
}
isFound = true;
break;
}
if (!isFound)
{
- ThrowOcException(JNI_EXCEPTION, "onDeleteResourceListener not found");
+ ThrowOcException(JNI_EXCEPTION, "KeepAliveListener not found");
}
- deleteResourceListenerMapLock.unlock();
+ KeepAliveListenerMapLock.unlock();
}
-
+#endif
/*
* Class: org_iotivity_base_OcPlatform
* Method: configure
-* Signature: (IILjava/lang/String;II)V
+* Signature: (IILjava/lang/String;IILjava/lang/String;I)V
*/
JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_configure
(JNIEnv *env, jclass clazz, jint jServiceType, jint jModeType, jstring jIpAddress, jint jPort,
- jint jQOS, jstring jDbPath)
+ jint jQOS, jstring jDbPath, jstring jDbPathDefault , jstring jRescueDBPath, jint jkeySize,
+jbyteArray data, jint jTransport)
{
LOGI("OcPlatform_configure");
std::string ipAddress;
- std::string dbfile;
+ std::string dbfile, defaultPath, rescuePath;
+ static unsigned char *aesKey = NULL;
if (jIpAddress)
{
ipAddress = env->GetStringUTFChars(jIpAddress, nullptr);
dbfile = env->GetStringUTFChars(jDbPath, nullptr);
JniOcSecurity::StoreDbPath(dbfile);
}
+ //Either we have both paths or neither of them.
+ if ((jDbPathDefault && !jRescueDBPath) || (!jDbPathDefault && jRescueDBPath))
+ {
+ ThrowOcException(OC_STACK_INVALID_PARAM, "path cannot be null");
+ return;
+ }
+
+ if (!jDbPathDefault && !jRescueDBPath)
+ {
+ LOGI("Secure SVR DB feature not enable!!");
+ }
+ else
+ {
+ aesKey = (unsigned char*)calloc(1, sizeof(unsigned char) * AES_KEY_SIZE);
+ defaultPath = env->GetStringUTFChars(jDbPathDefault, nullptr);
+ rescuePath = env->GetStringUTFChars(jRescueDBPath, nullptr);
+ OC::JniOcSecurity::StoreDefault_DbPath(defaultPath, rescuePath, (int)jkeySize);
+
+ jbyte* key = env->GetByteArrayElements(data, 0);
+ jsize arrayLength = env->GetArrayLength(data);
+ if(arrayLength != AES_KEY_SIZE)
+ {
+ ThrowOcException(OC_STACK_INVALID_PARAM, "key size mismatch");
+ }
+ else
+ {
+ for(int i=0;i < AES_KEY_SIZE; i++)
+ {
+ aesKey[i]=(jbyte)key[i];
+ }
+ }
+
+ }
uint16_t port = 0;
if (jPort > 0)
{
JniUtils::getModeType(env, jModeType),
ipAddress,
port,
+ JniUtils::getOCTransportAdapter(jTransport),
JniUtils::getQOS(env, static_cast<int>(jQOS)),
- JniOcSecurity::getOCPersistentStorage()
+ aesKey,
+ JniOcSecurity::getOCPersistentStorage(),
+ JniOcSecurity::getOCPersistentStorageEnc(),
+ JniOcSecurity::getOCPersistentStorageRescue()
};
+
OCPlatform::Configure(cfg);
+
+}
+
+/*
+* Class: org_iotivity_base_OcPlatform
+* Method: stop
+* Signature: ()V
+*/
+JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_stop
+(JNIEnv *env, jclass clazz)
+{
+ LOGI("OcPlatform.stop");
+
+ try {
+ OCStackResult result = OCPlatform::stop();
+ if (OC_STACK_OK != result)
+ {
+ ThrowOcException(result, "Failed to stop ocplatform");
+ return;
+ }
+ }
+ catch (OCException& e)
+ {
+ LOGE("%s", e.reason().c_str());
+ ThrowOcException(e.code(), e.reason().c_str());
+ }
+}
+
+/*
+* Class: org_iotivity_base_OcPlatform
+* Method: start
+* Signature: ()V
+*/
+JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_start
+(JNIEnv *env, jclass clazz)
+{
+ LOGI("OcPlatform.start");
+
+ try {
+ OCStackResult result = OCPlatform::start();
+ if (OC_STACK_OK != result)
+ {
+ ThrowOcException(result, "Failed to start ocplatform");
+ return;
+ }
+ }
+ catch (OCException& e)
+ {
+ LOGE("%s", e.reason().c_str());
+ ThrowOcException(e.code(), e.reason().c_str());
+ }
}
/*
ThrowOcException(OC_STACK_INVALID_PARAM, "onPlatformFoundListener cannot be null");
return;
}
- JniOnDeviceInfoListener *onDeviceInfoListener = AddOnDeviceInfoListener(env, jListener);
+ JniOnPlatformInfoListener *onPlatformInfoListener = AddOnPlatformInfoListener(env, jListener);
- FindDeviceCallback findDeviceCallback =
- [onDeviceInfoListener](const OCRepresentation& ocRepresentation)
+ FindPlatformCallback findPlatformCallback =
+ [onPlatformInfoListener](const OCRepresentation& ocRepresentation)
{
- onDeviceInfoListener->foundDeviceCallback(ocRepresentation);
+ onPlatformInfoListener->foundPlatformCallback(ocRepresentation);
};
try
host,
resourceUri,
static_cast<OCConnectivityType>(jConnectivityType),
- findDeviceCallback,
+ findPlatformCallback,
JniUtils::getQOS(env, static_cast<int>(jQoS)));
if (OC_STACK_OK != result)
}
OCDeviceInfo deviceInfo;
+ memset(&deviceInfo, 0, sizeof(deviceInfo));
try
{
DuplicateString(&deviceInfo.deviceName, env->GetStringUTFChars(jDeviceName, nullptr));
- deviceInfo.types = NULL;
jsize len = env->GetArrayLength(jDeviceTypes);
for (jsize i = 0; i < len; ++i)
jstring jStr = (jstring)env->GetObjectArrayElement(jDeviceTypes, i);
if (!jStr)
{
- delete deviceInfo.deviceName;
+ delete[] deviceInfo.deviceName;
ThrowOcException(OC_STACK_INVALID_PARAM, "device type cannot be null");
return;
}
OCResourcePayloadAddStringLL(&deviceInfo.types, env->GetStringUTFChars(jStr, nullptr));
if (env->ExceptionCheck())
{
- delete deviceInfo.deviceName;
+ delete[] deviceInfo.deviceName;
return;
}
{
OCStackResult result = OCPlatform::registerDeviceInfo(deviceInfo);
- delete deviceInfo.deviceName;
+ delete[] deviceInfo.deviceName;
if (OC_STACK_OK != result)
{
{
OCStackResult result = OCPlatform::registerPlatformInfo(platformInfo);
- delete platformInfo.platformID;
- delete platformInfo.manufacturerName;
- delete platformInfo.manufacturerUrl;
- delete platformInfo.modelNumber;
- delete platformInfo.dateOfManufacture;
- delete platformInfo.platformVersion;
- delete platformInfo.operatingSystemVersion;
- delete platformInfo.hardwareVersion;
- delete platformInfo.firmwareVersion;
- delete platformInfo.supportUrl;
- delete platformInfo.systemTime;
+ delete[] platformInfo.platformID;
+ delete[] platformInfo.manufacturerName;
+ delete[] platformInfo.manufacturerUrl;
+ delete[] platformInfo.modelNumber;
+ delete[] platformInfo.dateOfManufacture;
+ delete[] platformInfo.platformVersion;
+ delete[] platformInfo.operatingSystemVersion;
+ delete[] platformInfo.hardwareVersion;
+ delete[] platformInfo.firmwareVersion;
+ delete[] platformInfo.supportUrl;
+ delete[] platformInfo.systemTime;
if (OC_STACK_OK != result)
{
}
}
+JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_setPropertyValue0
+ (JNIEnv *env, jclass clazz, jint jType, jstring jPropName, jobjectArray jPropValue)
+{
+ try
+ {
+ OCPayloadType type = (OCPayloadType)jType;
+ std::string propName;
+ std::vector<std::string> propValue;
+ if (jPropName)
+ {
+ propName = env->GetStringUTFChars(jPropName, nullptr);
+ }
+ if (jPropValue)
+ {
+ JniUtils::convertJavaStrArrToStrVector(env, jPropValue, propValue);
+ }
+ OCStackResult result = OCPlatform::setPropertyValue(type, propName, propValue);
+ if (OC_STACK_OK != result)
+ {
+ ThrowOcException(result, "Failed to set property");
+ return;
+ }
+ }
+ catch (OCException& e)
+ {
+ LOGE("Error is due to %s", e.reason().c_str());
+ ThrowOcException(e.code(), e.reason().c_str());
+ }
+
+}
+
+/*
+* Class: org_iotivity_base_OcPlatform
+* Method: setPropertyValue0
+* Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
+*/
+JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_setPropertyValue1
+ (JNIEnv *env, jclass clazz, jint jType, jstring jPropName, jstring jPropValue)
+{
+ try
+ {
+ OCPayloadType type = (OCPayloadType)jType;
+ std::string propName;
+ std::string propValue;
+ if (jPropName)
+ {
+ propName = env->GetStringUTFChars(jPropName, nullptr);
+ }
+ if (jPropValue)
+ {
+ propValue = env->GetStringUTFChars(jPropValue, nullptr);
+ }
+ OCStackResult result = OCPlatform::setPropertyValue(type, propName, propValue);
+ if (OC_STACK_OK != result)
+ {
+ ThrowOcException(result, "Failed to set property");
+ return;
+ }
+ }
+ catch (OCException& e)
+ {
+ LOGE("Error is due to %s", e.reason().c_str());
+ ThrowOcException(e.code(), e.reason().c_str());
+ }
+}
+
+/*
+* Class: org_iotivity_base_OcPlatform
+* Method: getPropertyValue
+* Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
+*/
+JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_getPropertyValue0
+ (JNIEnv *env, jclass clazz, jint jType, jstring jPropName, jstring jPropValue)
+{
+ try
+ {
+ OCPayloadType type = (OCPayloadType) jType;
+ std::string propName;
+ std::string propValue;
+
+ if (jPropName)
+ {
+ propName = env->GetStringUTFChars(jPropName, nullptr);
+ }
+ OCStackResult result = OCPlatform::getPropertyValue(type, propName, propValue);
+ if (OC_STACK_OK != result)
+ {
+ ThrowOcException(result, "Failed to get property value.");
+ return;
+ }
+ }
+ catch (OCException& e)
+ {
+ LOGE("Error is due to %s", e.reason().c_str());
+ ThrowOcException(e.code(), e.reason().c_str());
+ }
+}
+
/*
* Class: org_iotivity_base_OcPlatform
* Method: unregisterResource0
}
/*
- * Class: org_iotivity_base_OcPlatform
- * Method: publishResourceToRD0
- * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnPublishResourceListener;I)V
- */
-JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_publishResourceToRD0(
- JNIEnv *env,
- jclass clazz,
- jstring jHost,
- jint jConnectivityType,
- jobject jListener,
- jint jQoS)
+* Class: org_iotivity_base_OcPlatform
+* Method: constructAccountManagerObject0
+* Signature: (Ljava/lang/String;I)Lorg/iotivity/base/OcAccountManager;
+*/
+JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_constructAccountManagerObject0(
+ JNIEnv *env,
+ jclass clazz,
+ jstring jHost,
+ jint jConnectivityType)
{
- LOGD("OcPlatform_publishResourceToRD");
-#ifdef RD_CLIENT
- std::string host;
- if (jHost)
+#ifndef WITH_CLOUD
+ ThrowOcException(OC_STACK_ERROR,
+ "OCAccountManager is not supported. (Please build with WITH_CLOUD=1 option)");
+ return nullptr;
+#else
+ LOGD("OcPlatform_constructAccountManagerObject");
+ if (!jHost)
{
- host = env->GetStringUTFChars(jHost, nullptr);
+ ThrowOcException(OC_STACK_INVALID_PARAM, "host cannot be null");
+ return nullptr;
}
- if (!jListener)
+
+ const char* charHost = env->GetStringUTFChars(jHost, nullptr);
+ if (!charHost)
{
- ThrowOcException(OC_STACK_INVALID_PARAM, "onPublishResourceListener cannot be null");
- return;
+ ThrowOcException(JNI_EXCEPTION, "charHost is null");
+ return nullptr;
}
- JniOnPublishResourceListener *onPubResListener = AddOnPublishResourceListener(env, jListener);
+ std::string host(charHost);
+ env->ReleaseStringUTFChars(jHost, charHost);
- PublishResourceCallback pubResCallback = [onPubResListener](
- const OCRepresentation& ocRepresentation,
- const int eCode)
- {
- onPubResListener->onPublishResourceCallback(ocRepresentation, eCode);
- };
+ std::shared_ptr<OCAccountManager> accountManager = OCPlatform::constructAccountManagerObject(
+ host,
+ static_cast<OCConnectivityType>(jConnectivityType));
- try
+ if (!accountManager)
{
- OCStackResult result = OCPlatform::publishResourceToRD(
- host,
- static_cast<OCConnectivityType>(jConnectivityType),
- pubResCallback,
- JniUtils::getQOS(env, static_cast<int>(jQoS)));
+ ThrowOcException(OC_STACK_ERROR, "Failed to create OCAccountManager");
+ return nullptr;
+ }
- if (OC_STACK_OK != result)
- {
- ThrowOcException(result, "Publish resource has failed");
- return;
- }
+ JniOcAccountManager *jniOcAccountManager = new JniOcAccountManager(accountManager);
+
+ jobject jAccountManager = env->NewObject(g_cls_OcAccountManager, g_mid_OcAccountManager_ctor);
+ if (!jAccountManager)
+ {
+ delete jniOcAccountManager;
+ return nullptr;
}
- catch (OCException& e)
+ SetHandle<JniOcAccountManager>(env, jAccountManager, jniOcAccountManager);
+ if (env->ExceptionCheck())
{
- LOGE("%s", e.reason().c_str());
- ThrowOcException(e.code(), e.reason().c_str());
+ delete jniOcAccountManager;
+ return nullptr;
}
-#else
- ThrowOcException(JNI_NO_SUPPORT, "Not supported");
- return;
+ return jAccountManager;
#endif
}
/*
- * Class: org_iotivity_base_OcPlatform
- * Method: publishResourceToRD1
- * Signature: (Ljava/lang/String;I[Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcPlatform/OnPublishResourceListener;I)V
- */
-JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_publishResourceToRD1(
- JNIEnv *env,
- jclass clazz,
- jstring jHost,
- jint jConnectivityType,
- jobjectArray jResourceHandleArray,
- jobject jListener,
- jint jQoS)
+* Class: org_iotivity_base_OcPlatform
+* Method: getDeviceId
+* Signature: (I)V
+*/
+JNIEXPORT jbyteArray JNICALL Java_org_iotivity_base_OcPlatform_getDeviceId
+(JNIEnv *env, jobject thiz)
{
- LOGD("OcPlatform_publishResourceToRD");
-#ifdef RD_CLIENT
- if (!env)
- {
- LOGE("env is null");
- return;
- }
- std::string host;
- if (jHost)
- {
- host = env->GetStringUTFChars(jHost, nullptr);
- }
- if (!jListener)
- {
- ThrowOcException(OC_STACK_INVALID_PARAM, "onPublishResourceListener cannot be null");
- return;
- }
- if (!jResourceHandleArray)
- {
- ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
- return;
- }
- JniOnPublishResourceListener *onPubResListener = AddOnPublishResourceListener(env, jListener);
+ LOGD("OcPlatform_getDeviceId");
+ OCUUIdentity deviceId;
- PublishResourceCallback pubResCallback = [onPubResListener](
- const OCRepresentation& ocRepresentation,
- const int eCode)
+ jbyteArray ret = env->NewByteArray(UUID_IDENTITY_SIZE);
+ jbyte uuid[UUID_IDENTITY_SIZE];
+ try
{
- onPubResListener->onPublishResourceCallback(ocRepresentation, eCode);
- };
- std::vector<OCResourceHandle> resourceHandleList;
- size_t len = env->GetArrayLength(jResourceHandleArray);
- for (size_t i = 0; i < len; ++i)
- {
- jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
- if (!jResourceHandle)
+ OCStackResult result = OCPlatform::getDeviceId(&deviceId);
+ LOGD("OcPlatform_getDeviceId return from CPP");
+ if (OC_STACK_OK != result)
{
- ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
- return;
+ ThrowOcException(result, "Error while getting my device Id");
}
-
- JniOcResourceHandle* jniOcResourceHandle =
- JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
- if (!jniOcResourceHandle)
+ else
{
- ThrowOcException(OC_STACK_INVALID_PARAM, "resource handle is invalid");
- return;
+ for(int i=0;i < UUID_IDENTITY_SIZE; i++)
+ {
+ uuid[i] =(jbyte) deviceId.id[i];
+ }
}
- resourceHandleList.push_back(jniOcResourceHandle->getOCResourceHandle());
+ }
+ catch (OCException& e)
+ {
+ LOGE("%s", e.reason().c_str());
+ ThrowOcException(e.code(), e.reason().c_str());
}
+ env->SetByteArrayRegion(ret, 0, UUID_IDENTITY_SIZE, uuid);
+
+ return ret;
+}
+
+/*
+* Class: org_iotivity_base_OcPlatform
+* Method: setDeviceId
+* Signature: (Ljava/lang/byte;)V
+*/
+JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_setDeviceId(
+ JNIEnv *env, jobject thiz, jbyteArray data)
+{
+ LOGI("OcPlatform_setDeviceId");
+ OCUUIdentity deviceId;
try
{
- OCStackResult result = OCPlatform::publishResourceToRD(
- host,
- static_cast<OCConnectivityType>(jConnectivityType),
- resourceHandleList,
- pubResCallback,
- JniUtils::getQOS(env, static_cast<int>(jQoS)));
-
- if (OC_STACK_OK != result)
+ OCStackResult result;
+ jbyte* uuid = env->GetByteArrayElements(data, 0);
+ jsize arrayLength = env->GetArrayLength(data);
+ if(arrayLength!=UUID_IDENTITY_SIZE)
{
- ThrowOcException(result, "Publish resource has failed");
- return;
+ ThrowOcException(OC_STACK_INVALID_PARAM, "Byte length not equal to UUID_IDENTITY_SIZE");
+ }
+ else
+ {
+ for(int i=0;i < UUID_IDENTITY_SIZE; i++)
+ {
+ deviceId.id[i]=(jchar)uuid[i];
+ }
+ result = OCPlatform::setDeviceId(&deviceId);
+ if (OC_STACK_OK != result)
+ {
+ ThrowOcException(result, "Failed to set DeviceId");
+ }
}
}
catch (OCException& e)
LOGE("%s", e.reason().c_str());
ThrowOcException(e.code(), e.reason().c_str());
}
-#else
- ThrowOcException(JNI_NO_SUPPORT, "Not supported");
- return;
-#endif
}
/*
* Class: org_iotivity_base_OcPlatform
- * Method: deleteResourceFromRD0
- * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/OnDeleteResourceListener;I)V
+ * Method: findKeepAliveResourceImpl
+ * Signature: (Ljava/lang/String;Lorg/iotivity/base/OcPlatform/KeepAliveListener;)V
*/
-JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_deleteResourceFromRD0(
- JNIEnv *env,
- jclass clazz,
- jstring jHost,
- jint jConnectivityType,
- jobject jListener,
- jint jQoS)
+JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_findKeepAliveResourceImpl(
+ JNIEnv *env, jclass clazz, jstring jHost, jobject jListener)
{
- LOGD("OcPlatform_deleteResourceFromRD");
-#ifdef RD_CLIENT
+#ifndef TCP_ADAPTER
+ ThrowOcException(OC_STACK_ERROR,
+ "findKeepAliveResource is not supported. (Please build with WITH_TCP=1 option)");
+ return;
+#else
+ LOGI("OcPlatform_findKeepAliveResource");
std::string host;
- if (jHost)
+ if (!jHost)
+ {
+ ThrowOcException(OC_STACK_INVALID_PARAM, "host cannot be null");
+ return;
+ }
+ else
{
host = env->GetStringUTFChars(jHost, nullptr);
}
+
if (!jListener)
{
- ThrowOcException(OC_STACK_INVALID_PARAM, "onDeleteResourceListener cannot be null");
+ ThrowOcException(OC_STACK_INVALID_PARAM, "onKeepAliveFoundListener cannot be null");
return;
}
- JniOnDeleteResourceListener *onDelResListener = AddOnDeleteResourceListener(env, jListener);
- DeleteResourceCallback delResCallback = [onDelResListener](const int eCode)
+ JniKeepAliveListener *onKeepAliveFoundListener = AddKeepAliveListener(env, jListener);
+
+ KeepAliveCallback KeepAliveCallback = [onKeepAliveFoundListener](const int ret,
+ const OCRepresentation& rep)
{
- onDelResListener->onDeleteResourceCallback(eCode);
+ onKeepAliveFoundListener->onKeepAliveListener(ret, rep);
};
try
{
- OCStackResult result = OCPlatform::deleteResourceFromRD(
- host,
- static_cast<OCConnectivityType>(jConnectivityType),
- delResCallback,
- JniUtils::getQOS(env, static_cast<int>(jQoS)));
+ OCStackResult result = OCPlatform::findKeepAliveResource(host, KeepAliveCallback);
if (OC_STACK_OK != result)
{
- ThrowOcException(result, "Delete resource has failed");
- return;
+ ThrowOcException(result, "findKeepAliveResource has failed");
}
}
catch (OCException& e)
{
LOGE("%s", e.reason().c_str());
ThrowOcException(e.code(), e.reason().c_str());
+ return;
}
-#else
- ThrowOcException(JNI_NO_SUPPORT, "Not supported");
- return;
#endif
}
/*
* Class: org_iotivity_base_OcPlatform
- * Method: deleteResourceFromRD1
- * Signature: (Ljava/lang/String;I[Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcPlatform/OnDeleteResourceListener;I)V
+ * Method: sendKeepAliveRequestImpl
+ * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcPlatform/KeepAliveListener;)V
*/
-JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_deleteResourceFromRD1(
- JNIEnv *env,
- jclass clazz,
- jstring jHost,
- jint jConnectivityType,
- jobjectArray jResourceHandleArray,
- jobject jListener,
- jint jQoS)
+JNIEXPORT void JNICALL Java_org_iotivity_base_OcPlatform_sendKeepAliveRequestImpl(
+ JNIEnv *env, jclass clazz, jstring jHost, jobject jRep, jobject jListener)
{
- LOGD("OcPlatform_deleteResourceFromRD");
-#ifdef RD_CLIENT
- if (!env)
+#ifndef TCP_ADAPTER
+ ThrowOcException(OC_STACK_ERROR,
+ "sendKeepAlive is not supported. (Please build with WITH_TCP=1 option)");
+ return;
+#else
+ LOGI("OcPlatform_sendKeepAliveRequest");
+ std::string host;
+ if (!jHost)
{
- LOGE("env is null");
+ ThrowOcException(OC_STACK_INVALID_PARAM, "host cannot be null");
return;
}
- std::string host;
- if (jHost)
+ else
{
host = env->GetStringUTFChars(jHost, nullptr);
}
+
if (!jListener)
{
- ThrowOcException(OC_STACK_INVALID_PARAM, "onDeleteResourceListener cannot be null");
- return;
- }
- if (!jResourceHandleArray)
- {
- ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
+ ThrowOcException(OC_STACK_INVALID_PARAM, "keepAliveResponseListener cannot be null");
return;
- }
- JniOnDeleteResourceListener *onDelResListener = AddOnDeleteResourceListener(env, jListener);
-
- DeleteResourceCallback delResCallback = [onDelResListener](const int eCode)
- {
- onDelResListener->onDeleteResourceCallback(eCode);
};
- std::vector<OCResourceHandle> resourceHandleList;
- size_t len = env->GetArrayLength(jResourceHandleArray);
- for (size_t i = 0; i < len; ++i)
- {
- jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
- if (!jResourceHandle)
- {
- ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
- return;
- }
-
- JniOcResourceHandle* jniOcResourceHandle =
- JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
- if (!jniOcResourceHandle)
- {
- ThrowOcException(OC_STACK_INVALID_PARAM, "resource handle is invalid");
- return;
- }
+ JniKeepAliveListener *KeepAliveResponseListener = AddKeepAliveListener(env, jListener);
- resourceHandleList.push_back(jniOcResourceHandle->getOCResourceHandle());
- }
+ KeepAliveCallback KeepAliveCallback = [KeepAliveResponseListener](const int ret,
+ const OCRepresentation& rep)
+ {
+ KeepAliveResponseListener->onKeepAliveListener(ret, rep);
+ };
try
{
- OCStackResult result = OCPlatform::deleteResourceFromRD(
- host,
- static_cast<OCConnectivityType>(jConnectivityType),
- resourceHandleList,
- delResCallback,
- JniUtils::getQOS(env, static_cast<int>(jQoS)));
+ OCRepresentation *rep = JniOcRepresentation::getOCRepresentationPtr(env, jRep);
+ OCStackResult result = OCPlatform::sendKeepAliveRequest(host, *rep, KeepAliveCallback);
if (OC_STACK_OK != result)
{
- ThrowOcException(result, "Delete resource has failed");
- return;
+ ThrowOcException(result, "sendKeepAliveRequest has failed");
}
}
catch (OCException& e)
{
LOGE("%s", e.reason().c_str());
ThrowOcException(e.code(), e.reason().c_str());
+ return;
}
-#else
- ThrowOcException(JNI_NO_SUPPORT, "Not supported");
- return;
-#endif
-}
-
-/*
-* Class: org_iotivity_base_OcPlatform
-* Method: constructAccountManagerObject0
-* Signature: (Ljava/lang/String;I)Lorg/iotivity/base/OcAccountManager;
-*/
-JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcPlatform_constructAccountManagerObject0(
- JNIEnv *env,
- jclass clazz,
- jstring jHost,
- jint jConnectivityType)
-{
-#ifndef WITH_CLOUD
- ThrowOcException(OC_STACK_ERROR,
- "OCAccountManager is not supported. (Please build with WITH_CLOUD=1 option)");
- return nullptr;
-#else
- LOGD("OcPlatform_constructAccountManagerObject");
- if (!jHost)
- {
- ThrowOcException(OC_STACK_INVALID_PARAM, "host cannot be null");
- return nullptr;
- }
-
- const char* charHost = env->GetStringUTFChars(jHost, nullptr);
- if (!charHost)
- {
- ThrowOcException(JNI_EXCEPTION, "charHost is null");
- return nullptr;
- }
- std::string host(charHost);
- env->ReleaseStringUTFChars(jHost, charHost);
-
- std::shared_ptr<OCAccountManager> accountManager = OCPlatform::constructAccountManagerObject(
- host,
- static_cast<OCConnectivityType>(jConnectivityType));
-
- if (!accountManager)
- {
- ThrowOcException(OC_STACK_ERROR, "Failed to create OCAccountManager");
- return nullptr;
- }
-
- JniOcAccountManager *jniOcAccountManager = new JniOcAccountManager(accountManager);
-
- jobject jAccountManager = env->NewObject(g_cls_OcAccountManager, g_mid_OcAccountManager_ctor);
- if (!jAccountManager)
- {
- delete jniOcAccountManager;
- return nullptr;
- }
- SetHandle<JniOcAccountManager>(env, jAccountManager, jniOcAccountManager);
- if (env->ExceptionCheck())
- {
- delete jniOcAccountManager;
- return nullptr;
- }
- return jAccountManager;
#endif
}
projects / platform / upstream / iotivity.git / blobdiff