Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-20 00:51:42 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
95d40ed01f8e66aa6aaa97f8601a366bdc73d0e7
allwpilib/wpilibj/src/athena/cpp/lib/AnalogJNI.cpp

668 lines
20 KiB
C++
Raw Normal View History

artf2612: Update license in source files. Years update, references to WIND_BASE were removed, and WPILib license was moved to the root directory of the project. If there was already a comment block, a year range through 2016 was created using the first year in the comment. If there was no comment block, a block with just the year 2016 was added. Comments were not added to files from external sources (NI, CTRE). Change-Id: Iff4f098ab908b90b8d929902dea903de2f596acc
2016-01-02 03:02:34 -08:00
/*----------------------------------------------------------------------------*/
/* Copyright (c) FIRST 2016. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
/*----------------------------------------------------------------------------*/
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
#include <assert.h>
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
#include <jni.h>
Renames all our .hpp HAL files to .h (#44) Adds consistency, as the HAL was .hpp however all other code was .h.
2016-05-22 21:41:22 -07:00
#include "Log.h"
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
#include "edu_wpi_first_wpilibj_hal_AnalogJNI.h"
Splits HAL Digital and Analog Headers into multiple headers (#52) The Digital and Analog headers (and the implementations, but that will be moved over later) are just too big and congested. This splits those headers, and then changes the few things that needed to be changed in WPILib to get the code working again. No function changes were made in this commit.
2016-05-24 00:58:10 -07:00
#include "HAL/AnalogInput.h"
#include "HAL/AnalogOutput.h"
#include "HAL/AnalogAccumulator.h"
#include "HAL/AnalogTrigger.h"
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
#include "HALUtil.h"
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
// set the logging level
Adds the Accumulator code to the AnalogJNI.cpp Disables the debug printlines from the AnalogJNI.cpp file Change-Id: Iac962721fb3eeca8f208feb162c96d5ae9f342a2
2014-05-20 15:38:41 -04:00
TLogLevel analogJNILogLevel = logWARNING;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
#define ANALOGJNI_LOG(level) \
if (level > analogJNILogLevel) \
; \
else \
Log().Get(level)
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
extern "C" {
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
Added support for digital and analog IO pins on the MXP Change-Id: I3a4e14ceab885d19a615d6cd45f22a2250ad2856
2014-06-12 09:08:33 -04:00
* Method: initializeAnalogInputPort
Changes HAL Port from a pointer to a handle (#93) HAL Port is using a special handle, where the module and pin are bit shifted straight into the handle. This is one of the few special cases we have, but for the way port is used it is much cleaner and uses much less memory. Plus it is generic and not specific to one type.
2016-06-05 15:23:58 -07:00
* Signature: (I)J
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jlong JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_initializeAnalogInputPort(
Changes HAL Port from a pointer to a handle (#93) HAL Port is using a special handle, where the module and pin are bit shifted straight into the handle. This is one of the few special cases we have, but for the way port is used it is much cleaner and uses much less memory. Plus it is generic and not specific to one type.
2016-06-05 15:23:58 -07:00
JNIEnv *env, jclass, jint id) {
ANALOGJNI_LOG(logDEBUG) << "Port Handle = " << (HalPortHandle)id;
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
int32_t status = 0;
Changes HAL Port from a pointer to a handle (#93) HAL Port is using a special handle, where the module and pin are bit shifted straight into the handle. This is one of the few special cases we have, but for the way port is used it is much cleaner and uses much less memory. Plus it is generic and not specific to one type.
2016-06-05 15:23:58 -07:00
void *analog = initializeAnalogInputPort((HalPortHandle)id, &status);
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << analog;
CheckStatus(env, status);
return (jlong)analog;
Added support for digital and analog IO pins on the MXP Change-Id: I3a4e14ceab885d19a615d6cd45f22a2250ad2856
2014-06-12 09:08:33 -04:00
}
artf4153 Adds HAL structure memory management In the current HAL, once the port structures were created, there was no way to free the structures. The way the C++ libraries were written this wasn't a problem, since it grabbed a copy of each and stored them in an array on bootup. However java does not do this, and grabs new ports every time an object is created. This causes memory leaks if an object is ever disposed in java. The same thing looks to be happening in python, and C# does it too currently, but that would change if this gets merged. Adds java memory management fixes Adds memory management to AnalogInput and Analog Output C++ SolenoidPorts and Digital Ports are all hold static arrays with their port pointers (although solenoid overwrites them if a new solenoid on the same module is created), however analog always grabbed new pointers. I would fix the solenoid one, but I don't know what the ideal way to do it would be. Silently ignores free(null) calls by checking passed parameter is non-null. Change-Id: Id32993b57b53f896e46e55c97541d3bd90b52648
2015-10-20 10:37:04 -07:00
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: freeAnalogInputPort
* Signature: (J)V
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_freeAnalogInputPort(
JNIEnv *env, jclass, jlong id) {
ANALOGJNI_LOG(logDEBUG) << "Port Ptr = " << (void *)id;
freeAnalogInputPort((void *)id);
artf4153 Adds HAL structure memory management In the current HAL, once the port structures were created, there was no way to free the structures. The way the C++ libraries were written this wasn't a problem, since it grabbed a copy of each and stored them in an array on bootup. However java does not do this, and grabs new ports every time an object is created. This causes memory leaks if an object is ever disposed in java. The same thing looks to be happening in python, and C# does it too currently, but that would change if this gets merged. Adds java memory management fixes Adds memory management to AnalogInput and Analog Output C++ SolenoidPorts and Digital Ports are all hold static arrays with their port pointers (although solenoid overwrites them if a new solenoid on the same module is created), however analog always grabbed new pointers. I would fix the solenoid one, but I don't know what the ideal way to do it would be. Silently ignores free(null) calls by checking passed parameter is non-null. Change-Id: Id32993b57b53f896e46e55c97541d3bd90b52648
2015-10-20 10:37:04 -07:00
}
Added support for digital and analog IO pins on the MXP Change-Id: I3a4e14ceab885d19a615d6cd45f22a2250ad2856
2014-06-12 09:08:33 -04:00
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: initializeAnalogOutputPort
Changes HAL Port from a pointer to a handle (#93) HAL Port is using a special handle, where the module and pin are bit shifted straight into the handle. This is one of the few special cases we have, but for the way port is used it is much cleaner and uses much less memory. Plus it is generic and not specific to one type.
2016-06-05 15:23:58 -07:00
* Signature: (I)J
Added support for digital and analog IO pins on the MXP Change-Id: I3a4e14ceab885d19a615d6cd45f22a2250ad2856
2014-06-12 09:08:33 -04:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jlong JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_initializeAnalogOutputPort(
Changes HAL Port from a pointer to a handle (#93) HAL Port is using a special handle, where the module and pin are bit shifted straight into the handle. This is one of the few special cases we have, but for the way port is used it is much cleaner and uses much less memory. Plus it is generic and not specific to one type.
2016-06-05 15:23:58 -07:00
JNIEnv *env, jclass, jint id) {
ANALOGJNI_LOG(logDEBUG) << "Port Handle = " << (HalPortHandle)id;
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
int32_t status = 0;
Changes HAL Port from a pointer to a handle (#93) HAL Port is using a special handle, where the module and pin are bit shifted straight into the handle. This is one of the few special cases we have, but for the way port is used it is much cleaner and uses much less memory. Plus it is generic and not specific to one type.
2016-06-05 15:23:58 -07:00
void *analog = initializeAnalogOutputPort((HalPortHandle)id, &status);
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << analog;
CheckStatus(env, status);
return (jlong)analog;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
artf4153 Adds HAL structure memory management In the current HAL, once the port structures were created, there was no way to free the structures. The way the C++ libraries were written this wasn't a problem, since it grabbed a copy of each and stored them in an array on bootup. However java does not do this, and grabs new ports every time an object is created. This causes memory leaks if an object is ever disposed in java. The same thing looks to be happening in python, and C# does it too currently, but that would change if this gets merged. Adds java memory management fixes Adds memory management to AnalogInput and Analog Output C++ SolenoidPorts and Digital Ports are all hold static arrays with their port pointers (although solenoid overwrites them if a new solenoid on the same module is created), however analog always grabbed new pointers. I would fix the solenoid one, but I don't know what the ideal way to do it would be. Silently ignores free(null) calls by checking passed parameter is non-null. Change-Id: Id32993b57b53f896e46e55c97541d3bd90b52648
2015-10-20 10:37:04 -07:00
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: freeAnalogOutputPort
* Signature: (J)V
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_freeAnalogOutputPort(
JNIEnv *env, jclass, jlong id) {
ANALOGJNI_LOG(logDEBUG) << "Port Ptr = " << (void *)id;
freeAnalogOutputPort((void *)id);
artf4153 Adds HAL structure memory management In the current HAL, once the port structures were created, there was no way to free the structures. The way the C++ libraries were written this wasn't a problem, since it grabbed a copy of each and stored them in an array on bootup. However java does not do this, and grabs new ports every time an object is created. This causes memory leaks if an object is ever disposed in java. The same thing looks to be happening in python, and C# does it too currently, but that would change if this gets merged. Adds java memory management fixes Adds memory management to AnalogInput and Analog Output C++ SolenoidPorts and Digital Ports are all hold static arrays with their port pointers (although solenoid overwrites them if a new solenoid on the same module is created), however analog always grabbed new pointers. I would fix the solenoid one, but I don't know what the ideal way to do it would be. Silently ignores free(null) calls by checking passed parameter is non-null. Change-Id: Id32993b57b53f896e46e55c97541d3bd90b52648
2015-10-20 10:37:04 -07:00
}
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: checkAnalogModule
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (B)Z
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jboolean JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_checkAnalogModule(
JNIEnv *, jclass, jbyte value) {
// ANALOGJNI_LOG(logDEBUG) << "Module = " << (jint)value;
jboolean returnValue = checkAnalogModule(value);
// ANALOGJNI_LOG(logDEBUG) << "checkAnalogModuleResult = " <<
// (jint)returnValue;
return returnValue;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
Added support for digital and analog IO pins on the MXP Change-Id: I3a4e14ceab885d19a615d6cd45f22a2250ad2856
2014-06-12 09:08:33 -04:00
* Method: checkAnalogInputChannel
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (I)Z
Added support for digital and analog IO pins on the MXP Change-Id: I3a4e14ceab885d19a615d6cd45f22a2250ad2856
2014-06-12 09:08:33 -04:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jboolean JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_checkAnalogInputChannel(
JNIEnv *, jclass, jint value) {
// ANALOGJNI_LOG(logDEBUG) << "Channel = " << value;
jboolean returnValue = checkAnalogInputChannel(value);
// ANALOGJNI_LOG(logDEBUG) << "checkAnalogChannelResult = " <<
// (jint)returnValue;
return returnValue;
Added support for digital and analog IO pins on the MXP Change-Id: I3a4e14ceab885d19a615d6cd45f22a2250ad2856
2014-06-12 09:08:33 -04:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: checkAnalogOutputChannel
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (I)Z
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jboolean JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_checkAnalogOutputChannel(
JNIEnv *, jclass, jint value) {
// ANALOGJNI_LOG(logDEBUG) << "Channel = " << value;
jboolean returnValue = checkAnalogOutputChannel(value);
// ANALOGJNI_LOG(logDEBUG) << "checkAnalogChannelResult = " <<
// (jint)returnValue;
return returnValue;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
Added support for digital and analog IO pins on the MXP Change-Id: I3a4e14ceab885d19a615d6cd45f22a2250ad2856
2014-06-12 09:08:33 -04:00
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: setAnalogOutput
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (JD)V
Added support for digital and analog IO pins on the MXP Change-Id: I3a4e14ceab885d19a615d6cd45f22a2250ad2856
2014-06-12 09:08:33 -04:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT void JNICALL Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAnalogOutput(
JNIEnv *env, jclass, jlong id, jdouble voltage) {
ANALOGJNI_LOG(logDEBUG) << "Calling setAnalogOutput";
ANALOGJNI_LOG(logDEBUG) << "Voltage = " << voltage;
ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
int32_t status = 0;
setAnalogOutput((void *)id, voltage, &status);
CheckStatus(env, status);
Added support for digital and analog IO pins on the MXP Change-Id: I3a4e14ceab885d19a615d6cd45f22a2250ad2856
2014-06-12 09:08:33 -04:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: getAnalogOutput
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (J)D
Added support for digital and analog IO pins on the MXP Change-Id: I3a4e14ceab885d19a615d6cd45f22a2250ad2856
2014-06-12 09:08:33 -04:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jdouble JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogOutput(
JNIEnv *env, jclass, jlong id) {
int32_t status = 0;
double val = getAnalogOutput((void *)id, &status);
CheckStatus(env, status);
return val;
Added support for digital and analog IO pins on the MXP Change-Id: I3a4e14ceab885d19a615d6cd45f22a2250ad2856
2014-06-12 09:08:33 -04:00
}
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: setAnalogSampleRate
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (D)V
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAnalogSampleRate(
JNIEnv *env, jclass, jdouble value) {
ANALOGJNI_LOG(logDEBUG) << "SampleRate = " << value;
int32_t status = 0;
setAnalogSampleRate(value, &status);
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: getAnalogSampleRate
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: ()D
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jdouble JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogSampleRate(
JNIEnv *env, jclass) {
int32_t status = 0;
double returnValue = getAnalogSampleRate(&status);
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
ANALOGJNI_LOG(logDEBUG) << "SampleRate = " << returnValue;
CheckStatus(env, status);
return returnValue;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: setAnalogAverageBits
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (JI)V
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAnalogAverageBits(
JNIEnv *env, jclass, jlong id, jint value) {
ANALOGJNI_LOG(logDEBUG) << "AverageBits = " << value;
ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
int32_t status = 0;
setAnalogAverageBits((void *)id, value, &status);
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: getAnalogAverageBits
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (J)I
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jint JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogAverageBits(
JNIEnv *env, jclass, jlong id) {
ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
int32_t status = 0;
jint returnValue = getAnalogAverageBits((void *)id, &status);
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
ANALOGJNI_LOG(logDEBUG) << "AverageBits = " << returnValue;
CheckStatus(env, status);
return returnValue;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: setAnalogOversampleBits
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (JI)V
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAnalogOversampleBits(
JNIEnv *env, jclass, jlong id, jint value) {
ANALOGJNI_LOG(logDEBUG) << "OversampleBits = " << value;
ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
int32_t status = 0;
setAnalogOversampleBits((void *)id, value, &status);
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: getAnalogOversampleBits
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (J)I
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jint JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogOversampleBits(
JNIEnv *env, jclass, jlong id) {
ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
int32_t status = 0;
jint returnValue = getAnalogOversampleBits((void *)id, &status);
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
ANALOGJNI_LOG(logDEBUG) << "OversampleBits = " << returnValue;
CheckStatus(env, status);
return returnValue;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: getAnalogValue
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (J)S
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jshort JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogValue(
JNIEnv *env, jclass, jlong id) {
// ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void*)id;
int32_t status = 0;
jshort returnValue = getAnalogValue((void *)id, &status);
// ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
// ANALOGJNI_LOG(logDEBUG) << "Value = " << returnValue;
CheckStatus(env, status);
return returnValue;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: getAnalogAverageValue
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (J)I
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jint JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogAverageValue(
JNIEnv *env, jclass, jlong id) {
ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
int32_t status = 0;
jint returnValue = getAnalogAverageValue((void *)id, &status);
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
ANALOGJNI_LOG(logDEBUG) << "AverageValue = " << returnValue;
CheckStatus(env, status);
return returnValue;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: getAnalogVoltsToValue
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (JD)I
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jint JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogVoltsToValue(
JNIEnv *env, jclass, jlong id, jdouble voltageValue) {
ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
ANALOGJNI_LOG(logDEBUG) << "VoltageValue = " << voltageValue;
int32_t status = 0;
jint returnValue = getAnalogVoltsToValue((void *)id, voltageValue, &status);
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
ANALOGJNI_LOG(logDEBUG) << "Value = " << returnValue;
CheckStatus(env, status);
return returnValue;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: getAnalogVoltage
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (J)D
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jdouble JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogVoltage(
JNIEnv *env, jclass, jlong id) {
// ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void*)id;
int32_t status = 0;
jdouble returnValue = getAnalogVoltage((void *)id, &status);
// ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
// ANALOGJNI_LOG(logDEBUG) << "Voltage = " << returnValue;
CheckStatus(env, status);
return returnValue;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: getAnalogAverageVoltage
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (J)D
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jdouble JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogAverageVoltage(
JNIEnv *env, jclass, jlong id) {
ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
int32_t status = 0;
jdouble returnValue = getAnalogAverageVoltage((void *)id, &status);
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
ANALOGJNI_LOG(logDEBUG) << "AverageVoltage = " << returnValue;
CheckStatus(env, status);
return returnValue;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: getAnalogLSBWeight
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (J)I
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jint JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogLSBWeight(
JNIEnv *env, jclass, jlong id) {
ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
int32_t status = 0;
Adds the Accumulator code to the AnalogJNI.cpp Disables the debug printlines from the AnalogJNI.cpp file Change-Id: Iac962721fb3eeca8f208feb162c96d5ae9f342a2
2014-05-20 15:38:41 -04:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
jint returnValue = getAnalogLSBWeight((void *)id, &status);
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
ANALOGJNI_LOG(logDEBUG) << "AnalogLSBWeight = " << returnValue;
CheckStatus(env, status);
return returnValue;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: getAnalogOffset
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (J)I
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jint JNICALL Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogOffset(
JNIEnv *env, jclass, jlong id) {
ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
int32_t status = 0;
Adds the Accumulator code to the AnalogJNI.cpp Disables the debug printlines from the AnalogJNI.cpp file Change-Id: Iac962721fb3eeca8f208feb162c96d5ae9f342a2
2014-05-20 15:38:41 -04:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
jint returnValue = getAnalogOffset((void *)id, &status);
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
ANALOGJNI_LOG(logDEBUG) << "AnalogOffset = " << returnValue;
CheckStatus(env, status);
return returnValue;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: isAccumulatorChannel
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (J)Z
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jboolean JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_isAccumulatorChannel(
JNIEnv *env, jclass, jlong id) {
ANALOGJNI_LOG(logDEBUG) << "isAccumulatorChannel";
ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
int32_t status = 0;
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
jboolean returnValue = isAccumulatorChannel((void *)id, &status);
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
ANALOGJNI_LOG(logDEBUG) << "AnalogOffset = " << returnValue;
CheckStatus(env, status);
return returnValue;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: initAccumulator
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (J)V
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT void JNICALL Java_edu_wpi_first_wpilibj_hal_AnalogJNI_initAccumulator(
JNIEnv *env, jclass, jlong id) {
ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
int32_t status = 0;
initAccumulator((void *)id, &status);
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: resetAccumulator
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (J)V
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_resetAccumulator(
JNIEnv *env, jclass, jlong id) {
ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
int32_t status = 0;
Adds the Accumulator code to the AnalogJNI.cpp Disables the debug printlines from the AnalogJNI.cpp file Change-Id: Iac962721fb3eeca8f208feb162c96d5ae9f342a2
2014-05-20 15:38:41 -04:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
resetAccumulator((void *)id, &status);
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: setAccumulatorCenter
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (JI)V
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAccumulatorCenter(
JNIEnv *env, jclass, jlong id, jint center) {
ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
int32_t status = 0;
Adds the Accumulator code to the AnalogJNI.cpp Disables the debug printlines from the AnalogJNI.cpp file Change-Id: Iac962721fb3eeca8f208feb162c96d5ae9f342a2
2014-05-20 15:38:41 -04:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
setAccumulatorCenter((void *)id, center, &status);
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: setAccumulatorDeadband
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (JI)V
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAccumulatorDeadband(
JNIEnv *env, jclass, jlong id, jint deadband) {
ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
int32_t status = 0;
Adds the Accumulator code to the AnalogJNI.cpp Disables the debug printlines from the AnalogJNI.cpp file Change-Id: Iac962721fb3eeca8f208feb162c96d5ae9f342a2
2014-05-20 15:38:41 -04:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
setAccumulatorDeadband((void *)id, deadband, &status);
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: getAccumulatorValue
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (J)J
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jlong JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAccumulatorValue(
JNIEnv *env, jclass, jlong id) {
ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
int32_t status = 0;
Adds the Accumulator code to the AnalogJNI.cpp Disables the debug printlines from the AnalogJNI.cpp file Change-Id: Iac962721fb3eeca8f208feb162c96d5ae9f342a2
2014-05-20 15:38:41 -04:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
jlong returnValue = getAccumulatorValue((void *)id, &status);
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
ANALOGJNI_LOG(logDEBUG) << "AccumulatorValue = " << returnValue;
CheckStatus(env, status);
Adds the Accumulator code to the AnalogJNI.cpp Disables the debug printlines from the AnalogJNI.cpp file Change-Id: Iac962721fb3eeca8f208feb162c96d5ae9f342a2
2014-05-20 15:38:41 -04:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
return returnValue;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: getAccumulatorCount
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (J)I
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jint JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAccumulatorCount(
JNIEnv *env, jclass, jlong id) {
ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
int32_t status = 0;
Adds the Accumulator code to the AnalogJNI.cpp Disables the debug printlines from the AnalogJNI.cpp file Change-Id: Iac962721fb3eeca8f208feb162c96d5ae9f342a2
2014-05-20 15:38:41 -04:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
jint returnValue = getAccumulatorCount((void *)id, &status);
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
ANALOGJNI_LOG(logDEBUG) << "AccumulatorCount = " << returnValue;
CheckStatus(env, status);
return returnValue;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: getAccumulatorOutput
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (JLjava/nio/LongBuffer;Ljava/nio/IntBuffer;)V
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAccumulatorOutput(
JNIEnv *env, jclass, jlong id, jobject value, jobject count) {
ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
int32_t status = 0;
Adds the Accumulator code to the AnalogJNI.cpp Disables the debug printlines from the AnalogJNI.cpp file Change-Id: Iac962721fb3eeca8f208feb162c96d5ae9f342a2
2014-05-20 15:38:41 -04:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
jlong *valuePtr = (jlong *)env->GetDirectBufferAddress(value);
uint32_t *countPtr = (uint32_t *)env->GetDirectBufferAddress(count);
Adds the Accumulator code to the AnalogJNI.cpp Disables the debug printlines from the AnalogJNI.cpp file Change-Id: Iac962721fb3eeca8f208feb162c96d5ae9f342a2
2014-05-20 15:38:41 -04:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
getAccumulatorOutput((void *)id, valuePtr, countPtr, &status);
Adds the Accumulator code to the AnalogJNI.cpp Disables the debug printlines from the AnalogJNI.cpp file Change-Id: Iac962721fb3eeca8f208feb162c96d5ae9f342a2
2014-05-20 15:38:41 -04:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
ANALOGJNI_LOG(logDEBUG) << "Value = " << *valuePtr;
ANALOGJNI_LOG(logDEBUG) << "Count = " << *countPtr;
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
CheckStatus(env, status);
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: initializeAnalogTrigger
Changes HAL Port from a pointer to a handle (#93) HAL Port is using a special handle, where the module and pin are bit shifted straight into the handle. This is one of the few special cases we have, but for the way port is used it is much cleaner and uses much less memory. Plus it is generic and not specific to one type.
2016-06-05 15:23:58 -07:00
* Signature: (ILjava/nio/IntBuffer;)J
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jlong JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_initializeAnalogTrigger(
Changes HAL Port from a pointer to a handle (#93) HAL Port is using a special handle, where the module and pin are bit shifted straight into the handle. This is one of the few special cases we have, but for the way port is used it is much cleaner and uses much less memory. Plus it is generic and not specific to one type.
2016-06-05 15:23:58 -07:00
JNIEnv *env, jclass, jint id, jobject index) {
ANALOGJNI_LOG(logDEBUG) << "Port Ptr = " << (HalPortHandle)id;
AnalogTrigger support in Java Analog triggers now work in Java. Integration tests for analog triggers are included. A message in the C++ analog trigger IT was fixed. Change-Id: I50007c6901b8391d32c0e81becdbe18e48a7840f
2014-08-01 12:39:19 -04:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
jint *indexPtr = (jint *)env->GetDirectBufferAddress(index);
ANALOGJNI_LOG(logDEBUG) << "Index Ptr = " << indexPtr;
AnalogTrigger support in Java Analog triggers now work in Java. Integration tests for analog triggers are included. A message in the C++ analog trigger IT was fixed. Change-Id: I50007c6901b8391d32c0e81becdbe18e48a7840f
2014-08-01 12:39:19 -04:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
int32_t status = 0;
void *analogTrigger =
Changes HAL Port from a pointer to a handle (#93) HAL Port is using a special handle, where the module and pin are bit shifted straight into the handle. This is one of the few special cases we have, but for the way port is used it is much cleaner and uses much less memory. Plus it is generic and not specific to one type.
2016-06-05 15:23:58 -07:00
initializeAnalogTrigger((HalPortHandle)id, (uint32_t *)indexPtr, &status);
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
ANALOGJNI_LOG(logDEBUG) << "AnalogTrigger Ptr = " << analogTrigger;
CheckStatus(env, status);
return (jlong)analogTrigger;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: cleanAnalogTrigger
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (J)V
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_cleanAnalogTrigger(
JNIEnv *env, jclass, jlong id) {
ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Ptr = " << (void *)id;
AnalogTrigger support in Java Analog triggers now work in Java. Integration tests for analog triggers are included. A message in the C++ analog trigger IT was fixed. Change-Id: I50007c6901b8391d32c0e81becdbe18e48a7840f
2014-08-01 12:39:19 -04:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
int32_t status = 0;
cleanAnalogTrigger((void *)id, &status);
CheckStatus(env, status);
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: setAnalogTriggerLimitsRaw
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (JII)V
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAnalogTriggerLimitsRaw(
JNIEnv *env, jclass, jlong id, jint lower, jint upper) {
ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Ptr = " << (void *)id;
AnalogTrigger support in Java Analog triggers now work in Java. Integration tests for analog triggers are included. A message in the C++ analog trigger IT was fixed. Change-Id: I50007c6901b8391d32c0e81becdbe18e48a7840f
2014-08-01 12:39:19 -04:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
int32_t status = 0;
setAnalogTriggerLimitsRaw((void *)id, lower, upper, &status);
CheckStatus(env, status);
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: setAnalogTriggerLimitsVoltage
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (JDD)V
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAnalogTriggerLimitsVoltage(
JNIEnv *env, jclass, jlong id, jdouble lower, jdouble upper) {
ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Ptr = " << (void *)id;
AnalogTrigger support in Java Analog triggers now work in Java. Integration tests for analog triggers are included. A message in the C++ analog trigger IT was fixed. Change-Id: I50007c6901b8391d32c0e81becdbe18e48a7840f
2014-08-01 12:39:19 -04:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
int32_t status = 0;
setAnalogTriggerLimitsVoltage((void *)id, lower, upper, &status);
CheckStatus(env, status);
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: setAnalogTriggerAveraged
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (JZ)V
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAnalogTriggerAveraged(
JNIEnv *env, jclass, jlong id, jboolean averaged) {
ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Ptr = " << (void *)id;
AnalogTrigger support in Java Analog triggers now work in Java. Integration tests for analog triggers are included. A message in the C++ analog trigger IT was fixed. Change-Id: I50007c6901b8391d32c0e81becdbe18e48a7840f
2014-08-01 12:39:19 -04:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
int32_t status = 0;
setAnalogTriggerAveraged((void *)id, averaged, &status);
CheckStatus(env, status);
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: setAnalogTriggerFiltered
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (JZ)V
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT void JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAnalogTriggerFiltered(
JNIEnv *env, jclass, jlong id, jboolean filtered) {
ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Ptr = " << (void *)id;
AnalogTrigger support in Java Analog triggers now work in Java. Integration tests for analog triggers are included. A message in the C++ analog trigger IT was fixed. Change-Id: I50007c6901b8391d32c0e81becdbe18e48a7840f
2014-08-01 12:39:19 -04:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
int32_t status = 0;
setAnalogTriggerFiltered((void *)id, filtered, &status);
CheckStatus(env, status);
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: getAnalogTriggerInWindow
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (J)Z
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jboolean JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogTriggerInWindow(
JNIEnv *env, jclass, jlong id) {
ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Ptr = " << (void *)id;
AnalogTrigger support in Java Analog triggers now work in Java. Integration tests for analog triggers are included. A message in the C++ analog trigger IT was fixed. Change-Id: I50007c6901b8391d32c0e81becdbe18e48a7840f
2014-08-01 12:39:19 -04:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
int32_t status = 0;
jboolean val = getAnalogTriggerInWindow((void *)id, &status);
CheckStatus(env, status);
return val;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: getAnalogTriggerTriggerState
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (J)Z
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jboolean JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogTriggerTriggerState(
JNIEnv *env, jclass, jlong id) {
ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Ptr = " << (void *)id;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
int32_t status = 0;
jboolean val = getAnalogTriggerTriggerState((void *)id, &status);
CheckStatus(env, status);
return val;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
/*
* Class: edu_wpi_first_wpilibj_hal_AnalogJNI
* Method: getAnalogTriggerOutput
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
* Signature: (JI)Z
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
*/
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
JNIEXPORT jboolean JNICALL
Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogTriggerOutput(
JNIEnv *env, jclass, jlong id, jint type) {
ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Ptr = " << (void *)id;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
Add format script which invokes clang-format on the C++ source code (#41) On Windows machines, clang-format.exe must be in the PATH environment variable.
2016-05-20 17:30:37 -07:00
int32_t status = 0;
jboolean val =
getAnalogTriggerOutput((void *)id, (AnalogTriggerType)type, &status);
CheckStatus(env, status);
return val;
JNI implementation for Java Normal vs
2014-01-06 09:27:51 -05:00
}
Simplify JNI interfaces. These changes both simplify the Java code and improve performance across the JNI boundary. This also fixes the AnalogCrossConnectTest by adding delays to setInterruptHigh() and setInterruptLow() to ensure the change in voltage has time to propagate and extends the timeouts in AbstractInterruptTest. Detailed changes: Hoisted status checks to C. This avoids the need to create direct byte buffers (expensive) and significantly simplifies the Java code. The C code now directly generates the exception or reports the error to the DS. The JVM pointer is now a global across the JNI, initialized by the OnLoad function, avoiding the need for some of the class-specific initializers to get this pointer for callbacks. Opaque pointers (such as ports) are now passed as long values rather than with a ByteBuffer wrapper. Added extern "C" to source files. This allows earlier detection of JNI definition mismatches to the Java source headers. Changed JNI signatures to more closely match HAL signatures (in particular, boolean is now universally used instead of byte for HAL bool, which cleans up mapping back and forth to 1/0 from true/false). Change-Id: I4ea0032cabb0871cd74106a3a70d947258c29d2d
2015-11-01 09:11:52 -08:00
} // extern "C"
Reference in New Issue Copy Permalink