From 3b4b9a88189bf74c16df4f4e7527a2eb753f539b Mon Sep 17 00:00:00 2001 From: Alexander Zagumennikov Date: Sun, 15 Sep 2013 16:06:03 +0400 Subject: [PATCH] Missed OpenZWave methods. --- OpenZWave.patch | 6 +- README | 4 +- src/main/cpp/org_zwave4j_Manager.cpp | 1429 ++++++++++++++++- src/main/cpp/org_zwave4j_Options.cpp | 125 +- .../java/org/zwave4j/CommandClassData.java | 50 + .../java/org/zwave4j/ControllerCallback.java | 30 + .../java/org/zwave4j/ControllerCommand.java | 45 + .../java/org/zwave4j/ControllerError.java | 41 + .../java/org/zwave4j/ControllerInterface.java | 31 + .../java/org/zwave4j/ControllerState.java | 39 + src/main/java/org/zwave4j/DriverData.java | 218 +++ src/main/java/org/zwave4j/Main.java | 26 +- src/main/java/org/zwave4j/Manager.java | 181 ++- src/main/java/org/zwave4j/NodeData.java | 159 ++ .../java/org/zwave4j/NotificationWatcher.java | 2 +- src/main/java/org/zwave4j/OptionType.java | 32 + src/main/java/org/zwave4j/Options.java | 10 + 17 files changed, 2369 insertions(+), 59 deletions(-) create mode 100644 src/main/java/org/zwave4j/CommandClassData.java create mode 100644 src/main/java/org/zwave4j/ControllerCallback.java create mode 100644 src/main/java/org/zwave4j/ControllerCommand.java create mode 100644 src/main/java/org/zwave4j/ControllerError.java create mode 100644 src/main/java/org/zwave4j/ControllerInterface.java create mode 100644 src/main/java/org/zwave4j/ControllerState.java create mode 100644 src/main/java/org/zwave4j/DriverData.java create mode 100644 src/main/java/org/zwave4j/NodeData.java create mode 100644 src/main/java/org/zwave4j/OptionType.java diff --git a/OpenZWave.patch b/OpenZWave.patch index daf8731..a3adf3b 100644 --- a/OpenZWave.patch +++ b/OpenZWave.patch @@ -1,6 +1,6 @@ Index: cpp/src/Defs.h =================================================================== ---- cpp/src/Defs.h (revision 664) +--- cpp/src/Defs.h (revision 665) +++ cpp/src/Defs.h (working copy) @@ -28,6 +28,7 @@ #ifndef _Defs_H @@ -12,7 +12,7 @@ Index: cpp/src/Defs.h #ifdef NULL Index: cpp/src/platform/windows/LogImpl.cpp =================================================================== ---- cpp/src/platform/windows/LogImpl.cpp (revision 664) +--- cpp/src/platform/windows/LogImpl.cpp (revision 665) +++ cpp/src/platform/windows/LogImpl.cpp (working copy) @@ -30,6 +30,32 @@ #include "Defs.h" @@ -49,7 +49,7 @@ Index: cpp/src/platform/windows/LogImpl.cpp //----------------------------------------------------------------------------- Index: cpp/src/platform/windows/TimeStampImpl.cpp =================================================================== ---- cpp/src/platform/windows/TimeStampImpl.cpp (revision 664) +--- cpp/src/platform/windows/TimeStampImpl.cpp (revision 665) +++ cpp/src/platform/windows/TimeStampImpl.cpp (working copy) @@ -25,6 +25,7 @@ // along with OpenZWave. If not, see . diff --git a/README b/README index 2101b51..a357ec6 100644 --- a/README +++ b/README @@ -16,9 +16,9 @@ java -cp zwave4j-X-ozw-revY.jar org.zwave4j.Main "C:/open-zwave/config" "//./COM Build requirements: 1. JDK 1.7+ (http://www.oracle.com/technetwork/java/javase/downloads/index.html) -2. Gradle 1.5+ (http://www.gradle.org/downloads) +2. Gradle 1.6 (http://www.gradle.org/downloads) 3. GCC (MinGW for Windows*) -4. OpenZWave with sources (latest tested revision: 664) (https://code.google.com/p/open-zwave) +4. OpenZWave with sources (latest tested revision: 665) (https://code.google.com/p/open-zwave) * For Windows this build of MinGW was used: http://sourceforge.net/projects/mingwbuilds. diff --git a/src/main/cpp/org_zwave4j_Manager.cpp b/src/main/cpp/org_zwave4j_Manager.cpp index 11fe731..e6ab003 100644 --- a/src/main/cpp/org_zwave4j_Manager.cpp +++ b/src/main/cpp/org_zwave4j_Manager.cpp @@ -24,10 +24,10 @@ #include "../headers/init.h" #include "../headers/org_zwave4j_Manager.h" -jobject getNotificationType(JNIEnv * env, OpenZWave::Notification::NotificationType type) +jobject getNotificationType(JNIEnv * env, OpenZWave::Notification::NotificationType ozwNotificationType) { const char * name; - switch(type) + switch(ozwNotificationType) { case OpenZWave::Notification::Type_ValueAdded: name = "VALUE_ADDED"; @@ -116,10 +116,10 @@ jobject getNotificationType(JNIEnv * env, OpenZWave::Notification::NotificationT return env->GetStaticObjectField(clazz, env->GetStaticFieldID(clazz, name, "Lorg/zwave4j/NotificationType;")); } -jobject getValueType(JNIEnv * env, OpenZWave::ValueID::ValueType type) +jobject getValueType(JNIEnv * env, OpenZWave::ValueID::ValueType ozwValueType) { const char * name; - switch(type) + switch(ozwValueType) { case OpenZWave::ValueID::ValueType_Bool: name = "BOOL"; @@ -156,10 +156,10 @@ jobject getValueType(JNIEnv * env, OpenZWave::ValueID::ValueType type) return env->GetStaticObjectField(clazz, env->GetStaticFieldID(clazz, name, "Lorg/zwave4j/ValueType;")); } -jobject getValueGenre(JNIEnv * env, OpenZWave::ValueID::ValueGenre type) +jobject getValueGenre(JNIEnv * env, OpenZWave::ValueID::ValueGenre ozwValueGenre) { const char * name; - switch(type) + switch(ozwValueGenre) { case OpenZWave::ValueID::ValueGenre_Basic: name = "BASIC"; @@ -181,6 +181,118 @@ jobject getValueGenre(JNIEnv * env, OpenZWave::ValueID::ValueGenre type) return env->GetStaticObjectField(clazz, env->GetStaticFieldID(clazz, name, "Lorg/zwave4j/ValueGenre;")); } +jobject getControllerInterface(JNIEnv * env, OpenZWave::Driver::ControllerInterface ozwControllerInterface) +{ + const char * name; + switch(ozwControllerInterface) + { + case OpenZWave::Driver::ControllerInterface_Unknown: + name = "UNKNOWN"; + break; + case OpenZWave::Driver::ControllerInterface_Serial: + name = "SERIAL"; + break; + case OpenZWave::Driver::ControllerInterface_Hid: + name = "HID"; + break; + } + jclass clazz = findClass(env, "org/zwave4j/ControllerInterface"); + return env->GetStaticObjectField(clazz, env->GetStaticFieldID(clazz, name, "Lorg/zwave4j/ControllerInterface;")); +} + +jobject getControllerState(JNIEnv * env, OpenZWave::Driver::ControllerState ozwControllerState) +{ + const char * name; + switch(ozwControllerState) + { + case OpenZWave::Driver::ControllerState_Normal: + name = "NORMAL"; + break; + case OpenZWave::Driver::ControllerState_Starting: + name = "STARTING"; + break; + case OpenZWave::Driver::ControllerState_Cancel: + name = "CANCEL"; + break; + case OpenZWave::Driver::ControllerState_Error: + name = "ERROR"; + break; + case OpenZWave::Driver::ControllerState_Waiting: + name = "WAITING"; + break; + case OpenZWave::Driver::ControllerState_Sleeping: + name = "SLEEPING"; + break; + case OpenZWave::Driver::ControllerState_InProgress: + name = "IN_PROGRESS"; + break; + case OpenZWave::Driver::ControllerState_Completed: + name = "COMPLETED"; + break; + case OpenZWave::Driver::ControllerState_Failed: + name = "FAILED"; + break; + case OpenZWave::Driver::ControllerState_NodeOK: + name = "NODE_OK"; + break; + case OpenZWave::Driver::ControllerState_NodeFailed: + name = "NODE_FAILED"; + break; + + } + jclass clazz = findClass(env, "org/zwave4j/ControllerState"); + return env->GetStaticObjectField(clazz, env->GetStaticFieldID(clazz, name, "Lorg/zwave4j/ControllerState;")); +} + +jobject getControllerError(JNIEnv * env, OpenZWave::Driver::ControllerError ozwControllerError) +{ + const char * name; + switch(ozwControllerError) + { + case OpenZWave::Driver::ControllerError_None: + name = "NONE"; + break; + case OpenZWave::Driver::ControllerError_ButtonNotFound: + name = "BUTTON_NOT_FOUND"; + break; + case OpenZWave::Driver::ControllerError_NodeNotFound: + name = "NODE_NOT_FOUND"; + break; + case OpenZWave::Driver::ControllerError_NotBridge: + name = "NOT_BRIDGE"; + break; + case OpenZWave::Driver::ControllerError_NotSUC: + name = "NOT_SUC"; + break; + case OpenZWave::Driver::ControllerError_NotSecondary: + name = "NOT_SECONDARY"; + break; + case OpenZWave::Driver::ControllerError_NotPrimary: + name = "NOT_PRIMARY"; + break; + case OpenZWave::Driver::ControllerError_IsPrimary: + name = "IS_PRIMARY"; + break; + case OpenZWave::Driver::ControllerError_NotFound: + name = "NOT_FOUND"; + break; + case OpenZWave::Driver::ControllerError_Busy: + name = "BUSY"; + break; + case OpenZWave::Driver::ControllerError_Failed: + name = "FAILED"; + break; + case OpenZWave::Driver::ControllerError_Disabled: + name = "DISABLED"; + break; + case OpenZWave::Driver::ControllerError_Overflow: + name = "OVERFLOW"; + break; + } + jclass clazz = findClass(env, "org/zwave4j/ControllerError"); + return env->GetStaticObjectField(clazz, env->GetStaticFieldID(clazz, name, "Lorg/zwave4j/ControllerError;")); +} + jobject getValueId(JNIEnv * env, OpenZWave::ValueID const * ozwValueId) { jclass clazz = findClass(env, "org/zwave4j/ValueId"); @@ -197,12 +309,6 @@ jobject getValueId(JNIEnv * env, OpenZWave::ValueID const * ozwValueId) ); } -jobject getManager(JNIEnv * env) -{ - jclass clazz = findClass(env, "org/zwave4j/Manager"); - return env->GetStaticObjectField(clazz, env->GetStaticFieldID(clazz, "instance", "Lorg/zwave4j/Manager;")); -} - jobject getNotification(JNIEnv * env, OpenZWave::Notification const * ozwNotification) { jclass clazz = findClass(env, "org/zwave4j/Notification"); @@ -215,6 +321,17 @@ jobject getNotification(JNIEnv * env, OpenZWave::Notification const * ozwNotific ); } +jobject getCommandClassData(JNIEnv * env, OpenZWave::Node::CommandClassData const * ozwCommandClassData) { + jclass clazz = findClass(env, "org/zwave4j/CommandClassData"); + return env->NewObject( + clazz, + env->GetMethodID(clazz, "", "(SJJ)V"), + getJshort(ozwCommandClassData->m_commandClassId), + getJlong(ozwCommandClassData->m_sentCnt), + getJlong(ozwCommandClassData->m_receivedCnt) + ); +} + OpenZWave::ValueID::ValueType getOzwValueType(JNIEnv * env, jobject valueType) { jstring name = (jstring) env->CallObjectMethod( @@ -269,6 +386,52 @@ OpenZWave::ValueID::ValueGenre getOzwValueGenre(JNIEnv * env, jobject valueGenre return ozwValueGenre; } +OpenZWave::Driver::ControllerCommand getOzwControllerCommand(JNIEnv * env, jobject controllerCommand) +{ + jstring name = (jstring) env->CallObjectMethod( + controllerCommand, env->GetMethodID(findClass(env, "org/zwave4j/ControllerCommand"), "name", "()Ljava/lang/String;") + ); + const char * nameChars = env->GetStringUTFChars(name, NULL); + OpenZWave::Driver::ControllerCommand ozwControllerCommand; + if (strcmp(nameChars, "NONE") == 0) + ozwControllerCommand = OpenZWave::Driver::ControllerCommand_None; + else if (strcmp(nameChars, "ADD_DEVICE") == 0) + ozwControllerCommand = OpenZWave::Driver::ControllerCommand_AddDevice; + else if (strcmp(nameChars, "CREATE_NEW_PRIMARY") == 0) + ozwControllerCommand = OpenZWave::Driver::ControllerCommand_CreateNewPrimary; + else if (strcmp(nameChars, "RECEIVE_CONFIGURATION") == 0) + ozwControllerCommand = OpenZWave::Driver::ControllerCommand_ReceiveConfiguration; + else if (strcmp(nameChars, "REMOVE_DEVICE") == 0) + ozwControllerCommand = OpenZWave::Driver::ControllerCommand_RemoveDevice; + else if (strcmp(nameChars, "REMOVE_FAILED_NODE") == 0) + ozwControllerCommand = OpenZWave::Driver::ControllerCommand_RemoveFailedNode; + else if (strcmp(nameChars, "HAS_NODE_FAILED") == 0) + ozwControllerCommand = OpenZWave::Driver::ControllerCommand_HasNodeFailed; + else if (strcmp(nameChars, "REPLACE_FAILED_NODE") == 0) + ozwControllerCommand = OpenZWave::Driver::ControllerCommand_ReplaceFailedNode; + else if (strcmp(nameChars, "TRANSFER_PRIMARY_ROLE") == 0) + ozwControllerCommand = OpenZWave::Driver::ControllerCommand_TransferPrimaryRole; + else if (strcmp(nameChars, "REQUEST_NETWORK_UPDATE") == 0) + ozwControllerCommand = OpenZWave::Driver::ControllerCommand_RequestNetworkUpdate; + else if (strcmp(nameChars, "REQUEST_NODE_NEIGHBOR_UPDATE") == 0) + ozwControllerCommand = OpenZWave::Driver::ControllerCommand_RequestNodeNeighborUpdate; + else if (strcmp(nameChars, "ASSIGN_RETURN_ROUTE") == 0) + ozwControllerCommand = OpenZWave::Driver::ControllerCommand_AssignReturnRoute; + else if (strcmp(nameChars, "DELETE_ALL_RETURN_ROUTES") == 0) + ozwControllerCommand = OpenZWave::Driver::ControllerCommand_DeleteAllReturnRoutes; + else if (strcmp(nameChars, "SEND_NODE_INFORMATION") == 0) + ozwControllerCommand = OpenZWave::Driver::ControllerCommand_SendNodeInformation; + else if (strcmp(nameChars, "REPLICATION_SEND") == 0) + ozwControllerCommand = OpenZWave::Driver::ControllerCommand_ReplicationSend; + else if (strcmp(nameChars, "CREATE_BUTTON") == 0) + ozwControllerCommand = OpenZWave::Driver::ControllerCommand_CreateButton; + else if (strcmp(nameChars, "DELETE_BUTTON") == 0) + ozwControllerCommand = OpenZWave::Driver::ControllerCommand_DeleteButton; + + env->ReleaseStringUTFChars(name, nameChars); + return ozwControllerCommand; +} + OpenZWave::ValueID getOzwValueId(JNIEnv * env, jobject valueId) { jclass clazz = findClass(env, "org/zwave4j/ValueId"); @@ -287,6 +450,27 @@ OpenZWave::ValueID getOzwValueId(JNIEnv * env, jobject valueId) ); } +OpenZWave::Node::CommandClassData getOzwCommandClassData(JNIEnv * env, jobject commandClassData) +{ + jclass clazz = findClass(env, "org/zwave4j/CommandClassData"); + OpenZWave::Node::CommandClassData ozwCommandClassData = OpenZWave::Node::CommandClassData(); + ozwCommandClassData.m_commandClassId = env->CallShortMethod(commandClassData, env->GetMethodID(clazz, "getCommandClassId", "()S")); + ozwCommandClassData.m_sentCnt = env->CallLongMethod(commandClassData, env->GetMethodID(clazz, "getSentCnt", "()J")); + ozwCommandClassData.m_receivedCnt = env->CallLongMethod(commandClassData, env->GetMethodID(clazz, "getReceivedCnt", "()J")); +} + +struct sameObjectPairComparator +{ + bool operator()(const std::pair& o1, const std::pair& o2) const + { + JNIEnv * env; + jvm->GetEnv((void **) &env, JNI_VERSION_1_6); + return (env->IsSameObject(o1.first, o2.first) && env->IsSameObject(o1.second, o2.second)) < true; + } +}; + +std::map, std::pair *, sameObjectPairComparator> notificationWatchers; + void onNotification(OpenZWave::Notification const * ozwNotification, void * context) { JNIEnv * env; @@ -296,12 +480,53 @@ void onNotification(OpenZWave::Notification const * ozwNotification, void * cont jvm->AttachCurrentThread((void **) &env, NULL); } + std::pair * pair = (std::pair *) context; + env->CallVoidMethod( - getManager(env), - env->GetMethodID(findClass(env, "org/zwave4j/Manager"), "fireNotificationWatchers", "(Lorg/zwave4j/Notification;)V"), - getNotification(env, ozwNotification) + pair->first, + env->GetMethodID(findClass(env, "org/zwave4j/NotificationWatcher"), "onNotification", "(Lorg/zwave4j/Notification;Ljava/lang/Object;)V"), + getNotification(env, ozwNotification), + pair->second + ); + + jvm->DetachCurrentThread(); +} + +void onControllerCallback(OpenZWave::Driver::ControllerState ozwState, OpenZWave::Driver::ControllerError ozwErr, void* context) +{ + JNIEnv * env; + int getEnvResult = jvm->GetEnv((void **) &env, JNI_VERSION_1_6); + if (getEnvResult == JNI_EDETACHED) + { + jvm->AttachCurrentThread((void **) &env, NULL); + } + + std::pair * pair = (std::pair *) context; + + env->CallVoidMethod( + pair->first, + env->GetMethodID(findClass(env, "org/zwave4j/ControllerCallback"), "onCallback", "(Lorg/zwave4j/ControllerState;Lorg/zwave4j/ControllerError;Ljava/lang/Object;)V"), + getControllerState(env, ozwState), + getControllerError(env, ozwErr), + pair->second ); + if ( + ozwState == OpenZWave::Driver::ControllerState_Normal || + ozwState == OpenZWave::Driver::ControllerState_Cancel || + ozwState == OpenZWave::Driver::ControllerState_Error || + ozwState == OpenZWave::Driver::ControllerState_Completed || + ozwState == OpenZWave::Driver::ControllerState_Failed || + ozwState == OpenZWave::Driver::ControllerState_NodeOK || + ozwState == OpenZWave::Driver::ControllerState_NodeFailed + ) { + env->DeleteGlobalRef(pair->first); + if (pair->second != NULL) { + env->DeleteGlobalRef(pair->second); + } + delete pair; + } + jvm->DetachCurrentThread(); } @@ -311,10 +536,9 @@ void onNotification(OpenZWave::Notification const * ozwNotification, void * cont * Signature: ()V; */ JNIEXPORT void JNICALL Java_org_zwave4j_Manager_createNativeManager - (JNIEnv *, jclass) + (JNIEnv * env, jclass clazz) { OpenZWave::Manager::Create(); - OpenZWave::Manager::Get()->AddWatcher(onNotification, NULL); } /* @@ -323,9 +547,8 @@ JNIEXPORT void JNICALL Java_org_zwave4j_Manager_createNativeManager * Signature: ()V */ JNIEXPORT void JNICALL Java_org_zwave4j_Manager_destroyNativeManager - (JNIEnv *, jclass) + (JNIEnv * env, jclass clazz) { - OpenZWave::Manager::Get()->RemoveWatcher(onNotification, NULL); OpenZWave::Manager::Destroy(); } @@ -368,6 +591,127 @@ JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_removeDriver return result; } +/* + * Class: org_zwave4j_Manager + * Method: getControllerNodeId + * Signature: (J)S + */ +JNIEXPORT jshort JNICALL Java_org_zwave4j_Manager_getControllerNodeId + (JNIEnv * env, jobject object, jlong homeId) +{ + return getJshort(OpenZWave::Manager::Get()->GetControllerNodeId(getUint32(homeId))); +} + +/* + * Class: org_zwave4j_Manager + * Method: getSUCNodeId + * Signature: (J)S + */ +JNIEXPORT jshort JNICALL Java_org_zwave4j_Manager_getSUCNodeId + (JNIEnv * env, jobject object, jlong homeId) +{ + return getJshort(OpenZWave::Manager::Get()->GetSUCNodeId(getUint32(homeId))); +} + +/* + * Class: org_zwave4j_Manager + * Method: isPrimaryController + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_isPrimaryController + (JNIEnv * env, jobject object, jlong homeId) +{ + return getJboolean(OpenZWave::Manager::Get()->IsPrimaryController(getUint32(homeId))); +} + +/* + * Class: org_zwave4j_Manager + * Method: isStaticUpdateController + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_isStaticUpdateController + (JNIEnv * env, jobject object, jlong homeId) +{ + return getJboolean(OpenZWave::Manager::Get()->IsStaticUpdateController(getUint32(homeId))); +} + +/* + * Class: org_zwave4j_Manager + * Method: isBridgeController + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_isBridgeController + (JNIEnv * env, jobject object, jlong homeId) +{ + return getJboolean(OpenZWave::Manager::Get()->IsBridgeController(getUint32(homeId))); +} + +/* + * Class: org_zwave4j_Manager + * Method: getLibraryVersion + * Signature: (J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_zwave4j_Manager_getLibraryVersion + (JNIEnv * env, jobject object, jlong homeId) +{ + return env->NewStringUTF(OpenZWave::Manager::Get()->GetLibraryVersion(getUint32(homeId)).c_str()); +} + +/* + * Class: org_zwave4j_Manager + * Method: getLibraryTypeName + * Signature: (J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_zwave4j_Manager_getLibraryTypeName + (JNIEnv * env, jobject object, jlong homeId) +{ + return env->NewStringUTF(OpenZWave::Manager::Get()->GetLibraryTypeName(getUint32(homeId)).c_str()); +} + +/* + * Class: org_zwave4j_Manager + * Method: getSendQueueCount + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_zwave4j_Manager_getSendQueueCount + (JNIEnv * env, jobject object, jlong homeId) +{ + return getJint(OpenZWave::Manager::Get()->GetSendQueueCount(getUint32(homeId))); +} + +/* + * Class: org_zwave4j_Manager + * Method: logDriverStatistics + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_zwave4j_Manager_logDriverStatistics + (JNIEnv * env, jobject object, jlong homeId) +{ + OpenZWave::Manager::Get()->LogDriverStatistics(getUint32(homeId)); +} + +/* + * Class: org_zwave4j_Manager + * Method: getControllerInterfaceType + * Signature: (J)Lorg/zwave4j/ControllerInterface; + */ +JNIEXPORT jobject JNICALL Java_org_zwave4j_Manager_getControllerInterfaceType + (JNIEnv * env, jobject object, jlong homeId) +{ + return getControllerInterface(env, OpenZWave::Manager::Get()->GetControllerInterfaceType(getUint32(homeId))); +} + +/* + * Class: org_zwave4j_Manager + * Method: getControllerPath + * Signature: (J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_zwave4j_Manager_getControllerPath + (JNIEnv * env, jobject object, jlong homeId) +{ + return env->NewStringUTF(OpenZWave::Manager::Get()->GetControllerPath(getUint32(homeId)).c_str()); +} + /* * Class: org_zwave4j_Manager * Method: getPollInterval @@ -395,7 +739,7 @@ JNIEXPORT void JNICALL Java_org_zwave4j_Manager_setPollInterval * Method: enablePoll * Signature: (Lorg/zwave4j/ValueId;S)Z */ -JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_enablePoll +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_enablePoll__Lorg_zwave4j_ValueId_2S (JNIEnv * env, jobject object, jobject valueId, jshort intensity) { return getJboolean(OpenZWave::Manager::Get()->EnablePoll(getOzwValueId(env, valueId), getUint8(intensity))); @@ -817,7 +1161,7 @@ JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_isNodeInfoReceived * Method: getNodeClassInformation * Signature: (JSSLjava/lang/String;Ljava/lang/Short;)Z */ -JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_getNodeClassInformation +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_getNodeClassInformation__JSSLjava_lang_String_2Ljava_lang_Short_2 (JNIEnv * env, jobject object, jlong homeId, jshort nodeId, jshort commandClassId, jstring className, jobject classVersion) { const char * classNameChars; @@ -1455,6 +1799,95 @@ JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_releaseButton return getJboolean(OpenZWave::Manager::Get()->ReleaseButton(getOzwValueId(env, valueId))); } +/* + * Class: org_zwave4j_Manager + * Method: getNumSwitchPoints + * Signature: (Lorg/zwave4j/ValueId;)S + */ +JNIEXPORT jshort JNICALL Java_org_zwave4j_Manager_getNumSwitchPoints + (JNIEnv * env, jobject object, jobject id) +{ + return getJshort(OpenZWave::Manager::Get()->GetNumSwitchPoints(getOzwValueId(env, id))); +} + +/* + * Class: org_zwave4j_Manager + * Method: setSwitchPoint + * Signature: (Lorg/zwave4j/ValueId;SSB)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_setSwitchPoint + (JNIEnv * env, jobject object, jobject id, jshort hours, jshort minutes, jbyte setback) +{ + return getJboolean(OpenZWave::Manager::Get()->SetSwitchPoint(getOzwValueId(env, id), getUint8(hours), getUint8(minutes), getInt8(setback))); +} + +/* + * Class: org_zwave4j_Manager + * Method: removeSwitchPoint + * Signature: (Lorg/zwave4j/ValueId;SS)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_removeSwitchPoint + (JNIEnv * env, jobject object, jobject id, jshort hours, jshort minutes) +{ + return getJboolean(OpenZWave::Manager::Get()->RemoveSwitchPoint(getOzwValueId(env, id), getUint8(hours), getUint8(minutes))); +} + +/* + * Class: org_zwave4j_Manager + * Method: clearSwitchPoints + * Signature: (Lorg/zwave4j/ValueId;)V + */ +JNIEXPORT void JNICALL Java_org_zwave4j_Manager_clearSwitchPoints + (JNIEnv * env, jobject object, jobject id) +{ + OpenZWave::Manager::Get()->ClearSwitchPoints(getOzwValueId(env, id)); +} + +/* + * Class: org_zwave4j_Manager + * Method: getSwitchPoint + * Signature: (Lorg/zwave4j/ValueId;SLjava/util/concurrent/atomic/AtomicReference;Ljava/util/concurrent/atomic/AtomicReference;Ljava/util/concurrent/atomic/AtomicReference;)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_getSwitchPoint + (JNIEnv * env, jobject object, jobject id, jshort idx, jobject hours, jobject minutes, jobject setback) +{ + uint8 ozwHours, ozwMinutes; + int8 ozwSetback; + jboolean result = getJboolean(OpenZWave::Manager::Get()->GetSwitchPoint(getOzwValueId(env, id), getUint8(idx), &ozwHours, &ozwMinutes, &ozwSetback)); + + env->CallVoidMethod( + hours, + env->GetMethodID(findClass(env, "java/util/concurrent/atomic/AtomicReference"), "set", "(Ljava/lang/Object;)V"), + env->NewObject( + findClass(env, "java/lang/Short"), + env->GetMethodID(findClass(env, "java/lang/Short"), "", "(S)V"), + getJshort(ozwHours) + ) + ); + + env->CallVoidMethod( + minutes, + env->GetMethodID(findClass(env, "java/util/concurrent/atomic/AtomicReference"), "set", "(Ljava/lang/Object;)V"), + env->NewObject( + findClass(env, "java/lang/Short"), + env->GetMethodID(findClass(env, "java/lang/Short"), "", "(S)V"), + getJshort(ozwMinutes) + ) + ); + + env->CallVoidMethod( + setback, + env->GetMethodID(findClass(env, "java/util/concurrent/atomic/AtomicReference"), "set", "(Ljava/lang/Object;)V"), + env->NewObject( + findClass(env, "java/lang/Byte"), + env->GetMethodID(findClass(env, "java/lang/Byte"), "", "(B)V"), + getJbyte(ozwSetback) + ) + ); + + return result; +} + /* * Class: org_zwave4j_Manager * Method: switchAllOn @@ -1482,7 +1915,7 @@ JNIEXPORT void JNICALL Java_org_zwave4j_Manager_switchAllOff * Method: setConfigParam * Signature: (JSSIS)Z */ -JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_setConfigParam +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_setConfigParam__JSSIS (JNIEnv * env, jobject object, jlong homeId, jshort nodeId, jshort param, jint value, jshort size) { return getJboolean(OpenZWave::Manager::Get()->SetConfigParam(getUint32(homeId), getUint8(nodeId), getUint8(param), getInt32(value), getUint8(size))); @@ -1520,3 +1953,955 @@ JNIEXPORT void JNICALL Java_org_zwave4j_Manager_requestAllConfigParams { OpenZWave::Manager::Get()->RequestAllConfigParams(getUint32(homeId), getUint8(nodeId)); } + +/* + * Class: org_zwave4j_Manager + * Method: getNumGroups + * Signature: (JS)S + */ +JNIEXPORT jshort JNICALL Java_org_zwave4j_Manager_getNumGroups + (JNIEnv * env, jobject object, jlong homeId, jshort nodeId) +{ + return getJshort(OpenZWave::Manager::Get()->GetNumGroups(getUint32(homeId), getUint8(nodeId))); +} + +/* + * Class: org_zwave4j_Manager + * Method: getAssociations + * Signature: (JSSLjava/util/concurrent/atomic/AtomicReference;)J + */ +JNIEXPORT jlong JNICALL Java_org_zwave4j_Manager_getAssociations + (JNIEnv * env, jobject object, jlong homeId, jshort nodeId, jshort groupIdx, jobject associations) +{ + uint8 * ozwAssociations; + + jlong associationsAmount = getJlong(OpenZWave::Manager::Get()->GetAssociations(getUint32(homeId), getUint8(nodeId), getUint8(groupIdx), &ozwAssociations)); + + jshortArray associationsArray = env->NewShortArray(getJsize(associationsAmount)); + jshort * neighborsArrayElements = env->GetShortArrayElements(associationsArray, NULL); + for (uint32 i = 0; i < associationsAmount; ++i) + { + neighborsArrayElements[i] = getJshort(ozwAssociations[i]); + } + env->ReleaseShortArrayElements(associationsArray, neighborsArrayElements, 0); + + delete ozwAssociations; + + env->CallVoidMethod( + associations, + env->GetMethodID(findClass(env, "java/util/concurrent/atomic/AtomicReference"), "set", "(Ljava/lang/Object;)V"), + associationsArray + ); + + return associationsAmount; +} + +/* + * Class: org_zwave4j_Manager + * Method: getMaxAssociations + * Signature: (JSS)S + */ +JNIEXPORT jshort JNICALL Java_org_zwave4j_Manager_getMaxAssociations + (JNIEnv * env, jobject object, jlong homeId, jshort nodeId, jshort groupIdx) +{ + return getJshort(OpenZWave::Manager::Get()->GetMaxAssociations(getUint32(homeId), getUint8(nodeId), getUint8(groupIdx))); +} + +/* + * Class: org_zwave4j_Manager + * Method: getGroupLabel + * Signature: (JSS)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_zwave4j_Manager_getGroupLabel + (JNIEnv * env, jobject object, jlong homeId, jshort nodeId, jshort groupIdx) +{ + return env->NewStringUTF(OpenZWave::Manager::Get()->GetGroupLabel(getUint32(homeId), getUint8(nodeId), getUint8(groupIdx)).c_str()); +} + +/* + * Class: org_zwave4j_Manager + * Method: addAssociation + * Signature: (JSSS)V + */ +JNIEXPORT void JNICALL Java_org_zwave4j_Manager_addAssociation + (JNIEnv * env, jobject object, jlong homeId, jshort nodeId, jshort groupIdx, jshort targetNodeId) +{ + OpenZWave::Manager::Get()->AddAssociation(getUint32(homeId), getUint8(nodeId), getUint8(groupIdx), getUint8(targetNodeId)); +} + +/* + * Class: org_zwave4j_Manager + * Method: removeAssociation + * Signature: (JSSS)V + */ +JNIEXPORT void JNICALL Java_org_zwave4j_Manager_removeAssociation + (JNIEnv * env, jobject object, jlong homeId, jshort nodeId, jshort groupIdx, jshort targetNodeId) +{ + OpenZWave::Manager::Get()->RemoveAssociation(getUint32(homeId), getUint8(nodeId), getUint8(groupIdx), getUint8(targetNodeId)); +} + +/* + * Class: org_zwave4j_Manager + * Method: addWatcher + * Signature: (Lorg/zwave4j/NotificationWatcher;Ljava/lang/Object;)V + */ +JNIEXPORT void JNICALL Java_org_zwave4j_Manager_addWatcher + (JNIEnv * env, jobject object, jobject notificationWatcher, jobject context) +{ + std::pair * pair = new std::pair( + env->NewGlobalRef(notificationWatcher), + env->NewGlobalRef(context) + ); + notificationWatchers[std::pair(notificationWatcher, context)] = pair; + OpenZWave::Manager::Get()->AddWatcher(onNotification, pair); +} + +/* + * Class: org_zwave4j_Manager + * Method: removeWatcher + * Signature: (Lorg/zwave4j/NotificationWatcher;Ljava/lang/Object;)V + */ +JNIEXPORT void JNICALL Java_org_zwave4j_Manager_removeWatcher + (JNIEnv * env, jobject object, jobject notificationWatcher, jobject context) +{ + std::pair * pair = notificationWatchers[std::pair(notificationWatcher, context)]; + OpenZWave::Manager::Get()->RemoveWatcher(onNotification, pair); + env->DeleteGlobalRef(pair->first); + env->DeleteGlobalRef(pair->second); + delete pair; +} + +/* + * Class: org_zwave4j_Manager + * Method: resetController + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_zwave4j_Manager_resetController + (JNIEnv * env, jobject object, jlong homeId) +{ + OpenZWave::Manager::Get()->ResetController(getUint32(homeId)); +} + +/* + * Class: org_zwave4j_Manager + * Method: softReset + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_zwave4j_Manager_softReset + (JNIEnv * env, jobject object, jlong homeId) +{ + OpenZWave::Manager::Get()->SoftReset(getUint32(homeId)); +} + +/* + * Class: org_zwave4j_Manager + * Method: beginControllerCommand + * Signature: (JLorg/zwave4j/ControllerCommand;)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_beginControllerCommand__JLorg_zwave4j_ControllerCommand_2 + (JNIEnv * env, jobject object, jlong homeId, jobject command) +{ + return getJboolean(OpenZWave::Manager::Get()->BeginControllerCommand(getUint32(homeId), getOzwControllerCommand(env, command))); +} + +/* + * Class: org_zwave4j_Manager + * Method: beginControllerCommand + * Signature: (JLorg/zwave4j/ControllerCommand;Lorg/zwave4j/ControllerCallback;)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_beginControllerCommand__JLorg_zwave4j_ControllerCommand_2Lorg_zwave4j_ControllerCallback_2 + (JNIEnv * env, jobject object, jlong homeId, jobject command, jobject callback) +{ + std::pair * pair = new std::pair( + env->NewGlobalRef(callback), + NULL + ); + return getJboolean(OpenZWave::Manager::Get()->BeginControllerCommand(getUint32(homeId), getOzwControllerCommand(env, command), onControllerCallback, pair)); +} + +/* + * Class: org_zwave4j_Manager + * Method: beginControllerCommand + * Signature: (JLorg/zwave4j/ControllerCommand;Lorg/zwave4j/ControllerCallback;Ljava/lang/Object;)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_beginControllerCommand__JLorg_zwave4j_ControllerCommand_2Lorg_zwave4j_ControllerCallback_2Ljava_lang_Object_2 + (JNIEnv * env, jobject object, jlong homeId, jobject command, jobject callback, jobject context) +{ + std::pair * pair = new std::pair( + env->NewGlobalRef(callback), + env->NewGlobalRef(context) + ); + return getJboolean(OpenZWave::Manager::Get()->BeginControllerCommand(getUint32(homeId), getOzwControllerCommand(env, command), onControllerCallback, pair)); +} + +/* + * Class: org_zwave4j_Manager + * Method: beginControllerCommand + * Signature: (JLorg/zwave4j/ControllerCommand;Lorg/zwave4j/ControllerCallback;Ljava/lang/Object;Z)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_beginControllerCommand__JLorg_zwave4j_ControllerCommand_2Lorg_zwave4j_ControllerCallback_2Ljava_lang_Object_2Z + (JNIEnv * env, jobject object, jlong homeId, jobject command, jobject callback, jobject context, jboolean highPower) +{ + std::pair * pair = new std::pair( + env->NewGlobalRef(callback), + env->NewGlobalRef(context) + ); + return getJboolean(OpenZWave::Manager::Get()->BeginControllerCommand(getUint32(homeId), getOzwControllerCommand(env, command), onControllerCallback, pair, getBool(highPower))); +} + +/* + * Class: org_zwave4j_Manager + * Method: beginControllerCommand + * Signature: (JLorg/zwave4j/ControllerCommand;Lorg/zwave4j/ControllerCallback;Ljava/lang/Object;ZS)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_beginControllerCommand__JLorg_zwave4j_ControllerCommand_2Lorg_zwave4j_ControllerCallback_2Ljava_lang_Object_2ZS + (JNIEnv * env, jobject object, jlong homeId, jobject command, jobject callback, jobject context, jboolean highPower, jshort nodeId) +{ + std::pair * pair = new std::pair( + env->NewGlobalRef(callback), + env->NewGlobalRef(context) + ); + return getJboolean(OpenZWave::Manager::Get()->BeginControllerCommand(getUint32(homeId), getOzwControllerCommand(env, command), onControllerCallback, pair, getBool(highPower), getUint8(nodeId))); +} + +/* + * Class: org_zwave4j_Manager + * Method: beginControllerCommand + * Signature: (JLorg/zwave4j/ControllerCommand;Lorg/zwave4j/ControllerCallback;Ljava/lang/Object;ZSS)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_beginControllerCommand__JLorg_zwave4j_ControllerCommand_2Lorg_zwave4j_ControllerCallback_2Ljava_lang_Object_2ZSS + (JNIEnv * env, jobject object, jlong homeId, jobject command, jobject callback, jobject context, jboolean highPower, jshort nodeId, jshort arg) +{ + std::pair * pair = new std::pair( + env->NewGlobalRef(callback), + env->NewGlobalRef(context) + ); + return getJboolean(OpenZWave::Manager::Get()->BeginControllerCommand(getUint32(homeId), getOzwControllerCommand(env, command), onControllerCallback, pair, getBool(highPower), getUint8(nodeId), getUint8(arg))); +} + +/* + * Class: org_zwave4j_Manager + * Method: cancelControllerCommand + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_cancelControllerCommand + (JNIEnv * env, jobject object, jlong homeId) +{ + return getJboolean(OpenZWave::Manager::Get()->CancelControllerCommand(getUint32(homeId))); +} + +/* + * Class: org_zwave4j_Manager + * Method: testNetworkNode + * Signature: (JSJ)V + */ +JNIEXPORT void JNICALL Java_org_zwave4j_Manager_testNetworkNode + (JNIEnv * env, jobject object, jlong homeId, jshort nodeId, jlong count) +{ + OpenZWave::Manager::Get()->TestNetworkNode(getUint32(homeId), getUint8(nodeId), getUint32(count)); +} + +/* + * Class: org_zwave4j_Manager + * Method: testNetwork + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_zwave4j_Manager_testNetwork + (JNIEnv * env, jobject object, jlong homeId, jlong count) +{ + OpenZWave::Manager::Get()->TestNetwork(getUint32(homeId), getUint32(count)); +} + +/* + * Class: org_zwave4j_Manager + * Method: healNetworkNode + * Signature: (JSZ)V + */ +JNIEXPORT void JNICALL Java_org_zwave4j_Manager_healNetworkNode + (JNIEnv * env, jobject object, jlong homeId, jshort nodeId, jboolean doRR) +{ + OpenZWave::Manager::Get()->HealNetworkNode(getUint32(homeId), getUint8(nodeId), getBool(doRR)); +} + +/* + * Class: org_zwave4j_Manager + * Method: healNetwork + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_zwave4j_Manager_healNetwork + (JNIEnv * env, jobject object, jlong homeId, jboolean doRR) +{ + OpenZWave::Manager::Get()->HealNetwork(getUint32(homeId), getBool(doRR)); +} + +/* + * Class: org_zwave4j_Manager + * Method: getNumScenes + * Signature: ()S + */ +JNIEXPORT jshort JNICALL Java_org_zwave4j_Manager_getNumScenes + (JNIEnv * env, jobject object) +{ + return getJshort(OpenZWave::Manager::Get()->GetNumScenes()); +} + +/* + * Class: org_zwave4j_Manager + * Method: getAllScenes + * Signature: (Ljava/util/concurrent/atomic/AtomicReference;)S + */ +JNIEXPORT jshort JNICALL Java_org_zwave4j_Manager_getAllScenes + (JNIEnv * env, jobject object, jobject sceneIds) +{ + uint8 * ozwScenesIds; + uint8 scenesIdsAmount = OpenZWave::Manager::Get()->GetAllScenes(&ozwScenesIds); + + jshortArray scenesIdsArray = env->NewShortArray(getJsize(scenesIdsAmount)); + jshort * neighborsArrayElements = env->GetShortArrayElements(scenesIdsArray, NULL); + for (uint32 i = 0; i < scenesIdsAmount; ++i) + { + neighborsArrayElements[i] = getJshort(ozwScenesIds[i]); + } + env->ReleaseShortArrayElements(scenesIdsArray, neighborsArrayElements, 0); + + delete ozwScenesIds; + + env->CallVoidMethod( + sceneIds, + env->GetMethodID(findClass(env, "java/util/concurrent/atomic/AtomicReference"), "set", "(Ljava/lang/Object;)V"), + scenesIdsArray + ); + + return scenesIdsAmount; +} + +/* + * Class: org_zwave4j_Manager + * Method: removeAllScenes + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_zwave4j_Manager_removeAllScenes + (JNIEnv * env, jobject object, jlong homeId) +{ + OpenZWave::Manager::Get()->RemoveAllScenes(getUint32(homeId)); +} + +/* + * Class: org_zwave4j_Manager + * Method: createScene + * Signature: ()S + */ +JNIEXPORT jshort JNICALL Java_org_zwave4j_Manager_createScene + (JNIEnv * env, jobject object) +{ + return getJshort(OpenZWave::Manager::Get()->CreateScene()); +} + +/* + * Class: org_zwave4j_Manager + * Method: removeScene + * Signature: (S)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_removeScene + (JNIEnv * env, jobject object, jshort sceneId) +{ + return getJboolean(OpenZWave::Manager::Get()->RemoveScene(getUint8(sceneId))); +} + +/* + * Class: org_zwave4j_Manager + * Method: addSceneValueAsBool + * Signature: (SLorg/zwave4j/ValueId;Z)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_addSceneValueAsBool + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jboolean value) +{ + return getJboolean(OpenZWave::Manager::Get()->AddSceneValue(getUint8(sceneId), getOzwValueId(env, valueId), getBool(value))); +} + +/* + * Class: org_zwave4j_Manager + * Method: addSceneValueAsByte + * Signature: (SLorg/zwave4j/ValueId;S)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_addSceneValueAsByte + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jshort value) +{ + return getJboolean(OpenZWave::Manager::Get()->AddSceneValue(getUint8(sceneId), getOzwValueId(env, valueId), getUint8(value))); +} + +/* + * Class: org_zwave4j_Manager + * Method: addSceneValueAsFloat + * Signature: (SLorg/zwave4j/ValueId;F)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_addSceneValueAsFloat + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jfloat value) +{ + return getJboolean(OpenZWave::Manager::Get()->AddSceneValue(getUint8(sceneId), getOzwValueId(env, valueId), getFloat32(value))); +} + +/* + * Class: org_zwave4j_Manager + * Method: addSceneValueAsInt + * Signature: (SLorg/zwave4j/ValueId;I)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_addSceneValueAsInt + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jint value) +{ + return getJboolean(OpenZWave::Manager::Get()->AddSceneValue(getUint8(sceneId), getOzwValueId(env, valueId), getInt32(value))); +} + +/* + * Class: org_zwave4j_Manager + * Method: addSceneValueAsShort + * Signature: (SLorg/zwave4j/ValueId;S)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_addSceneValueAsShort + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jshort value) +{ + return getJboolean(OpenZWave::Manager::Get()->AddSceneValue(getUint8(sceneId), getOzwValueId(env, valueId), getInt16(value))); +} + +/* + * Class: org_zwave4j_Manager + * Method: addSceneValueAsString + * Signature: (SLorg/zwave4j/ValueId;Ljava/lang/String;)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_addSceneValueAsString + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jstring value) +{ + const char * valueChars = env->GetStringUTFChars(value, NULL); + + jboolean result = getJboolean(OpenZWave::Manager::Get()->AddSceneValue(getUint8(sceneId), getOzwValueId(env, valueId), std::string(valueChars))); + + env->ReleaseStringUTFChars(value, valueChars); + return result; +} + +/* + * Class: org_zwave4j_Manager + * Method: addSceneValueListSelection + * Signature: (SLorg/zwave4j/ValueId;Ljava/lang/String;)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_addSceneValueListSelection__SLorg_zwave4j_ValueId_2Ljava_lang_String_2 + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jstring value) +{ + const char * valueChars = env->GetStringUTFChars(value, NULL); + + jboolean result = getJboolean(OpenZWave::Manager::Get()->AddSceneValueListSelection(getUint8(sceneId), getOzwValueId(env, valueId), std::string(valueChars))); + + env->ReleaseStringUTFChars(value, valueChars); + return result; +} + +/* + * Class: org_zwave4j_Manager + * Method: addSceneValueListSelection + * Signature: (SLorg/zwave4j/ValueId;I)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_addSceneValueListSelection__SLorg_zwave4j_ValueId_2I + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jint value) +{ + return getJboolean(OpenZWave::Manager::Get()->AddSceneValueListSelection(getUint8(sceneId), getOzwValueId(env, valueId), getInt32(value))); +} + +/* + * Class: org_zwave4j_Manager + * Method: removeSceneValue + * Signature: (SLorg/zwave4j/ValueId;)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_removeSceneValue + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId) +{ + return getJboolean(OpenZWave::Manager::Get()->RemoveSceneValue(getUint8(sceneId), getOzwValueId(env, valueId))); +} + +/* + * Class: org_zwave4j_Manager + * Method: sceneGetValues + * Signature: (SLjava/util/List;)I + */ +JNIEXPORT jint JNICALL Java_org_zwave4j_Manager_sceneGetValues + (JNIEnv * env, jobject object, jshort sceneId, jobject value) +{ + std::vector ozwValue; + jboolean result = getJboolean(OpenZWave::Manager::Get()->SceneGetValues(getUint8(sceneId), &ozwValue)); + + jmethodID addMethodId = env->GetMethodID(findClass(env, "java/util/List"), "add", "(Ljava/lang/Object;)Z"); + for(std::vector::iterator it = ozwValue.begin(); it != ozwValue.end(); ++it) + { + env->CallBooleanMethod( + value, + addMethodId, + getValueId(env, &*it) + ); + } + + return result; +} + +/* + * Class: org_zwave4j_Manager + * Method: sceneGetValueAsBool + * Signature: (SLorg/zwave4j/ValueId;Ljava/util/concurrent/atomic/AtomicReference;)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_sceneGetValueAsBool + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jobject value) +{ + bool ozwValue; + jboolean result = getJboolean(OpenZWave::Manager::Get()->SceneGetValueAsBool(getJshort(sceneId), getOzwValueId(env, valueId), &ozwValue)); + env->CallVoidMethod( + value, + env->GetMethodID(findClass(env, "java/util/concurrent/atomic/AtomicReference"), "set", "(Ljava/lang/Object;)V"), + env->NewObject( + findClass(env, "java/lang/Boolean"), + env->GetMethodID(findClass(env, "java/lang/Boolean"), "", "(Z)V"), + getJboolean(ozwValue) + ) + ); + return result; +} + +/* + * Class: org_zwave4j_Manager + * Method: sceneGetValueAsByte + * Signature: (SLorg/zwave4j/ValueId;Ljava/util/concurrent/atomic/AtomicReference;)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_sceneGetValueAsByte + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jobject value) +{ + uint8 ozwValue; + jboolean result = getJboolean(OpenZWave::Manager::Get()->SceneGetValueAsByte(getJshort(sceneId), getOzwValueId(env, valueId), &ozwValue)); + env->CallVoidMethod( + value, + env->GetMethodID(findClass(env, "java/util/concurrent/atomic/AtomicReference"), "set", "(Ljava/lang/Object;)V"), + env->NewObject( + findClass(env, "java/lang/Short"), + env->GetMethodID(findClass(env, "java/lang/Short"), "", "(S)V"), + getJshort(ozwValue) + ) + ); + return result; +} + +/* + * Class: org_zwave4j_Manager + * Method: sceneGetValueAsFloat + * Signature: (SLorg/zwave4j/ValueId;Ljava/util/concurrent/atomic/AtomicReference;)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_sceneGetValueAsFloat + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jobject value) +{ + float ozwValue; + jboolean result = getJboolean(OpenZWave::Manager::Get()->SceneGetValueAsFloat(getJshort(sceneId), getOzwValueId(env, valueId), &ozwValue)); + env->CallVoidMethod( + value, + env->GetMethodID(findClass(env, "java/util/concurrent/atomic/AtomicReference"), "set", "(Ljava/lang/Object;)V"), + env->NewObject( + findClass(env, "java/lang/Float"), + env->GetMethodID(findClass(env, "java/lang/Float"), "", "(F)V"), + getJfloat(ozwValue) + ) + ); + return result; +} + +/* + * Class: org_zwave4j_Manager + * Method: sceneGetValueAsInt + * Signature: (SLorg/zwave4j/ValueId;Ljava/util/concurrent/atomic/AtomicReference;)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_sceneGetValueAsInt + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jobject value) +{ + int32 ozwValue; + jboolean result = getJboolean(OpenZWave::Manager::Get()->SceneGetValueAsInt(getJshort(sceneId), getOzwValueId(env, valueId), &ozwValue)); + env->CallVoidMethod( + value, + env->GetMethodID(findClass(env, "java/util/concurrent/atomic/AtomicReference"), "set", "(Ljava/lang/Object;)V"), + env->NewObject( + findClass(env, "java/lang/Integer"), + env->GetMethodID(findClass(env, "java/lang/Integer"), "", "(I)V"), + getJint(ozwValue) + ) + ); + return result; +} + +/* + * Class: org_zwave4j_Manager + * Method: sceneGetValueAsShort + * Signature: (SLorg/zwave4j/ValueId;Ljava/util/concurrent/atomic/AtomicReference;)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_sceneGetValueAsShort + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jobject value) +{ + int16 ozwValue; + jboolean result = getJboolean(OpenZWave::Manager::Get()->SceneGetValueAsShort(getJshort(sceneId), getOzwValueId(env, valueId), &ozwValue)); + env->CallVoidMethod( + value, + env->GetMethodID(findClass(env, "java/util/concurrent/atomic/AtomicReference"), "set", "(Ljava/lang/Object;)V"), + env->NewObject( + findClass(env, "java/lang/Short"), + env->GetMethodID(findClass(env, "java/lang/Short"), "", "(S)V"), + getJshort(ozwValue) + ) + ); + return result; +} + +/* + * Class: org_zwave4j_Manager + * Method: sceneGetValueAsString + * Signature: (SLorg/zwave4j/ValueId;Ljava/util/concurrent/atomic/AtomicReference;)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_sceneGetValueAsString + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jobject value) +{ + std::string ozwValue; + jboolean result = getJboolean(OpenZWave::Manager::Get()->SceneGetValueAsString(getJshort(sceneId), getOzwValueId(env, valueId), &ozwValue)); + env->CallVoidMethod( + value, + env->GetMethodID(findClass(env, "java/util/concurrent/atomic/AtomicReference"), "set", "(Ljava/lang/Object;)V"), + env->NewStringUTF(ozwValue.c_str()) + ); + return result; +} + +/* + * Class: org_zwave4j_Manager + * Method: sceneGetValueListSelectionString + * Signature: (SLorg/zwave4j/ValueId;Ljava/util/concurrent/atomic/AtomicReference;)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_sceneGetValueListSelectionString + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jobject value) +{ + std::string ozwValue; + jboolean result = getJboolean(OpenZWave::Manager::Get()->SceneGetValueListSelection(getJshort(sceneId), getOzwValueId(env, valueId), &ozwValue)); + env->CallVoidMethod( + value, + env->GetMethodID(findClass(env, "java/util/concurrent/atomic/AtomicReference"), "set", "(Ljava/lang/Object;)V"), + env->NewStringUTF(ozwValue.c_str()) + ); + return result; +} + +/* + * Class: org_zwave4j_Manager + * Method: sceneGetValueListSelectionInt + * Signature: (SLorg/zwave4j/ValueId;Ljava/util/concurrent/atomic/AtomicReference;)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_sceneGetValueListSelectionInt + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jobject value) +{ + int32 ozwValue; + jboolean result = getJboolean(OpenZWave::Manager::Get()->SceneGetValueListSelection(getJshort(sceneId), getOzwValueId(env, valueId), &ozwValue)); + env->CallVoidMethod( + value, + env->GetMethodID(findClass(env, "java/util/concurrent/atomic/AtomicReference"), "set", "(Ljava/lang/Object;)V"), + env->NewObject( + findClass(env, "java/lang/Integer"), + env->GetMethodID(findClass(env, "java/lang/Integer"), "", "(I)V"), + getJint(ozwValue) + ) + ); + return result; +} + +/* + * Class: org_zwave4j_Manager + * Method: setSceneValueAsBool + * Signature: (SLorg/zwave4j/ValueId;Z)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_setSceneValueAsBool + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jboolean value) +{ + return getJboolean(OpenZWave::Manager::Get()->SetSceneValue(getUint8(sceneId), getOzwValueId(env, valueId), getBool(value))); +} + +/* + * Class: org_zwave4j_Manager + * Method: setSceneValueAsByte + * Signature: (SLorg/zwave4j/ValueId;S)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_setSceneValueAsByte + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jshort value) +{ + return getJboolean(OpenZWave::Manager::Get()->SetSceneValue(getUint8(sceneId), getOzwValueId(env, valueId), getUint8(value))); +} + +/* + * Class: org_zwave4j_Manager + * Method: setSceneValueAsFloat + * Signature: (SLorg/zwave4j/ValueId;F)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_setSceneValueAsFloat + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jfloat value) +{ + return getJboolean(OpenZWave::Manager::Get()->SetSceneValue(getUint8(sceneId), getOzwValueId(env, valueId), getFloat32(value))); +} + +/* + * Class: org_zwave4j_Manager + * Method: setSceneValueAsInt + * Signature: (SLorg/zwave4j/ValueId;I)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_setSceneValueAsInt + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jint value) +{ + return getJboolean(OpenZWave::Manager::Get()->SetSceneValue(getUint8(sceneId), getOzwValueId(env, valueId), getInt32(value))); +} + +/* + * Class: org_zwave4j_Manager + * Method: setSceneValueAsShort + * Signature: (SLorg/zwave4j/ValueId;S)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_setSceneValueAsShort + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jshort value) +{ + return getJboolean(OpenZWave::Manager::Get()->SetSceneValue(getUint8(sceneId), getOzwValueId(env, valueId), getInt16(value))); +} + +/* + * Class: org_zwave4j_Manager + * Method: setSceneValueAsString + * Signature: (SLorg/zwave4j/ValueId;Ljava/lang/String;)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_setSceneValueAsString + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jstring value) +{ + const char * valueChars = env->GetStringUTFChars(value, NULL); + + jboolean result = getJboolean(OpenZWave::Manager::Get()->SetSceneValue(getUint8(sceneId), getOzwValueId(env, valueId), std::string(valueChars))); + + env->ReleaseStringUTFChars(value, valueChars); + return result; +} + +/* + * Class: org_zwave4j_Manager + * Method: setSceneValueListSelection + * Signature: (SLorg/zwave4j/ValueId;Ljava/lang/String;)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_setSceneValueListSelection__SLorg_zwave4j_ValueId_2Ljava_lang_String_2 + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jstring value) +{ + const char * valueChars = env->GetStringUTFChars(value, NULL); + + jboolean result = getJboolean(OpenZWave::Manager::Get()->SetSceneValueListSelection(getUint8(sceneId), getOzwValueId(env, valueId), std::string(valueChars))); + + env->ReleaseStringUTFChars(value, valueChars); + return result; +} + +/* + * Class: org_zwave4j_Manager + * Method: setSceneValueListSelection + * Signature: (SLorg/zwave4j/ValueId;I)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_setSceneValueListSelection__SLorg_zwave4j_ValueId_2I + (JNIEnv * env, jobject object, jshort sceneId, jobject valueId, jint value) +{ + return getJboolean(OpenZWave::Manager::Get()->SetSceneValueListSelection(getUint8(sceneId), getOzwValueId(env, valueId), getInt32(value))); +} + +/* + * Class: org_zwave4j_Manager + * Method: getSceneLabel + * Signature: (S)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_zwave4j_Manager_getSceneLabel + (JNIEnv * env, jobject object, jshort sceneId) +{ + return env->NewStringUTF(OpenZWave::Manager::Get()->GetSceneLabel(getUint8(sceneId)).c_str()); +} + +/* + * Class: org_zwave4j_Manager + * Method: setSceneLabel + * Signature: (SLjava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_org_zwave4j_Manager_setSceneLabel + (JNIEnv * env, jobject object, jshort sceneId, jstring value) +{ + const char * valueChars = env->GetStringUTFChars(value, NULL); + + OpenZWave::Manager::Get()->SetSceneLabel(getUint8(sceneId), std::string(valueChars)); + + env->ReleaseStringUTFChars(value, valueChars); +} + +/* + * Class: org_zwave4j_Manager + * Method: sceneExists + * Signature: (S)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_sceneExists + (JNIEnv * env, jobject object, jshort sceneId) +{ + return getJboolean(OpenZWave::Manager::Get()->SceneExists(getUint8(sceneId))); +} + +/* + * Class: org_zwave4j_Manager + * Method: activateScene + * Signature: (S)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Manager_activateScene + (JNIEnv * env, jobject object, jshort sceneId) +{ + return getJboolean(OpenZWave::Manager::Get()->ActivateScene(getUint8(sceneId))); +} + +/* + * Class: org_zwave4j_Manager + * Method: getDriverStatistics + * Signature: (JLorg/zwave4j/DriverData;)V + */ +JNIEXPORT void JNICALL Java_org_zwave4j_Manager_getDriverStatistics + (JNIEnv * env, jobject object, jlong homeId, jobject data) +{ + jclass clazz = findClass(env, "org/zwave4j/DriverData"); + OpenZWave::Driver::DriverData ozwDriverData = OpenZWave::Driver::DriverData(); + ozwDriverData.m_SOFCnt = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getSofCnt", "()J"))); + ozwDriverData.m_ACKWaiting = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getAckWaiting", "()J"))); + ozwDriverData.m_readAborts = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getReadAborts", "()J"))); + ozwDriverData.m_badChecksum = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getBadChecksum", "()J"))); + ozwDriverData.m_readCnt = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getReadCnt", "()J"))); + ozwDriverData.m_writeCnt = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getWriteCnt", "()J"))); + ozwDriverData.m_CANCnt = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getCanCnt", "()J"))); + ozwDriverData.m_NAKCnt = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getNakCnt", "()J"))); + ozwDriverData.m_ACKCnt = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getAckCnt", "()J"))); + ozwDriverData.m_OOFCnt = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getOofCnt", "()J"))); + ozwDriverData.m_dropped = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getDropped", "()J"))); + ozwDriverData.m_retries = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getRetries", "()J"))); + ozwDriverData.m_callbacks = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getCallbacks", "()J"))); + ozwDriverData.m_badroutes = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getBadRoutes", "()J"))); + ozwDriverData.m_noack = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getNoAck", "()J"))); + ozwDriverData.m_netbusy = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getNetBusy", "()J"))); + ozwDriverData.m_notidle = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getNotIdle", "()J"))); + ozwDriverData.m_nondelivery = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getNondelivery", "()J"))); + ozwDriverData.m_routedbusy = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getRoutedBusy", "()J"))); + ozwDriverData.m_broadcastReadCnt = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getBroadcastReadCnt", "()J"))); + ozwDriverData.m_broadcastWriteCnt = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getBroadcastWriteCnt", "()J"))); + + OpenZWave::Manager::Get()->GetDriverStatistics(getUint32(homeId), &ozwDriverData); + + env->CallVoidMethod(data, env->GetMethodID(clazz, "setSofCnt", "(J)V"), getJlong(ozwDriverData.m_SOFCnt)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setAckWaiting", "(J)V"), getJlong(ozwDriverData.m_ACKWaiting)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setReadAborts", "(J)V"), getJlong(ozwDriverData.m_readAborts)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setBadChecksum", "(J)V"), getJlong(ozwDriverData.m_badChecksum)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setReadCnt", "(J)V"), getJlong(ozwDriverData.m_readCnt)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setWriteCnt", "(J)V"), getJlong(ozwDriverData.m_writeCnt)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setCanCnt", "(J)V"), getJlong(ozwDriverData.m_CANCnt)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setNakCnt", "(J)V"), getJlong(ozwDriverData.m_NAKCnt)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setAckCnt", "(J)V"), getJlong(ozwDriverData.m_ACKCnt)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setOofCnt", "(J)V"), getJlong(ozwDriverData.m_OOFCnt)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setDropped", "(J)V"), getJlong(ozwDriverData.m_dropped)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setRetries", "(J)V"), getJlong(ozwDriverData.m_retries)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setCallbacks", "(J)V"), getJlong(ozwDriverData.m_callbacks)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setBadRoutes", "(J)V"), getJlong(ozwDriverData.m_badroutes)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setNoAck", "(J)V"), getJlong(ozwDriverData.m_noack)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setNetBusy", "(J)V"), getJlong(ozwDriverData.m_netbusy)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setNotIdle", "(J)V"), getJlong(ozwDriverData.m_notidle)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setNondelivery", "(J)V"), getJlong(ozwDriverData.m_nondelivery)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setRoutedBusy", "(J)V"), getJlong(ozwDriverData.m_routedbusy)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setBroadcastReadCnt", "(J)V"), getJlong(ozwDriverData.m_broadcastReadCnt)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setBroadcastWriteCnt", "(J)V"), getJlong(ozwDriverData.m_broadcastWriteCnt)); +} + +/* + * Class: org_zwave4j_Manager + * Method: getNodeStatistics + * Signature: (JSLorg/zwave4j/NodeData;)V + */ +JNIEXPORT void JNICALL Java_org_zwave4j_Manager_getNodeStatistics + (JNIEnv * env, jobject object, jlong homeId, jshort nodeId, jobject data) +{ + jclass clazz = findClass(env, "org/zwave4j/NodeData"); + OpenZWave::Node::NodeData ozwNodeData; + ozwNodeData.m_sentCnt = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getSentCnt", "()J"))); + ozwNodeData.m_sentFailed = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getSentFailed", "()J"))); + ozwNodeData.m_retries = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getRetries", "()J"))); + ozwNodeData.m_receivedCnt = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getReceivedCnt", "()J"))); + ozwNodeData.m_receivedDups = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getReceivedDups", "()J"))); + ozwNodeData.m_receivedUnsolicited = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getReceivedUnsolicited", "()J"))); + + jstring sentTs = (jstring) env->CallObjectMethod(data, env->GetMethodID(clazz, "getSentTs", "()Ljava/lang/String;")); + const char * sentTsChars = NULL; + if (sentTs != NULL) { + const char * sentTsChars = env->GetStringUTFChars(sentTs, NULL); + ozwNodeData.m_sentTS = std::string(sentTsChars); + } + + jstring receivedTs = (jstring) env->CallObjectMethod(data, env->GetMethodID(clazz, "getReceivedTs", "()Ljava/lang/String;")); + const char * receivedTsChars = NULL; + if (receivedTs != NULL) { + const char * receivedTsChars = env->GetStringUTFChars(receivedTs, NULL); + ozwNodeData.m_receivedTS = std::string(receivedTsChars); + } + + ozwNodeData.m_lastRequestRTT = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getLastRequestRtt", "()J"))); + ozwNodeData.m_averageRequestRTT = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getAverageRequestRtt", "()J"))); + ozwNodeData.m_lastResponseRTT = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getLastResponseRtt", "()J"))); + ozwNodeData.m_averageResponseRTT = getUint32(env->CallLongMethod(data, env->GetMethodID(clazz, "getAverageResponseRtt", "()J"))); + ozwNodeData.m_quality = getUint8(env->CallShortMethod(data, env->GetMethodID(clazz, "getQuality", "()S"))); + + jshortArray lastReceivedMessage = (jshortArray) env->CallObjectMethod(data, env->GetMethodID(clazz, "getLastReceivedMessage", "()[S")); + jshort * lastReceivedMessageElements = env->GetShortArrayElements(lastReceivedMessage, NULL); + for (uint32 i = 0; i < 254; ++i) + { + ozwNodeData.m_lastReceivedMessage[i] = getUint8(lastReceivedMessageElements[i]); + } + env->ReleaseShortArrayElements(lastReceivedMessage, lastReceivedMessageElements, 0); + + jobject ccData = env->CallObjectMethod(data, env->GetMethodID(clazz, "getCcData", "()Ljava/util/List;")); + jint ccDataSize = env->CallIntMethod(ccData, env->GetMethodID(findClass(env, "java/util/List"), "size", "()I")); + ozwNodeData.m_ccData.resize(ccDataSize); + for (std::list::iterator it = ozwNodeData.m_ccData.begin(); it != ozwNodeData.m_ccData.end(); it++) { + (*it) = getOzwCommandClassData(env, env->CallObjectMethod(ccData, env->GetMethodID(findClass(env, "java/util/List"), "get", "()Ljava/lang/Object;"))); + } + + OpenZWave::Manager::Get()->GetNodeStatistics(getUint32(homeId), getUint8(nodeId), &ozwNodeData); + + if (sentTsChars != NULL) { + env->ReleaseStringUTFChars(sentTs, sentTsChars); + } + if (receivedTsChars != NULL) { + env->ReleaseStringUTFChars(receivedTs, receivedTsChars); + } + + env->CallVoidMethod(data, env->GetMethodID(clazz, "setSentCnt", "(J)V"), getJlong(ozwNodeData.m_sentCnt)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setSentFailed", "(J)V"), getJlong(ozwNodeData.m_sentFailed)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setRetries", "(J)V"), getJlong(ozwNodeData.m_retries)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setReceivedCnt", "(J)V"), getJlong(ozwNodeData.m_receivedCnt)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setReceivedDups", "(J)V"), getJlong(ozwNodeData.m_receivedDups)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setReceivedUnsolicited", "(J)V"), getJlong(ozwNodeData.m_receivedUnsolicited)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setSentTs", "(Ljava/lang/String;)V"), env->NewStringUTF(ozwNodeData.m_sentTS.c_str())); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setReceivedTs", "(Ljava/lang/String;)V"), env->NewStringUTF(ozwNodeData.m_receivedTS.c_str())); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setLastRequestRtt", "(J)V"), getJlong(ozwNodeData.m_lastRequestRTT)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setAverageRequestRtt", "(J)V"), getJlong(ozwNodeData.m_averageRequestRTT)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setLastResponseRtt", "(J)V"), getJlong(ozwNodeData.m_lastResponseRTT)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setAverageResponseRtt", "(J)V"), getJlong(ozwNodeData.m_averageResponseRTT)); + env->CallVoidMethod(data, env->GetMethodID(clazz, "setQuality", "(S)V"), getJshort(ozwNodeData.m_quality)); + + lastReceivedMessage = (jshortArray) env->CallObjectMethod(data, env->GetMethodID(clazz, "getLastReceivedMessage", "()[S")); + lastReceivedMessageElements = env->GetShortArrayElements(lastReceivedMessage, NULL); + for (uint32 i = 0; i < 254; ++i) + { + lastReceivedMessageElements[i] = getJshort(ozwNodeData.m_lastReceivedMessage[i]); + } + env->ReleaseShortArrayElements(lastReceivedMessage, lastReceivedMessageElements, 0); + + ccData = env->CallObjectMethod(data, env->GetMethodID(clazz, "getCcData", "()Ljava/util/List;")); + env->CallVoidMethod(ccData, env->GetMethodID(findClass(env, "java/util/List"), "clear", "()V")); + for (std::list::iterator it = ozwNodeData.m_ccData.begin(); it != ozwNodeData.m_ccData.end(); it++) { + env->CallVoidMethod( + ccData, + env->GetMethodID(findClass(env, "java/util/List"), "set", "(Ljava/lang/Object;)V"), + getCommandClassData(env, &*it) + ); + } +} diff --git a/src/main/cpp/org_zwave4j_Options.cpp b/src/main/cpp/org_zwave4j_Options.cpp index 3ab1e04..8101316 100644 --- a/src/main/cpp/org_zwave4j_Options.cpp +++ b/src/main/cpp/org_zwave4j_Options.cpp @@ -23,6 +23,28 @@ #include "../headers/init.h" #include "../headers/org_zwave4j_Options.h" +jobject getOptionType(JNIEnv * env, OpenZWave::Options::OptionType ozwOptionType) +{ + const char * name; + switch(ozwOptionType) + { + case OpenZWave::Options::OptionType_Invalid: + name = "INVALID"; + break; + case OpenZWave::Options::OptionType_Bool: + name = "BOOL"; + break; + case OpenZWave::Options::OptionType_Int: + name = "INT"; + break; + case OpenZWave::Options::OptionType_String: + name = "STRING"; + break; + } + jclass clazz = findClass(env, "org/zwave4j/OptionType"); + return env->GetStaticObjectField(clazz, env->GetStaticFieldID(clazz, name, "Lorg/zwave4j/OptionType;")); +} + jobject getOptions(JNIEnv * env) { jclass clazz = findClass(env, "org/zwave4j/Options"); @@ -83,8 +105,11 @@ JNIEXPORT jboolean JNICALL Java_org_zwave4j_Options_addOptionBool (JNIEnv * env, jobject object, jstring name, jboolean defaultValue) { const char * nameChars = env->GetStringUTFChars(name, NULL); - return OpenZWave::Options::Get()->AddOptionBool(std::string(nameChars), getBool(defaultValue)); + + jboolean result = OpenZWave::Options::Get()->AddOptionBool(std::string(nameChars), getBool(defaultValue)); + env->ReleaseStringUTFChars(name, nameChars); + return result; } /* @@ -96,8 +121,11 @@ JNIEXPORT jboolean JNICALL Java_org_zwave4j_Options_addOptionInt (JNIEnv * env, jobject object, jstring name, jint defaultValue) { const char * nameChars = env->GetStringUTFChars(name, NULL); - return OpenZWave::Options::Get()->AddOptionInt(std::string(nameChars), defaultValue); + + jboolean result = OpenZWave::Options::Get()->AddOptionInt(std::string(nameChars), defaultValue); + env->ReleaseStringUTFChars(name, nameChars); + return result; } /* @@ -111,7 +139,7 @@ JNIEXPORT jboolean JNICALL Java_org_zwave4j_Options_addOptionString const char * nameChars = env->GetStringUTFChars(name, NULL); const char * defaultValueChars = env->GetStringUTFChars(defaultValue, NULL); - return OpenZWave::Options::Get()->AddOptionString( + jboolean result = OpenZWave::Options::Get()->AddOptionString( std::string(nameChars), std::string(defaultValueChars), getBool(append) @@ -119,6 +147,97 @@ JNIEXPORT jboolean JNICALL Java_org_zwave4j_Options_addOptionString env->ReleaseStringUTFChars(name, nameChars); env->ReleaseStringUTFChars(defaultValue, defaultValueChars); + return result; +} + +/* + * Class: org_zwave4j_Options + * Method: getOptionAsBool + * Signature: (Ljava/lang/String;Ljava/util/concurrent/atomic/AtomicReference;)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Options_getOptionAsBool + (JNIEnv * env, jobject object, jstring name, jobject value) +{ + const char * nameChars = env->GetStringUTFChars(name, NULL); + + bool ozwValue; + jboolean result = getJboolean(OpenZWave::Options::Get()->GetOptionAsBool(nameChars, &ozwValue)); + env->CallVoidMethod( + value, + env->GetMethodID(findClass(env, "java/util/concurrent/atomic/AtomicReference"), "set", "(Ljava/lang/Object;)V"), + env->NewObject( + findClass(env, "java/lang/Boolean"), + env->GetMethodID(findClass(env, "java/lang/Boolean"), "", "(Z)V"), + getJboolean(ozwValue) + ) + ); + + env->ReleaseStringUTFChars(name, nameChars); + return result; +} + +/* + * Class: org_zwave4j_Options + * Method: getOptionAsInt + * Signature: (Ljava/lang/String;Ljava/util/concurrent/atomic/AtomicReference;)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Options_getOptionAsInt + (JNIEnv * env, jobject object, jstring name, jobject value) +{ + const char * nameChars = env->GetStringUTFChars(name, NULL); + + int32 ozwValue; + jboolean result = getJboolean(OpenZWave::Options::Get()->GetOptionAsInt(nameChars, &ozwValue)); + env->CallVoidMethod( + value, + env->GetMethodID(findClass(env, "java/util/concurrent/atomic/AtomicReference"), "set", "(Ljava/lang/Object;)V"), + env->NewObject( + findClass(env, "java/lang/Integer"), + env->GetMethodID(findClass(env, "java/lang/Integer"), "", "(I)V"), + getJint(ozwValue) + ) + ); + + env->ReleaseStringUTFChars(name, nameChars); + return result; +} + +/* + * Class: org_zwave4j_Options + * Method: getOptionAsString + * Signature: (Ljava/lang/String;Ljava/util/concurrent/atomic/AtomicReference;)Z + */ +JNIEXPORT jboolean JNICALL Java_org_zwave4j_Options_getOptionAsString + (JNIEnv * env, jobject object, jstring name, jobject value) +{ + const char * nameChars = env->GetStringUTFChars(name, NULL); + + std::string ozwValue; + jboolean result = getJboolean(OpenZWave::Options::Get()->GetOptionAsString(nameChars, &ozwValue)); + env->CallVoidMethod( + value, + env->GetMethodID(findClass(env, "java/util/concurrent/atomic/AtomicReference"), "set", "(Ljava/lang/Object;)V"), + env->NewStringUTF(ozwValue.c_str()) + ); + + env->ReleaseStringUTFChars(name, nameChars); + return result; +} + +/* + * Class: org_zwave4j_Options + * Method: getOptionType + * Signature: (Ljava/lang/String;)Lorg/zwave4j/OptionType; + */ +JNIEXPORT jobject JNICALL Java_org_zwave4j_Options_getOptionType + (JNIEnv * env, jobject object, jstring name) +{ + const char * nameChars = env->GetStringUTFChars(name, NULL); + + OpenZWave::Options::OptionType ozwOptionType = OpenZWave::Options::Get()->GetOptionType(nameChars); + + env->ReleaseStringUTFChars(name, nameChars); + return getOptionType(env, ozwOptionType); } /* diff --git a/src/main/java/org/zwave4j/CommandClassData.java b/src/main/java/org/zwave4j/CommandClassData.java new file mode 100644 index 0000000..d7b4a15 --- /dev/null +++ b/src/main/java/org/zwave4j/CommandClassData.java @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2013 Alexander Zagumennikov + * + * SOFTWARE NOTICE AND LICENSE + * + * This file is part of ZWave4J. + * + * ZWave4J is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * ZWave4J is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ZWave4J. If not, see . + */ + +package org.zwave4j; + +/** + * @author zagumennikov + */ +public class CommandClassData { + + private long commandClassId; + private long sentCnt; + private long receivedCnt; + + public CommandClassData(long commandClassId, long sentCnt, long receivedCnt) { + this.commandClassId = commandClassId; + this.sentCnt = sentCnt; + this.receivedCnt = receivedCnt; + } + + public long getCommandClassId() { + return commandClassId; + } + + public long getSentCnt() { + return sentCnt; + } + + public long getReceivedCnt() { + return receivedCnt; + } +} diff --git a/src/main/java/org/zwave4j/ControllerCallback.java b/src/main/java/org/zwave4j/ControllerCallback.java new file mode 100644 index 0000000..7895d34 --- /dev/null +++ b/src/main/java/org/zwave4j/ControllerCallback.java @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2013 Alexander Zagumennikov + * + * SOFTWARE NOTICE AND LICENSE + * + * This file is part of ZWave4J. + * + * ZWave4J is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * ZWave4J is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ZWave4J. If not, see . + */ + +package org.zwave4j; + +/** + * @author zagumennikov + */ +public interface ControllerCallback { + + void onCallback(ControllerState state, ControllerError err, Object context); +} diff --git a/src/main/java/org/zwave4j/ControllerCommand.java b/src/main/java/org/zwave4j/ControllerCommand.java new file mode 100644 index 0000000..6be8358 --- /dev/null +++ b/src/main/java/org/zwave4j/ControllerCommand.java @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2013 Alexander Zagumennikov + * + * SOFTWARE NOTICE AND LICENSE + * + * This file is part of ZWave4J. + * + * ZWave4J is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * ZWave4J is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ZWave4J. If not, see . + */ + +package org.zwave4j; + +/** + * @author zagumennikov + */ +public enum ControllerCommand { + NONE, + ADD_DEVICE, + CREATE_NEW_PRIMARY, + RECEIVE_CONFIGURATION, + REMOVE_DEVICE, + REMOVE_FAILED_NODE, + HAS_NODE_FAILED, + REPLACE_FAILED_NODE, + TRANSFER_PRIMARY_ROLE, + REQUEST_NETWORK_UPDATE, + REQUEST_NODE_NEIGHBOR_UPDATE, + ASSIGN_RETURN_ROUTE, + DELETE_ALL_RETURN_ROUTES, + SEND_NODE_INFORMATION, + REPLICATION_SEND, + CREATE_BUTTON, + DELETE_BUTTON +} diff --git a/src/main/java/org/zwave4j/ControllerError.java b/src/main/java/org/zwave4j/ControllerError.java new file mode 100644 index 0000000..ccb5c0f --- /dev/null +++ b/src/main/java/org/zwave4j/ControllerError.java @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2013 Alexander Zagumennikov + * + * SOFTWARE NOTICE AND LICENSE + * + * This file is part of ZWave4J. + * + * ZWave4J is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * ZWave4J is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ZWave4J. If not, see . + */ + +package org.zwave4j; + +/** + * @author zagumennikov + */ +public enum ControllerError { + NONE, + BUTTON_NOT_FOUND, + NODE_NOT_FOUND, + NOT_BRIDGE, + NOT_SUC, + NOT_SECONDARY, + NOT_PRIMARY, + IS_PRIMARY, + NOT_FOUND, + BUSY, + FAILED, + DISABLED, + OVERFLOW +} diff --git a/src/main/java/org/zwave4j/ControllerInterface.java b/src/main/java/org/zwave4j/ControllerInterface.java new file mode 100644 index 0000000..66ee193 --- /dev/null +++ b/src/main/java/org/zwave4j/ControllerInterface.java @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2013 Alexander Zagumennikov + * + * SOFTWARE NOTICE AND LICENSE + * + * This file is part of ZWave4J. + * + * ZWave4J is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * ZWave4J is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ZWave4J. If not, see . + */ + +package org.zwave4j; + +/** + * @author zagumennikov + */ +public enum ControllerInterface { + UNKNOWN, + SERIAL, + HID +} diff --git a/src/main/java/org/zwave4j/ControllerState.java b/src/main/java/org/zwave4j/ControllerState.java new file mode 100644 index 0000000..e472b07 --- /dev/null +++ b/src/main/java/org/zwave4j/ControllerState.java @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2013 Alexander Zagumennikov + * + * SOFTWARE NOTICE AND LICENSE + * + * This file is part of ZWave4J. + * + * ZWave4J is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * ZWave4J is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ZWave4J. If not, see . + */ + +package org.zwave4j; + +/** + * @author zagumennikov + */ +public enum ControllerState { + NORMAL, + STARTING, + CANCEL, + ERROR, + WAITING, + SLEEPING, + IN_PROGRESS, + COMPLETED, + FAILED, + NODE_OK, + NODE_FAILED +} diff --git a/src/main/java/org/zwave4j/DriverData.java b/src/main/java/org/zwave4j/DriverData.java new file mode 100644 index 0000000..d7a480e --- /dev/null +++ b/src/main/java/org/zwave4j/DriverData.java @@ -0,0 +1,218 @@ +/* + * Copyright (c) 2013 Alexander Zagumennikov + * + * SOFTWARE NOTICE AND LICENSE + * + * This file is part of ZWave4J. + * + * ZWave4J is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * ZWave4J is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ZWave4J. If not, see . + */ + +package org.zwave4j; + +/** + * @author zagumennikov + */ +public class DriverData { + + private long sofCnt; + private long ackWaiting; + private long readAborts; + private long badChecksum; + private long readCnt; + private long writeCnt; + private long canCnt; + private long nakCnt; + private long ackCnt; + private long oofCnt; + private long dropped; + private long retries; + private long callbacks; + private long badRoutes; + private long noAck; + private long netBusy; + private long notIdle; + private long nondelivery; + private long routedBusy; + private long broadcastReadCnt; + private long broadcastWriteCnt; + + public long getSofCnt() { + return sofCnt; + } + + public void setSofCnt(long sofCnt) { + this.sofCnt = sofCnt; + } + + public long getAckWaiting() { + return ackWaiting; + } + + public void setAckWaiting(long ackWaiting) { + this.ackWaiting = ackWaiting; + } + + public long getReadAborts() { + return readAborts; + } + + public void setReadAborts(long readAborts) { + this.readAborts = readAborts; + } + + public long getBadChecksum() { + return badChecksum; + } + + public void setBadChecksum(long badChecksum) { + this.badChecksum = badChecksum; + } + + public long getReadCnt() { + return readCnt; + } + + public void setReadCnt(long readCnt) { + this.readCnt = readCnt; + } + + public long getWriteCnt() { + return writeCnt; + } + + public void setWriteCnt(long writeCnt) { + this.writeCnt = writeCnt; + } + + public long getCanCnt() { + return canCnt; + } + + public void setCanCnt(long canCnt) { + this.canCnt = canCnt; + } + + public long getNakCnt() { + return nakCnt; + } + + public void setNakCnt(long nakCnt) { + this.nakCnt = nakCnt; + } + + public long getAckCnt() { + return ackCnt; + } + + public void setAckCnt(long ackCnt) { + this.ackCnt = ackCnt; + } + + public long getOofCnt() { + return oofCnt; + } + + public void setOofCnt(long oofCnt) { + this.oofCnt = oofCnt; + } + + public long getDropped() { + return dropped; + } + + public void setDropped(long dropped) { + this.dropped = dropped; + } + + public long getRetries() { + return retries; + } + + public void setRetries(long retries) { + this.retries = retries; + } + + public long getCallbacks() { + return callbacks; + } + + public void setCallbacks(long callbacks) { + this.callbacks = callbacks; + } + + public long getBadRoutes() { + return badRoutes; + } + + public void setBadRoutes(long badRoutes) { + this.badRoutes = badRoutes; + } + + public long getNoAck() { + return noAck; + } + + public void setNoAck(long noAck) { + this.noAck = noAck; + } + + public long getNetBusy() { + return netBusy; + } + + public void setNetBusy(long netBusy) { + this.netBusy = netBusy; + } + + public long getNotIdle() { + return notIdle; + } + + public void setNotIdle(long notIdle) { + this.notIdle = notIdle; + } + + public long getNondelivery() { + return nondelivery; + } + + public void setNondelivery(long nondelivery) { + this.nondelivery = nondelivery; + } + + public long getRoutedBusy() { + return routedBusy; + } + + public void setRoutedBusy(long routedBusy) { + this.routedBusy = routedBusy; + } + + public long getBroadcastReadCnt() { + return broadcastReadCnt; + } + + public void setBroadcastReadCnt(long broadcastReadCnt) { + this.broadcastReadCnt = broadcastReadCnt; + } + + public long getBroadcastWriteCnt() { + return broadcastWriteCnt; + } + + public void setBroadcastWriteCnt(long broadcastWriteCnt) { + this.broadcastWriteCnt = broadcastWriteCnt; + } +} diff --git a/src/main/java/org/zwave4j/Main.java b/src/main/java/org/zwave4j/Main.java index f404afc..8e955a6 100644 --- a/src/main/java/org/zwave4j/Main.java +++ b/src/main/java/org/zwave4j/Main.java @@ -42,9 +42,10 @@ public static void main(String[] args) throws IOException { options.lock(); final Manager manager = Manager.create(); - manager.addNotificationWatcher(new NotificationWatcher() { + + final NotificationWatcher watcher = new NotificationWatcher() { @Override - public void onNotification(Notification notification) { + public void onNotification(Notification notification, Object context) { switch (notification.getType()) { case DRIVER_READY: System.out.println(String.format("Driver ready\n" + @@ -69,6 +70,8 @@ public void onNotification(Notification notification) { break; case ALL_NODES_QUERIED_SOME_DEAD: System.out.println("All nodes queried some dead"); + manager.writeConfig(homeId); + ready = true; break; case POLLING_ENABLED: System.out.println("Polling enabled"); @@ -235,13 +238,14 @@ public void onNotification(Notification notification) { break; } } - }); + }; + manager.addWatcher(watcher, null); - String controllerPort = args[1]; + final String controllerPort = args[1]; manager.addDriver(controllerPort); - BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + final BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); String line; do { @@ -250,16 +254,20 @@ public void onNotification(Notification notification) { continue; } - if (line.equals("on")) { - manager.switchAllOn(homeId); - } else if (line.equals("off")) { - manager.switchAllOff(homeId); + switch (line) { + case "on": + manager.switchAllOn(homeId); + break; + case "off": + manager.switchAllOff(homeId); + break; } } while(line != null && !line.equals("q")); br.close(); + manager.removeWatcher(watcher, null); manager.removeDriver(controllerPort); Manager.destroy(); Options.destroy(); diff --git a/src/main/java/org/zwave4j/Manager.java b/src/main/java/org/zwave4j/Manager.java index 0b17371..c358971 100644 --- a/src/main/java/org/zwave4j/Manager.java +++ b/src/main/java/org/zwave4j/Manager.java @@ -21,7 +21,6 @@ package org.zwave4j; -import java.util.ArrayList; import java.util.List; import java.util.concurrent.atomic.AtomicReference; @@ -51,9 +50,6 @@ public static void destroy() { private static native void createNativeManager(); private static native void destroyNativeManager(); - - - private List notificationWatchers = new ArrayList<>(); //Configuration @@ -65,6 +61,29 @@ public static void destroy() { public native boolean removeDriver(String path); + public native short getControllerNodeId(long homeId); + + public native short getSUCNodeId(long homeId); + + public native boolean isPrimaryController(long homeId); + + public native boolean isStaticUpdateController(long homeId); + + public native boolean isBridgeController(long homeId); + + public native String getLibraryVersion(long homeId); + + public native String getLibraryTypeName(long homeId); + + public native int getSendQueueCount(long homeId); + + public native void logDriverStatistics(long homeId); + + public native ControllerInterface getControllerInterfaceType(long homeId); + + public native String getControllerPath(long homeId); + + //Polling public native int getPollInterval(); @@ -225,10 +244,24 @@ public static void destroy() { public native void setChangeVerified(ValueId id, boolean verify); + + //Button public native boolean pressButton(ValueId id); public native boolean releaseButton(ValueId id); + + //Climate Control Schedules + public native short getNumSwitchPoints(ValueId id); + + public native boolean setSwitchPoint(ValueId id, short hours, short minutes, byte setback); + + public native boolean removeSwitchPoint(ValueId id, short hours, short minutes); + + public native void clearSwitchPoints(ValueId id); + + public native boolean getSwitchPoint(ValueId id, short idx, AtomicReference hours, AtomicReference minutes, AtomicReference setback); + //Switch all public native void switchAllOn(long homeId); @@ -245,21 +278,131 @@ public static void destroy() { public native void requestAllConfigParams(long homeId, short nodeId); - public void addNotificationWatcher(NotificationWatcher notificationWatcher) { - notificationWatchers.add(notificationWatcher); - } - public void removeNotificationWatcher(NotificationWatcher notificationWatcher) { - notificationWatchers.remove(notificationWatcher); - } - + //Groups + public native short getNumGroups(long homeId, short nodeId); - /** - * Called from native - */ - private void fireNotificationWatchers(Notification notification) { - for (NotificationWatcher notificationWatcher : notificationWatchers) { - notificationWatcher.onNotification(notification); - } - } + public native long getAssociations(long homeId, short nodeId, short groupIdx, AtomicReference associations); + + public native short getMaxAssociations(long homeId, short nodeId, short groupIdx); + + public native String getGroupLabel(long homeId, short nodeId, short groupIdx); + + public native void addAssociation(long homeId, short nodeId, short groupIdx, short targetNodeId); + + public native void removeAssociation(long homeId, short nodeId, short groupIdx, short targetNodeId); + + + //Notifications + public native void addWatcher(NotificationWatcher notificationWatcher, Object context); + + public native void removeWatcher(NotificationWatcher notificationWatcher, Object context); + + + //Controller commands + public native void resetController(long homeId); + + public native void softReset(long homeId); + + public native boolean beginControllerCommand(long homeId, ControllerCommand command); + + public native boolean beginControllerCommand(long homeId, ControllerCommand command, ControllerCallback callback); + + public native boolean beginControllerCommand(long homeId, ControllerCommand command, ControllerCallback callback, Object context); + + public native boolean beginControllerCommand(long homeId, ControllerCommand command, ControllerCallback callback, Object context, boolean highPower); + + public native boolean beginControllerCommand(long homeId, ControllerCommand command, ControllerCallback callback, Object context, boolean highPower, short nodeId); + + public native boolean beginControllerCommand(long homeId, ControllerCommand command, ControllerCallback callback, Object context, boolean highPower, short nodeId, short arg); + + public native boolean cancelControllerCommand(long homeId); + + + //Network commands + public native void testNetworkNode(long homeId, short nodeId, long count); + + public native void testNetwork(long homeId, long count); + + public native void healNetworkNode(long homeId, short nodeId, boolean doRR); + + public native void healNetwork(long homeId, boolean doRR); + + + //Scene commands + public native short getNumScenes(); + + public native short getAllScenes(AtomicReference sceneIds); + + public native void removeAllScenes(long homeId); + + public native short createScene(); + + public native boolean removeScene(short sceneId); + + public native boolean addSceneValueAsBool(short sceneId, ValueId valueId, boolean value); + + public native boolean addSceneValueAsByte(short sceneId, ValueId valueId, short value); + + public native boolean addSceneValueAsFloat(short sceneId, ValueId valueId, float value); + + public native boolean addSceneValueAsInt(short sceneId, ValueId valueId, int value); + + public native boolean addSceneValueAsShort(short sceneId, ValueId valueId, short value); + + public native boolean addSceneValueAsString(short sceneId, ValueId valueId, String value); + + public native boolean addSceneValueListSelection(short sceneId, ValueId valueId, String value); + + public native boolean addSceneValueListSelection(short sceneId, ValueId valueId, int value); + + public native boolean removeSceneValue(short sceneId, ValueId valueId); + + public native int sceneGetValues(short sceneId, List value); + + public native boolean sceneGetValueAsBool(short sceneId, ValueId valueId, AtomicReference value); + + public native boolean sceneGetValueAsByte(short sceneId, ValueId valueId, AtomicReference value); + + public native boolean sceneGetValueAsFloat(short sceneId, ValueId valueId, AtomicReference value); + + public native boolean sceneGetValueAsInt(short sceneId, ValueId valueId, AtomicReference value); + + public native boolean sceneGetValueAsShort(short sceneId, ValueId valueId, AtomicReference value); + + public native boolean sceneGetValueAsString(short sceneId, ValueId valueId, AtomicReference value); + + public native boolean sceneGetValueListSelectionString(short sceneId, ValueId valueId, AtomicReference value); + + public native boolean sceneGetValueListSelectionInt(short sceneId, ValueId valueId, AtomicReference value); + + public native boolean setSceneValueAsBool(short sceneId, ValueId valueId, boolean value); + + public native boolean setSceneValueAsByte(short sceneId, ValueId valueId, short value); + + public native boolean setSceneValueAsFloat(short sceneId, ValueId valueId, float value); + + public native boolean setSceneValueAsInt(short sceneId, ValueId valueId, int value); + + public native boolean setSceneValueAsShort(short sceneId, ValueId valueId, short value); + + public native boolean setSceneValueAsString(short sceneId, ValueId valueId, String value); + + public native boolean setSceneValueListSelection(short sceneId, ValueId valueId, String value); + + public native boolean setSceneValueListSelection(short sceneId, ValueId valueId, int value); + + public native String getSceneLabel(short sceneId); + + public native void setSceneLabel(short sceneId, String value); + + public native boolean sceneExists(short sceneId); + + public native boolean activateScene(short sceneId); + + + //Statistics + public native void getDriverStatistics(long homeId, DriverData data); + + public native void getNodeStatistics(long homeId, short nodeId, NodeData data); } diff --git a/src/main/java/org/zwave4j/NodeData.java b/src/main/java/org/zwave4j/NodeData.java new file mode 100644 index 0000000..dbb2168 --- /dev/null +++ b/src/main/java/org/zwave4j/NodeData.java @@ -0,0 +1,159 @@ +/* + * Copyright (c) 2013 Alexander Zagumennikov + * + * SOFTWARE NOTICE AND LICENSE + * + * This file is part of ZWave4J. + * + * ZWave4J is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * ZWave4J is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ZWave4J. If not, see . + */ + +package org.zwave4j; + +import java.util.ArrayList; +import java.util.List; + +/** + * @author zagumennikov + */ +public class NodeData { + + private long sentCnt; + private long sentFailed; + private long retries; + private long receivedCnt; + private long receivedDups; + private long receivedUnsolicited; + private String sentTs; + private String receivedTs; + private long lastRequestRtt; + private long averageRequestRtt; + private long lastResponseRtt; + private long averageResponseRtt; + private short quality; + private short[] lastReceivedMessage = new short[254]; + private List ccData = new ArrayList<>(); + + public long getSentCnt() { + return sentCnt; + } + + public void setSentCnt(long sentCnt) { + this.sentCnt = sentCnt; + } + + public long getSentFailed() { + return sentFailed; + } + + public void setSentFailed(long sentFailed) { + this.sentFailed = sentFailed; + } + + public long getRetries() { + return retries; + } + + public void setRetries(long retries) { + this.retries = retries; + } + + public long getReceivedCnt() { + return receivedCnt; + } + + public void setReceivedCnt(long receivedCnt) { + this.receivedCnt = receivedCnt; + } + + public long getReceivedDups() { + return receivedDups; + } + + public void setReceivedDups(long receivedDups) { + this.receivedDups = receivedDups; + } + + public long getReceivedUnsolicited() { + return receivedUnsolicited; + } + + public void setReceivedUnsolicited(long receivedUnsolicited) { + this.receivedUnsolicited = receivedUnsolicited; + } + + public String getSentTs() { + return sentTs; + } + + public void setSentTs(String sentTs) { + this.sentTs = sentTs; + } + + public String getReceivedTs() { + return receivedTs; + } + + public void setReceivedTs(String receivedTs) { + this.receivedTs = receivedTs; + } + + public long getLastRequestRtt() { + return lastRequestRtt; + } + + public void setLastRequestRtt(long lastRequestRtt) { + this.lastRequestRtt = lastRequestRtt; + } + + public long getAverageRequestRtt() { + return averageRequestRtt; + } + + public void setAverageRequestRtt(long averageRequestRtt) { + this.averageRequestRtt = averageRequestRtt; + } + + public long getLastResponseRtt() { + return lastResponseRtt; + } + + public void setLastResponseRtt(long lastResponseRtt) { + this.lastResponseRtt = lastResponseRtt; + } + + public long getAverageResponseRtt() { + return averageResponseRtt; + } + + public void setAverageResponseRtt(long averageResponseRtt) { + this.averageResponseRtt = averageResponseRtt; + } + + public short getQuality() { + return quality; + } + + public void setQuality(short quality) { + this.quality = quality; + } + + public short[] getLastReceivedMessage() { + return lastReceivedMessage; + } + + public List getCcData() { + return ccData; + } +} diff --git a/src/main/java/org/zwave4j/NotificationWatcher.java b/src/main/java/org/zwave4j/NotificationWatcher.java index 6b2b703..f1406d3 100644 --- a/src/main/java/org/zwave4j/NotificationWatcher.java +++ b/src/main/java/org/zwave4j/NotificationWatcher.java @@ -26,5 +26,5 @@ */ public interface NotificationWatcher { - void onNotification(Notification notification); + void onNotification(Notification notification, Object context); } diff --git a/src/main/java/org/zwave4j/OptionType.java b/src/main/java/org/zwave4j/OptionType.java new file mode 100644 index 0000000..49d2271 --- /dev/null +++ b/src/main/java/org/zwave4j/OptionType.java @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2013 Alexander Zagumennikov + * + * SOFTWARE NOTICE AND LICENSE + * + * This file is part of ZWave4J. + * + * ZWave4J is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * ZWave4J is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ZWave4J. If not, see . + */ + +package org.zwave4j; + +/** + * @author zagumennikov + */ +public enum OptionType { + INVALID, + BOOL, + INT, + STRING +} diff --git a/src/main/java/org/zwave4j/Options.java b/src/main/java/org/zwave4j/Options.java index 7cd480c..05df417 100644 --- a/src/main/java/org/zwave4j/Options.java +++ b/src/main/java/org/zwave4j/Options.java @@ -21,6 +21,8 @@ package org.zwave4j; +import java.util.concurrent.atomic.AtomicReference; + /** * @author zagumennikov */ @@ -57,5 +59,13 @@ public static boolean destroy() { public native boolean addOptionString(String name, String defaultValue, boolean append); + public native boolean getOptionAsBool(String name, AtomicReference value); + + public native boolean getOptionAsInt(String name, AtomicReference value); + + public native boolean getOptionAsString(String name, AtomicReference value); + + public native OptionType getOptionType(String name); + public native boolean areLocked(); }