TeamDev Support : Document List - JNIWrapper

Enabling Log4J in JNIWrapper

forum-admin@teamdev.com — Mon, 05 Oct 2009 09:44:42 GMT

Starting from version 3.8, JNIWrapper comes with SLF4J Loggin Facade. SLF4J supports multiple logging frameworks. We distribute JNIWrapper library with Simple implementation, which outputs all events to System.err. Only messages of level INFO and higher are printed. This binding may be useful in the context of small applications.

To enable Log4J in JNIWrapper please do the following steps:

1. Download the archive using the following link: http://www.slf4j.org/dist/slf4j-1.5.8.zip
2. From this archive copy the slf4j-log4j12-1.5.8.jar and add it to your application class path
3. Add the attached log4j.properties file to your application class path
4. Remove the slf4j-simple.jar from the application class path to disable default JNIWrapper logging

If you want to bind with other loggers, please refer to the SLF4J User Manual.

JNIWrapper Technical Questions and Answers

roman.kazmin@teamdev.com — Thu, 18 Dec 2008 18:46:06 GMT

Get answers to most commonly asked technical questions about JNIWrapper. If you can’t find the answer here, please send us your question using the support request form, and we will add it to this FAQ after answering you.

1. I developed my program on Windows XP (NT/2000) and it doesn’t run on Windows Me (95/98).
Answer: While JNIWrapper supports all versions of Windows operating systems, it is possible to invoke some OS-specific function or use a library that is not available on certain versions of Windows. For example, the SignalObjectAndWait function is not supported on Windows 95/98/Me. Therefore, if your program uses such a function, it will not run on the Windows versions that do not support it.

2. Can I write my own types for JNIWrapper?
Answer: Yes. The only thing you should do is extend the com.jniwrapper.Parameter class.

3. I heard that NIO introduced in version 1.4 provides better performance for accessing the native memory. Does JNIWrapper make use of NIO?
Answer: Yes, if the NIO package is available, JNIWrapper will use it.

4. I think that some safety checks are slowing down my program - can I disable them?
Answer: In version 1.4, NIO buffers perform range checks for all operations. We have found an underlying implementation class that can be used to access native memory without those checks. If your program accesses native data a lot, you can try to run it by defining the com.jniwrapper.useunsafe system property. This may give your program some extra performance. This option will not affect the programs running on J2SE version 1.3.

5. How can I further improve fail-safety of my program that uses JNIWrapper?
Answer: All function calls are already protected from access violations inside the native code, and those access violations are converted to Java exceptions. Under JDK 1.3.x, all memory accesses are protected in the same way, but this is not the case where NIO is used. Though NIO access is faster, it can lead to crashes with some ill-behaved libraries that return pointers to invalid memory locations. If your program interacts with such a library, you may want to switch the memory access behavior back to 1.3.x scheme by defining the com.jniwrapper.safemem system property. This option will have no effect on the programs running under JDK version 1.3.x.

6. Why does JNIWrapper for Linux require JRE 1.4.x?
Answer: To prevent failures caused by memory access violations on the native code side, JNIWrapper for Linux employs the signal-chaining feature that is available in JDK since version 1.4.
We consider developing a version that would run on JRE version 1.3.x if there is a demand for that. If you need such version, please send your requests to jniwrapper-support@teamdev.com

7. What should I not expect from JNIWrapper?
Answer: JNIWrapper provides means for calling native functions from libraries, but there are some things we cannot do at the moment. Here are the most remarkable cases:

JNIWrapper does not provide integration with C++ yet. This is planned for future versions. However, if you need to call a C function that takes a pointer to C++ object as a parameter, then it is possible to do that using JNIWrapper. You can operate with a C++ object using the Pointer.Void class. For example:

    // C++ class
    class A {
        public:
        A() {}
    }

// C function
void test(A* a);

// JNIWrapper function call
Function test = ...; // Pointer to C++ object

    // the object can be created on the native side
    // and then returned to Java via Pointer.Void
    Pointer.Void objectPtr = ...;
    test.invoke(null,& objectPtr);

There is no support for C++ exception handling.

These and many other features are planned for future versions. The order of their implementation will depend on the feedback we receive. If you need a certain feature, please contact us at jniwrapper-support@teamdev.com.

8. How do I use multi-dimensional arrays with JNIWrapper?
Answer: To use correct parameters and initialize them properly, you should understand the actual data structure that represents the array in question. There are two different cases of array storage in the C language: the linear storage and array of pointers to array (of pointers to array, etc.) of actual elements.
In the first case, all data is stored sequentially, so, for example, the element at [1][1] of a 3 by 3 array is stored at offset 1 * 3 + 1 = 4 from the base pointer. For such arrays, you should allocate a linear array big enough to hold all the elements and access the elements using an index calculation function that converts the multi-dimensional index to the linear index.
In the second case, the actual data is stored only in the "leaf" arrays and you have to allocate arrays of pointers to arrays of actual data. Make sure that you have all intermediate arrays allocated and pointing to the appropriate children. To access data in this case, you will have to get through all the intermediate arrays to the bottom level and access the required value from the bottommost array.
It is often quite easy to determine the storage type from the declaration: when all array dimensions (except probably the first one) are specified, the array is stored sequentially; otherwise, it is stored as "arrays of arrays".

For example:

float a[3][4][5], int b[][100] - sequential storage,
char argv[][], double points[][] - "arrays of arrays".

9. I am calling a function with correct parameters, but keep getting an exception about incorrect parameter types.
Answer: Please verify that you are using the correct calling convention. The defaults are: stdcall for Windows as it is used by most of the Windows API, and cdecl for Linux - it is used by almost all libraries.

10. Where can I find a reference containing a one-to-one mapping of your Parameter classes with their relevant C data types?
Answer: Please check the JNIWrapper documentation (Programmer’s Guide). The quick reference with additional comments is also available online.

11. I get the following error: ciceroUIWNDFRAME: javaw.exe - apllication error
Answer: This error is not caused by JNIWrapper, but rather by Microsoft Office's Speech and Handwriting Recognition. In order to continue using JNIWrapper, you will need to disable this Microsoft feature. To disable the Speech and Handwriting Recognition:

Click "Start" button at the bottom left of Microsoft Windows.
Click "Control Panel."
Click "Add/Remove Programs."
Click "Microsoft Office."
Click on the "Change" button
Browse to "Office Shared Features."
Click on "Alternative User Input."
For both the Speech and Handwriting Recognition, select "Not available."

Once this is disabled, the CiceroUIWndFrame messages disappear. Also, please check this Microsoft support site for a more detailed set of steps to remove these tools: http://support.microsoft.com/default.aspx?scid=kb;%5BLN%5D;326526.

12. JNIWrapper fails to start and throws UnsatisfiedLinkError: "java.lang.UnsatisfiedLinkError: Cannot find JNIWrapper native library in java.library.path." even though jniwrap64.dll is installed correctly.
Answer: 64-bit version of JNIWrapper library (jniwrap64.dll) requires MSVCR80.dll runtime library to be installed in the system.

13. JNIWrapper native library fails to load on my Linux station. How can I find out why?
Answer: You need to check the presence of required system libraries and their versions. To do it, run the ld utility with a full path to the JNIWrapper native library as its parameter. If some required libraries are missing, you can build the JNIWrapper library from object files available on our site (http://www.teamdev.com/downloads/jniwrapper/jniwrapper-3.7-obj.tar.bz2).

To build the JNIWrapper native library, unpack the contents of the downloaded archive and run build.sh script from the appropriate subfolder. Make sure you have the gcc package installed.

14. Which Java version do you recommend to use with JNIWrapper and your other products?
Answer: You can use any Java version starting from 1.4.
If you use Java 1.5, we recommend updating to version 1.5.0_06.

15. I would like to invoke code from a DLL that I generated with C#. Can I do it with JNI Wrapper, and if possible how? [new]

Answer: JNIWrapper is not designed for integration with .NET libraries which are created on C# or any other .NET programming language. In fact such libraries have architecture which completely differs from conventional Win32 DLL libraries.

Nevertheless it is possible to integrate with a .NET library, but only if this library provides COM Interop level. In this case you can use our ComfyJ product.

16. How I can distribute my native library or jniwrap.dll/dylib/jnilib files with my application? [new]

Answer: The simplest way to deploy native libraries (and it’s applicable for all supported platforms) is to put these native libraries to any JAR file, which is included into class path of your application. This could be JNIWrapper JAR file as well. In this case JNIWrapper itself will take care of finding and loading the corresponding native library at runtime. The main requirement is that all native libraries should reside in a root folder of a JAR file.

Logging in JNIWrapper

roman.kazmin@teamdev.com — Fri, 11 Sep 2009 12:42:56 GMT

If you want to bind with other loggers, please refer to the SLF4J User Manual.

JNIWrapper Installation Instructions

roman.kazmin@teamdev.com — Fri, 19 Dec 2008 10:24:31 GMT

Installing Library JAR File

JNIWrapper JAR file should be on the program's class path. Library file can be also placed on the boot class path or in the extension directory of Java runtime, but this is not required.

Installing Native Code Library

JNIWrapper native DLL can be placed virtually anywhere. Its actual location should take into account that Java code must find the DLL to load. It can be placed somewhere within program's library search path. Users can add search path to the default library loader used by JNIWrapper or even write a custom one that searches for native code in a predefined location. Since JNIWrapper v3.0 native libraries can be put into any jar library from the application's classpath (but not into the META-INF folder).

Windows

Certain users may like to install the native DLL into the directories on the default system path (e.g. Windows root or Windows\System32) – this requires adequate rights on NT/2000/XP systems. Installing native DLL this way may be convenient, but is not required.

Linux32

JNIWrapper native library libjniwrap.so can be placed into a system directory from the system path (e.g. /lib or /usr/lib). You can also specify custom library path using the LD_LIBRARY_PATH environement variable. System library paths are listed in the /etc/ld.so.conf file.

Linux64

JNIWrapper native library libjniwrap.so can be placed into a system directory from the system path (e.g. /lib64 or /usr/lib64). You can also specify custom library path using the LD_LIBRARY_PATH environement variable. System library paths are listed in the /etc/ld.so.conf file.

MacOS X

JNIWrapper native library libjniwrap.jnilib can be placed into the system directory /usr/lib. You can also specify custom library path using the LD_LIBRARY_PATH environement variable. System library paths are listed in the /etc/ld.so.conf file.

Solaris32

Solaris64

AIX

Installing License File

License file is not the part of this package. It has to be obtained separately.

Visit TeamDev site (http://www.teamdev.com) to purchase the product or get an evaluation license.

License file has to be installed in the same directory as the native code library or in the META-INF subfolder of any jar library from the application's classpath.

Warning: Do NOT rename the license file or it will not be recognized.

Mapping Native Types to JNIWrapper Classes

roman.kazmin@teamdev.com — Thu, 05 Feb 2009 14:00:11 GMT

Please find below the mappings table for most commonly used data types along with some comments.

Native Type (C/C++)	JNIWrapper Type	Comments
Boolean Types
bool	Bool(1 byte), IntBool(4 bytes)
Character Types
char	Char
wchar_t	WideChar
uchar *	Char, UInt8
Integer Types
short	ShortInt	The unsigned types are represented by prepending U to the type name, e.g. unsigned int (or unsigned) type is UInt. There are also types for predefined-width integers: Int8, Int16, Int32 and Int64, they also have the unsigned variants.
int	Int
long	LongInt
Floating-point Types
float	SingleFloat
double	DoubleFloat
long double	LongDouble	Long double is the same as double (8-byte floating-point value) on win32 platform.
Pointer Types (not arrays)
void *	Pointer.Void
const	Pointer.Const	Use Pointer.Const if the referenced object is not to be modified by the calling function.
type *	Pointer	To create a pointer to the value (variable) of a known type, use the Pointer class. For example: int *i; is Pointer i = new Pointer(new Int());
type *	Pointer.OutOnly	Use Pointer.OutOnly if the referenced value is not read by the calling function.
char *	AnsiString
wchar_t *	WideString
Arrays
<c primitive type>[n]	PrimitiveArray(<corresponding JNIWrapper type>.class, n);	For example: int i[10]; is PrimitiveArray i = new PrimitiveArray(Int.class, 10);
Structures and Unions
struct	Structure
union	Union
Function Pointers
To create an object callable from the native code use the Callback class. To call a function returned from the native code use the method asFunction of the Pointer.Void class.

Windows API includes many data types that are not listed here (for example, DWORD, HANDLE). If you need to use one of such types, read Windows-specific documentation such as MSDN to find out the actual C type that corresponds to it (for example, LPSTR corresponds to char*) and use the relevant JNIWrapper type for the argument. You can also check the Windows Data Types table that we have created for your reference.

Mapping Windows Data Types

roman.kazmin@teamdev.com — Thu, 05 Feb 2009 14:04:35 GMT

Notes

Most pointer-type names begin with the prefix P or LP.
Handles refer to a resource that has been loaded into the memory.
Certain types may allow parameter representations different from the ones specified here.
Pointers to simple types may need to be represented as arrays of those types.
Representation of the Unicode-aware types such as LPTSTR or TCHAR depends on the actual type of the called function: use WideString (WideChar) when calling Unicode function version and AnsiString (Char) when calling ANSI version.
Most Unicode versions of functions end with "W", and ANSI functions normally end with "A".

Data Types

Windows Type	JNIWrapper Type	WinPack Type
ATOM	Int16	Int16
BOOL	Int	Int
BOOLEAN	Bool	Bool
BYTE	Int8	Int8
CHAR	Char	Char
COLORREF	ULongInt	ColorRef
CRITICAL_SECTION	Structure, see Windows documentation for member list	Structure, see Windows documentation for member list
DWORD	UInt32	UInt32
DWORD_PTR	UInt32, Pointer.Void	UInt32, Pointer.Void
DWORD32	UInt32	UInt32
FLOAT	SingleFloat	SingleFloat
HACCEL	Pointer.Void	Handle
HANDLE	Pointer.Void	Handle
HBITMAP	Pointer.Void	Bitmap
HBRUSH	Pointer.Void	Brush
HCONV	Pointer.Void	Handle
HCONVLIST	Pointer.Void	Handle
HCURSOR	Pointer.Void	Cursor
HDC	Pointer.Void	DC
HDDEDATA	Pointer.Void	Handle
HDESK	Pointer.Void	Handle
HDROP	Pointer.Void	Handle
HDWP	Pointer.Void	Handle
HENHMETAFILE	Pointer.Void	Handle
HFILE	Pointer.Void	Handle
HFONT	Pointer.Void	Font
HGDIOBJ	Pointer.Void	GdiObject
HGLOBAL	Pointer.Void	Handle
HHOOK	Pointer.Void	Handle
HICON	Pointer.Void	Icon
HIMAGELIST	Pointer.Void	Handle
HIMC	Pointer.Void	Handle
HINSTANCE	Pointer.Void	Handle
HKEY	Pointer.Void	Handle
HKL	Pointer.Void	Handle
HLOCAL	Pointer.Void	Handle
HMENU	Pointer.Void	Handle
HMETAFILE	Pointer.Void	Handle
HMODULE	Pointer.Void	Module
HMONITOR	Pointer.Void	Handle
HPALETTE	Pointer.Void	Handle
HPEN	Pointer.Void	Handle
HRGN	Pointer.Void	Region
HRSRC	Pointer.Void	Handle
HSZ	Pointer.Void	Handle
HWINSTA	Pointer.Void	Handle
HWND	Pointer.Void	Wnd
INT	Int32	Int32
INT_PTR	Int32	Int32
INT32	Int32	Int32
INT64	Int64	Int64
LANGID	UInt16	UInt16
LCID	UInt32	LocaleID
LCTYPE	UInt32	UInt32
LONG	Int32	Int32
LONG_PTR	Int32	Int32
LONG32	Int32	Int32
LONG64	Int64	Int64
LONGLONG	Int64	Int64
LPARAM	Int32	Int32
LPBOOL	Pointer(Int)	Pointer(Int)
LPBYTE	Pointer(Int8)	Pointer(Int8)
LPCOLORREF	Pointer(ULongInt)	Pointer(ColorRef)
LPCRITICAL_SECTION	Pointer(Structure), see Windows documentation for member list	Pointer(Structure), see Windows documentation for member list
LPCSTR	Pointer(AnsiString)	Pointer(AnsiString)
LPCTSTR	Str	Str
LPCVOID	Pointer.Void	Pointer.Void
LPCWSTR	Pointer(WideString)	Pointer(WideString)
LPDWORD	Pointer(UInt32)	Pointer(UInt32)
LPHANDLE	Pointer(Pointer.Void)	Pointer(Handle)
LPINT	Pointer(Int)	Pointer(Int)
LPLONG	Pointer(LongInt)	Pointer(LongInt)
LPSTR	Pointer(AnsiString)	Pointer(AnsiString)
LPTSTR	Str	Str
LPVOID	Pointer.Void	Handle
LPWORD	Pointer(UInt16)	Pointer(UInt16)
LPWSTR	Pointer(WideString)	Pointer(WideString)
LRESULT	Int32	Int32
LUID	Structure, see Windows documentation for member list	Structure, see Windows documentation for member list
PBOOL	Pointer(Int)	Pointer(Int)
PBOOLEAN	Pointer(Bool)	Pointer(Bool)
PBYTE	Pointer(Int8)	Pointer(Int8)
PCHAR	Pointer(Char), Pointer(AnsiString)	Pointer(Char), Pointer(AnsiString)
PCRITICAL_SECTION	Pointer(Structure), see Windows documentation for member list	Pointer(Structure), see Windows documentation for member list
PCSTR	Pointer(AnsiString)	Pointer(AnsiString)
PCTSTR	Str	Str
PCWCH	Str	Str
PCWSTR	Pointer(WideString)	Pointer(WideString)
PDWORD	Pointer(UInt32)	Pointer(UInt32)
PFLOAT Pointer(SingleFloat)	Pointer(SingleFloat)
PHANDLE	Pointer(Pointer.Void)	Pointer(Handle)
PHKEY	Pointer(Pointer.Void)	Pointer(Handle)
PINT	Pointer(Int)	Pointer(Int)
PLCID	Pointer(UInt32)	Pointer(UInt32)
PLONG	Pointer(LongInt)	Pointer(LongInt)
PLUID	Pointer(Structure), see Windows documentation for member list	Pointer(Structure), see Windows documentation for member list
PSHORT	Pointer(ShortInt)	Pointer(ShortInt)
PSTR	Pointer(AnsiString)	Pointer(AnsiString)
PTBYTE	Str	Str
PTCHAR	Str	Str
PUCHAR	Pointer(Char)	Pointer(Char)
PUINT	Pointer(UInt)	Pointer(UInt)
PULONG	Pointer(ULongInt)	Pointer(ULongInt)
PUSHORT	Pointer(UShortInt)	Pointer(UShortInt)
PVOID	Pointer.Void	Handle
PWCHAR	Str	Str
PWORD	Pointer(UInt16)	Pointer(UInt16)
PWSTR	Pointer(WideString)	Pointer(WideString)
REGSAM	UInt32	UInt32
SC_HANDLE	Pointer.Void	Handle
SC_LOCK	Pointer.Void	Handle
SERVICE_STATUS_HANDLE	Pointer.Void	Handle
SHORT	ShortInt	ShortInt
SIZE_T	ULongInt	ULongInt
SSIZE_T	LongInt	LontInt
TBYTE	Char or WideChar	Char or WideChar
TCHAR	Char or WideChar	Char or WideChar
UCHAR	Char	Char
UINT	UInt	UInt
UINT_PTR	UInt	UInt
UINT32	UInt32	UInt32
ULONG	ULongInt	ULongInt
ULONG_PTR	ULongInt	ULongInt
ULONG32	UInt32	UInt32
ULONG64	Int64	Int64
ULONGLONG	Int64	Int64
USHORT	UShortInt	UShortInt
WCHAR	WideChar	WideChar
WINAPI	Indicates stdcall calling convention	Indicates stdcall calling convention
WORD	UInt16	UInt16
WPARAM	UInt	UInt

JNIWrapper Troubleshooting

roman.kazmin@teamdev.com — Fri, 19 Dec 2008 09:58:35 GMT

1. A valid license is installed, but JNIWrapper does not load displaying the message "Your license is not valid" [new]
Cause: The license file is not installed in the same directory with the native code library or its name is incorrect. The license file should be named jniwrap.lic and located in the same directory as the JNIWrapper native library (jniwrap.dll on Win32 or libjniwrap.so on Linux). If any of these conditions is not met, JNIWrapper will be unable to find the license file.

Solution: Make sure that the license file is named and placed properly.

2. Exception UnsatisfiedLinkError: jniwrap is thrown
Cause: Default library loader cannot find the JNIWrapper native library (jniwrap.dll or libjniwrap.so depending on the platform). The library loader specified by Library.setDefaultLibraryLoader() or DefaultLibraryLoader cannot locate the native code library. Remember that JNIWrapper looks for its native code using the default library loader, so it has to be configured properly.

Solution: Place the native library and the license file into a directory on your library loader search path or add the directory where the JNIWrapper native library resides to the library loader search path.

3. DefaultLibraryLoader cannot load a library on the system library search path
Cause: The value of java.library.path system property is redefined on the program startup. In this case, it is not initialized using the system library search path (PATH on Win32 or LD_LIBRARY_PATH on Linux).

Solution 1: Do not set java.library.path property, add extra search directories using DefaultLibraryLoader.addPath() method.

Solution 2: Add the value of system PATH (LD_LIBRARY_PATH on Linux) variable to the value assigned to java.library.path. For example, with the batch file use the following construct:

java -Djava.library.path=%PATH%;<additional path entries> ...

JNIWrapper Licensing Questions and Answers

roman.kazmin@teamdev.com — Fri, 19 Dec 2008 09:48:18 GMT

Get answers to most commonly asked questions about JNIWrapper licensing. If you can’t find the answer here, please send us your question using the support request form, and we will add it to this FAQ after answering you.

1. What are the general terms of JNIWrapper License Agreement?
Answer: The complete License Agreement for JNIWrapper can be found here. If you have any questions regarding the Licensing Agreement, please e-mail us at info@teamdev.com.

2. How is JNIWrapper licensed?
Answer: We offer two types of licenses for JNIWrapper, and you get them both when you purchase it:

The Development License grants you the right to use JNIWrapper on one computer for solely development purposes.
The Redistribution License grants you the right to embed JNIWrapper run-time in your product or system, and redistribute that product or system to an unlimited number of computers without any further royalties to TeamDev.

For more details, please read the complete License Agreement for JNIWrapper.

3. What is the difference between the Standard and Personal licensing schemes? [new]
Answer: The main difference is that in the Personal license, no company name is mentioned, while in Standard one only the company name is specified. Additionally, the Personal license is single-user only. The Standard license can be multiple-user. There is no difference in the product functionality between the two licensing schemes.

4. Do I need a JNIWrapper license for each developer working on a software project?
Answer: The license is required for each developer who uses the JNIWrapper libraries. It is in violation of the License Agreement to purchase fewer Development Licenses than the actual number of developers using JNIWrapper. For more information about purchasing additional licenses, please e-mail to sales@teamdev.com.

5. On a 5-developer project I'm the only programmer who works on the native platform integration. Other developers would not use your product directly. How many licenses should we purchase?
Answer: The number of licenses should be obtained for developers who directly use JNIWrapper. That is, they program using our libraries' API. If other developers on your team neither work with API directly, nor modify the code that works with our API, only one license should be purchased.

6. Do I need any additional licenses to support the execution of unit test cases on the build machines or on other (non-UI) developers’ desktops?
Answer: When you purchase JNIWrapper, you get:

Development license key(s) to distribute among developers working directly with our library, and
Runtime license key(s) to use for redistribution and on any other environment where no development takes place.

Therefore, for the build environment and test execution, you can use the runtime key.

7. Are there any runtime licensing fees for applications built using JNIWrapper?
Answer: There are no runtime licensing fees, and there are no restrictions on the number of products that you can create using JNIWrapper, nor are there any restrictions on the number of end users that you may redistribute your software to.

8. Do I have to include a TeamDev copyright message in my software?
Answer: According to the terms of the License Agreement, it is not required for you to place a TeamDev copyright message in your software or documentation. However, if you would like to acknowledge the use of JNIWrapper in your product, you can do so by inserting a notice like this in the About dialog box or documentation: This software uses JNIWrapper™, licensed from TeamDev.We certainly appreciate your attribution and would like to learn about application of JNIWrapper in your software. E-mail us at info@teamdev.com and tell us how our products helped you.

9. Are there any limitations on using JNIWrapper with an evaluation license?
Answer: The evaluation version of JNIWrapper is fully functional. The code developed during the evaluation period can be compiled and used once you have purchased the software. However, there is a general limitation to consider when developing software using the evaluation license. After the evaluation period has expired, the application using JNIWrapper will no longer function correctly. Once you have purchased a license, you only need to place it instead of the evaluation license, as specified in the documentation. You can then redistribute your software along with JNIWrapper.

10. How do I check how much time remains in the evaluation period?
Answer: You can check the remaining time by opening your license file in any text editor or viewer and finding the date in the 4th line under your company/personal name. The date indicates the last day of your JNIWrapper evaluation period in DD-MM-YYYY format.

11. Do I have to re-download JNIWrapper once I have purchased the license after evaluation?
Answer: No, you may continue using JNIWrapper that you have previously downloaded from the TeamDev site. However, we recommend you to check for the version updates.

12. How can I ship several runtime license files with my application?
Answer: Name additional license files as follows: jniwrap.lic1, jniwrap.lic2, etc. JNIWrapper will look through those files while searching for valid licenses.

JNIWrapper General Questions and Answers

roman.kazmin@teamdev.com — Thu, 18 Dec 2008 13:25:45 GMT

Get answers to commonly asked general questions about JNIWrapper. If you don’t find the answer, send us your question using the support request form, and we will add it to this FAQ after answering you.

1. What is JNIWrapper?
Answer: JNIWrapper is a library that allows calling native functions directly from Java code.

2. Java provides so many features - why would I need native functions?
Answer: Some platform-dependent features, such as Windows registry, are not accessible through the Java API. You may also have some legacy software available in the form of a native library that you need to access. JNIWrapper makes it possible.

3. What Java versions are supported?
Answer: Officially, J2SE versions 1.3.x, 1.4.x and Java 5 are supported. We develop and test JNIWrapper using these versions of Java. However, JNIWrapper for Linux requires JRE 1.4.x. Why?

4. Will a program that uses JNIWrapper run on any platform?
Answer: It depends on how you are planning to use JNIWrapper and for what purposes. Essentially, a program that uses Java Native Interface (JNI) is not a true cross-platform one, because it employs platform-dependent native code. JNIWrapper is no exception. Currently, there are Windows, Mac OS and Linux versions of JNIWrapper, therefore the code that uses JNIWrapper can run on Windows, Windowsx64, Mac OS X and Linux platforms.

In your program, you can have a platform detection logic that would allow doing things differently depending on a platform where your code is running. For example, you may want your program to display a tray icon, when running on Windows, but under other platforms and windowing systems, your program would behave differently. As a result, your program will run on multiple platforms.

5. What about support for other platforms apart from Win32, Mac OS X and Linux?
Answer: We are planning to add support for more platforms in the future. We have in mind more Unix ports, like Solaris, HP-UX, etc. But terms and availability of these ports will mostly depend on user feedback that we receive.

6. What is your upgrade policy? [updated]
Answer: When you buy a license for JNIWrapper or any other TeamDev product, you are guaranteed to get free upgrades for all versions with the same major version number. That is, if you bought JNIWrapper version 2.0, you can get free upgrades for all 2.x versions. The same applies to 3.x. version upgrades. Upgrading from 2.x to 3.x version requires payment. However, you can upgrade to the next major version at no cost within 60 days from the date of purchase of any product version.

To upgrade your version of JNIWrapper, please use the online upgrade form on the Download or Purchase pages.

7. I have JNIWrapper for Windows. Are there any discounts if I want to buy JNIWrapper for Linux? [new]
Answer: Yes. We offer our customers a 15% discount for all TeamDev products. So if, for example, you purchased JNIWrapper, you can get any other of our products at a discount price using personal coupon code. You will receive this coupon code in the e-mail message along with your purchased product license(s). In order to buy at a discount, simply enter your personal coupon code in the online order form for the product you want.

If, for some reason, you don’t have your personal coupon code or have lost it, please contact our sales department at sales@teamdev.com.

8. I want to buy multiple licenses for JNIWrapper. Do you provide any volume discounts? [new]
Answer: Yes. If you wish to purchase a large number of licenses, you can do so at volume discounts. Price breaks start at five licenses, and the more you buy the bigger discounts you receive. To learn about volume price quotation, please contact our sales department at sales@teamdev.com.

What’s more, if you are already our customer, you can save even more when making a volume purchase using our 15% customer discount.

9. We are considering an update of JNIWrapper 2.9.5 to 3.0, but it seems that the codegen utility has changed completely. Was the old functionality that generated Java wrappers removed? [new]
Answer: All COM-related functionality is available as a separate product called ComfyJ.

The Codegen.bat found in JNIWrapper 3.0 distribution is designed for creating wrappers for C-types like structures, unions, callbacks etc. And the 'old' version of code generation utility can be found in ComfyJ 2.0 distribution.

10. We have upgraded to JNIWrapper 3.0. Can we no longer work with our OLE Adobe Acrobat Reader (which we generated with JNIWrapper 2.9.5) using JNIWrapper 3.0? Should we purchase a license for ComfyJ 2.0 as well? [updated]
Answer: Yes, in order to use COM functionality you will need ComfyJ 2.0 library.

However, being our customer entitles you to purchase ComfyJ at a 15% discount.

11. Do you use JNIWrapper yourself?
Answer: Yes. We successfully used JNIWrapper technology in several projects both for accessing platform-specific features and for legacy code integration. It appeared to be so useful to us that we decided to offer it as a commercial product. Currently, we continue using JNIWrapper and have big plans regarding its further development.