void write(std::string time, ILogger::Level level, std::string message)
{
JNIEnv *env = getEnv();
if (nullptr == env)
return;
jobject logger = env->NewLocalRef(m_logger);
if (!logger)
{
releaseEnv();
return;
}
jclass loggerCls = env->GetObjectClass(logger);
if (!loggerCls)
{
releaseEnv();
return;
}
jmethodID writeMId = env->GetMethodID(loggerCls, "write",
"(Ljava/lang/String;ILjava/lang/String;)V");
if (!writeMId)
{
releaseEnv();
return;
}
jstring msg = env->NewStringUTF(message.c_str());
jstring timeStr = env->NewStringUTF(time.c_str());
env->CallVoidMethod(logger, writeMId, timeStr, static_cast<jint>(level), msg);
env->DeleteLocalRef(msg);
env->DeleteLocalRef(timeStr);
releaseEnv();
}
void onDeviceInfoReceived(jobject listener, const std::string &hostUri, DeviceInfo &deviceInfo)
{
JNIEnv *env = getEnv();
if (!env)
return;
jclass listenerCls = env->GetObjectClass(listener);
jmethodID listenerMethodId = env->GetMethodID(listenerCls, "onDeviceFound",
"(Ljava/lang/String;Lorg/oic/simulator/DeviceInfo;)V");
jstring jHostUri = env->NewStringUTF(hostUri.c_str());
jobject jDeviceInfo = JniDeviceInfo(env).toJava(deviceInfo);
if (!jDeviceInfo)
{
releaseEnv();
return;
}
env->CallVoidMethod(listener, listenerMethodId, jHostUri, jDeviceInfo);
if (env->ExceptionCheck())
{
releaseEnv();
return;
}
releaseEnv();
}
void onDeviceInfoReceived(jobject listener, DeviceInfo &deviceInfo)
{
JNIEnv *env = getEnv();
if (!env)
return;
jclass listenerCls = env->GetObjectClass(listener);
jmethodID listenerMethodId = env->GetMethodID(listenerCls, "onDeviceFound",
"(Lorg/oic/simulator/DeviceInfo;)V");
jobject jDeviceInfo = JniDeviceInfo(env).toJava(deviceInfo);
if (!jDeviceInfo)
{
releaseEnv();
return;
}
env->CallVoidMethod(listener, listenerMethodId, jDeviceInfo);
if (env->ExceptionCheck())
{
releaseEnv();
return;
}
releaseEnv();
}
void onObserverChange(jweak jlistenerRef, const std::string &uri,
ObservationStatus state, const ObserverInfo &observerInfo)
{
JNIEnv *env = getEnv();
if (nullptr == env)
return;
jobject observerChangeListener = env->NewLocalRef(jlistenerRef);
if (!observerChangeListener)
{
releaseEnv();
return;
}
jclass observerChangeCls = env->GetObjectClass(observerChangeListener);
if (!observerChangeCls)
{
releaseEnv();
return;
}
jmethodID observerChangeMId = env->GetMethodID(observerChangeCls, "onObserverChanged",
"(Ljava/lang/String;ILorg/oic/simulator/serviceprovider/ObserverInfo;)V");
if (!observerChangeMId)
{
releaseEnv();
return;
}
// Convert URI
jstring jUri = env->NewStringUTF(uri.c_str());
// Convert state
jint jstate = (state == ObservationStatus::OBSERVE_REGISTER) ? 0 : 1;
// Construct the java object of observerinfo
jstring jaddress = env->NewStringUTF(observerInfo.address.c_str());
jobject jobserver = (jobject) env->NewObject(gSimulatorClassRefs.classObserverInfo,
gSimulatorClassRefs.classObserverInfoCtor, observerInfo.id,
jaddress, observerInfo.port);
env->CallVoidMethod(observerChangeListener, observerChangeMId, jUri, jstate, jobserver);
env->DeleteLocalRef(jaddress);
if ((env)->ExceptionCheck())
{
releaseEnv();
return;
}
env->DeleteLocalRef(jUri);
releaseEnv();
}
void onVerificationCallback(jobject listener, const std::string &uid, int id,
OperationState opState)
{
JNIEnv *env = getEnv();
if (!env)
return;
jclass listenerCls = env->GetObjectClass(listener);
jmethodID listenerMethodId;
if (OP_START == opState)
{
listenerMethodId = env->GetMethodID(listenerCls, "onVerificationStarted", "(Ljava/lang/String;I)V");
}
else if (OP_COMPLETE == opState)
{
listenerMethodId = env->GetMethodID(listenerCls, "onVerificationCompleted",
"(Ljava/lang/String;I)V");
}
else if (OP_ABORT == opState)
{
listenerMethodId = env->GetMethodID(listenerCls, "onVerificationAborted", "(Ljava/lang/String;I)V");
}
jstring jUid = env->NewStringUTF(uid.c_str());
env->CallVoidMethod(listener, listenerMethodId, jUid, id);
if (OP_COMPLETE == opState || OP_ABORT == opState)
env->DeleteGlobalRef(listener);
releaseEnv();
}
void onAutomationComplete(jweak jlistenerRef, const std::string &uri,
const int automationID)
{
JNIEnv *env = getEnv();
if (nullptr == env)
return;
jobject autoCompleteListener = env->NewLocalRef(jlistenerRef);
if (!autoCompleteListener)
{
releaseEnv();
return;
}
jclass autoCompleteCls = env->GetObjectClass(autoCompleteListener);
if (!autoCompleteCls)
{
releaseEnv();
return;
}
jmethodID autoCompleteMId = env->GetMethodID(autoCompleteCls, "onAutomationComplete",
"(Ljava/lang/String;I)V");
if (!autoCompleteMId)
{
releaseEnv();
return;
}
jstring jUri = env->NewStringUTF(uri.c_str());
env->CallVoidMethod(autoCompleteListener, autoCompleteMId, jUri, automationID);
if ((env)->ExceptionCheck())
{
releaseEnv();
return;
}
env->DeleteLocalRef(jUri);
releaseEnv();
}
static void onAutoUpdationComplete(jobject listener, const std::string &uri, const int id)
{
JNIEnv *env = getEnv();
if (!env)
return;
jclass listenerCls = env->GetObjectClass(listener);
jmethodID listenerMethod = env->GetMethodID(listenerCls, "onUpdateComplete",
"(Ljava/lang/String;I)V");
jstring jUri = env->NewStringUTF(uri.c_str());
env->CallVoidMethod(listener, listenerMethod, jUri, id);
releaseEnv();
}
void onObserveCallback(jobject listener, const std::string &uid, const int errorCode,
SimulatorResourceModelSP representation, const int seq)
{
JNIEnv *env = getEnv();
if (!env)
return;
jclass listenerCls = env->GetObjectClass(listener);
jmethodID listenerMethodId = env->GetMethodID(listenerCls, "onObserveNotification",
"(Ljava/lang/String;Lorg/oic/simulator/SimulatorResourceModel;I)V");
SimulatorResourceModel *resModel = representation.get();
jobject jResModel = simulatorResourceModelToJava(env, *resModel);
jstring jUid = env->NewStringUTF(uid.c_str());
env->CallVoidMethod(listener, listenerMethodId, jUid, jResModel, seq);
releaseEnv();
}
Object & Object::operator =(const Object &otherobject) {
jobject oldjthis = jthis;
jobject _newjthis = otherobject.jthis;
jobject newjthis= NULL;
jthis= NULL;
JNIEnv *env = getEnv();
if (_newjthis != NULL) {
if(debug_j4cpp) DebugPrintJObject(__FILE__,__LINE__,"Object::operator= called for _newjthis=",_newjthis);
newjthis = env->NewGlobalRef(_newjthis);
}
if (NULL != oldjthis) {
if(debug_j4cpp) DebugPrintJObject(__FILE__,__LINE__,"Object::operator= called for oldjthis=",oldjthis);
env->DeleteGlobalRef(oldjthis);
oldjthis = NULL;
}
jthis=newjthis;
releaseEnv(env);
return *this;
}
void onPutCallback(jobject listener, const std::string &uid, int errorCode,
SimulatorResourceModelSP representation)
{
JNIEnv *env = getEnv();
if (!env)
return;
jclass listenerCls = env->GetObjectClass(listener);
jmethodID listenerMethodId = env->GetMethodID(listenerCls, "onPutResponse",
"(Ljava/lang/String;Lorg/oic/simulator/SimulatorResult;Lorg/oic/simulator/SimulatorResourceModel;)V");
SimulatorResourceModel *resModel = representation.get();
jobject jResModel = simulatorResourceModelToJava(env, *resModel);
jstring jUid = env->NewStringUTF(uid.c_str());
env->CallVoidMethod(listener, listenerMethodId, jUid,
simulatorResultToJava(env, static_cast<SimulatorResult>(errorCode)), jResModel);
releaseEnv();
}
void onResourceModelChange(jweak jlistenerRef, const std::string &uri,
const SimulatorResourceModel &resModel)
{
JNIEnv *env = getEnv();
if (nullptr == env)
return;
jobject modelChangeListener = env->NewLocalRef(jlistenerRef);
if (!modelChangeListener)
{
releaseEnv();
return;
}
jclass modelChangeCls = env->GetObjectClass(modelChangeListener);
if (!modelChangeCls)
{
releaseEnv();
return;
}
jmethodID foundModelChangeMId = env->GetMethodID(modelChangeCls, "onResourceModelChanged",
"(Ljava/lang/String;Lorg/oic/simulator/SimulatorResourceModel;)V");
if (!foundModelChangeMId)
{
releaseEnv();
return;
}
JSimulatorResourceModel *jniModel = new JSimulatorResourceModel(resModel);
if (!jniModel)
{
releaseEnv();
return;
}
jobject jModel = JSimulatorResourceModel::toJava(env, reinterpret_cast<jlong>(jniModel));
jstring jUri = env->NewStringUTF(uri.c_str());
env->CallVoidMethod(modelChangeListener, foundModelChangeMId, jUri, jModel);
if ((env)->ExceptionCheck())
{
delete jniModel;
releaseEnv();
return;
}
env->DeleteLocalRef(jUri);
releaseEnv();
}
void onFoundResource(std::shared_ptr<SimulatorRemoteResource> resource)
{
JNIEnv *env = getEnv();
if (nullptr == env)
return;
jobject foundResourceListener = env->NewLocalRef(m_listener);
if (!foundResourceListener)
{
releaseEnv();
return;
}
jclass foundResourceCls = env->GetObjectClass(foundResourceListener);
if (!foundResourceCls)
{
releaseEnv();
return;
}
jmethodID foundResourceMId = env->GetMethodID(foundResourceCls, "onResourceCallback",
"(Lorg/oic/simulator/clientcontroller/SimulatorRemoteResource;)V");
if (!foundResourceMId)
{
releaseEnv();
return;
}
JniSimulatorRemoteResource *jniSimulatorResource = new JniSimulatorRemoteResource(resource);
if (!jniSimulatorResource)
{
releaseEnv();
return;
}
jobject simulatorResource = SimulatorRemoteResourceToJava(env,
reinterpret_cast<jlong>(jniSimulatorResource));
jfieldID fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mUri",
"Ljava/lang/String;");
jstring jUri = env->NewStringUTF(resource->getURI().c_str());
env->SetObjectField(simulatorResource, fieldID, jUri);
fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mConnType", "I");
jint jConnType = resource->getConnectivityType();
env->SetIntField(simulatorResource, fieldID, jConnType);
fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mHost",
"Ljava/lang/String;");
jstring jHost = env->NewStringUTF(resource->getHost().c_str());
env->SetObjectField(simulatorResource, fieldID, jHost);
fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mId",
"Ljava/lang/String;");
jstring jUid = env->NewStringUTF(resource->getID().c_str());
env->SetObjectField(simulatorResource, fieldID, jUid);
fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mResTypes",
"Ljava/util/LinkedList;");
std::vector<std::string> resourceTypes = resource->getResourceTypes();
jobject jResTypes = convertStringVectorToJavaList(env, resourceTypes);
env->SetObjectField(simulatorResource, fieldID, jResTypes);
fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mResInterfaces",
"Ljava/util/LinkedList;");
std::vector<std::string> interfaceTypes = resource->getResourceInterfaces();
jobject jResInterfaces = convertStringVectorToJavaList(env, interfaceTypes);
env->SetObjectField(simulatorResource, fieldID, jResInterfaces);
fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mIsObservable", "Z");
env->SetBooleanField(simulatorResource, fieldID, resource->isObservable());
env->CallVoidMethod(foundResourceListener, foundResourceMId, simulatorResource);
if ((env)->ExceptionCheck())
{
delete jniSimulatorResource;
releaseEnv();
return;
}
releaseEnv();
}
