jNative Howto

最新推荐文章于 2016-03-18 09:06:48 发布
最新推荐文章于 2016-03-18 09:06:48 发布
阅读量791 收藏
点赞数
文章标签： callback documentation structure parameters null class

JNative Howto

Saturday 3 June 2006.
 

By the same authors

In the same section

In the same section
This article describe how to use JNative

Requirements

  First you need to have [1]:

  Unzip the jnative archive you’ve just downloaded and you obtain at least 2 or 3 files :

  • JNative.jar : this is the java side suitable for all platforms with Java5,
  • JNative.dll : this is the Win32 native side for W2K/XP/2003,
  • libjnative.so : this is the Linux native side.

You have to add JNative.jar in your classpath, see in Eclipse the menu Project|Properties|Java Build Path|Libraries, click onAdd External JARs... and choose JNative.jar.

  For Windows users :JNative.dll must be in the path, so put it in thecurrent directory or in C:\Windows orC:\Windows\System32 (assuming that your Windows is installed in C:\Windows, can also be in C:\WINNT)

  For linux users :libjnative.so can be in your /usr/lib directory, in the i386 directory of your jre/lib, or you can add to the shell launching your application :


export LD_LIBRARY_PATH=/path/to/your/directory

You need to have the documentation of the library so you know what are the parameters and return value of a function.

I, now describe an example, you’ll need the documentation, get ithere this sample will demonstrate the use of the Color dialog (you can get the white paperhere)

We will implement the ChooseColor function we will also need the documentation of theCHOOSECOLOR structure

Structure handling

  First we need to implement the structure. Basically you have 2 ways to do this :

  • Dirty : you need one call and do not use all the members of the struct,
  • Clean : you create a library, your code must be reusable, you have 5 minutes to do it,I’ll elaborate theclean way as it is the recommanded one.

Let’s consider this structure :

typedef struct {
   DWORD lStructSize;
   HWND hwndOwner;
   HWND hInstance;
   COLORREF rgbResult;
   COLORREF *lpCustColors;
   DWORD Flags;
   LPARAM lCustData;
   LPCCHOOKPROC lpfnHook;
   LPCTSTR lpTemplateName;
} CHOOSECOLOR, *LPCHOOSECOLOR;

We need to know the size of each elements, some of them are already known by JNative [3], for the others you’ll have to find them by yourself (remember that a pointer has a size of 4 bytes).

TypeLength [4]JNative class
DWORD4org.xvolks.jnative.misc.basicStructures.LONG
HWND4org.xvolks.jnative.misc.basicStructures.HWND
COLORREF [MSDN1]4org.xvolks.jnative.misc.basicStructures.LONG
COLORREF* [MSDN1]4org.xvolks.jnative.pointers.Pointer
LPARAM4org.xvolks.jnative.misc.basicStructures.LPARAM
LPCCHOOKPROC [MSDN2]4org.xvolks.jnative.util.Callback
LPCTSTR4org.xvolks.jnative.pointers.Pointer

So, now we know the size of CHOOSECOLOR structure :
  2 * DWORD + 2 * HWND + 2 * COLORDEF + LPARAM + LPCCHOOKPROC + LPCTSTR = 2*4 + 2*4 + 2*4 + 4 + 4 + 4 = 36 bytes.

we have to implement org.xvolks.jnative.pointers.AbstractBasicData so our new class will be easy to use.

AbstractBasicData is a Generic class that return an instance of your data, we are now creating aChooseColor structure, with your IDE create a new class extending AbstractBasicData called ChooseColor:


package org.xvolks.jnative.misc;

import org.xvolks.jnative.exceptions.NativeException;
import org.xvolks.jnative.misc.basicStructures.AbstractBasicData;
import org.xvolks.jnative.pointers.Pointer;

public class ChooseColor extends AbstractBasicData<ChooseColor> {

        protected ChooseColor(ChooseColor lValue) {
                super(null);
                mValue = this;
        }

        public ChooseColor getValueFromPointer() throws NativeException {
                // TODO Auto-generated method stub
                return null;
        }

        public int getSizeOf() {
                // TODO Auto-generated method stub
                return 0;
        }

        public Pointer createPointer() throws NativeException {
                // TODO Auto-generated method stub
                return null;
        }
}

Modify this file to suit your needs:
  Add the data members:


import org.xvolks.jnative.misc.basicStructures.*;
   
   ....

   LONG lStructSize;
   HWND hwndOwner;
   HWND hInstance;
   //This one is public because it's the return value; I should have created a getter
   public LONG rgbResult;
   static Pointer lpCustColors;
   LONG Flags;
   LPARAM lCustData;
   int lpfnHook;
   Callback fnHook;
   String lpTemplateName;

   static {
           try {
                        lpCustColors = new Pointer(MemoryBlockFactory.createMemoryBlock(16));
                } catch (NativeException e) {
                        e.printStackTrace();
                        throw new RuntimeException(e);
                }           
   }

  The getSizoOf() method :


        /**
         * This method returns 36 always (it's the size of CHOOSECOLOR struct)
         * @returns 36
         */
        @Override
        public int getSizeOf() {
                return 36;
        }

  The createPointer() method :


        public Pointer createPointer() throws NativeException {
                pointer = new Pointer(new GlobalMemoryBlock(getSizeOf()));
                pointer.setIntAt(0, getSizeOf());
                pointer.setIntAt(16, lpCustColors.getPointer());
                return pointer;
        }

  The getValueFromPointer() method :


        public ChooseColor getValueFromPointer() throws NativeException {
                offset = 0;
                lStructSize = new LONG(getNextInt());
                hwndOwner = new HWND(getNextInt());
                hInstance = new HWND(getNextInt());
                rgbResult = new LONG(getNextInt());
                //Skip lpCustColor
                offset += 4;
                Flags = new LONG(getNextInt());
                lCustData = new LPARAM(getNextInt());
                //Skip callback
                return getValue();
        }

  Create helper methods to manipulate callbacks :


        public void removeCallback() throws NativeException {
                if(fnHook != null) {
                        JNative.releaseCallback(fnHook);
                        fnHook = null;
                }
        }
        public void addCallback(Callback lCallback) throws NativeException {
                removeCallback();
                fnHook = lCallback;
                //The callback object must handle 4 parameters from
                //CCHookProc(HWND hdlg, UINT uiMsg, WPARAM wParam, LPARAM lParam)
                lpfnHook = JNative.createCallback(4, lCallback);
                pointer.setIntAt(28, lpfnHook);
        }

  Create setters to manipulate data, they will fill the structure :


        ...

        public void setOwner(HWND owner) throws NativeException {
                hwndOwner = owner;
                pointer.setIntAt(4, hwndOwner.getValue());
        }

        public void setInstance(HWND instance) throws NativeException {
                hInstance = instance;
                pointer.setIntAt(8, hInstance.getValue());
        }

        ...

Function call

As we start to implement comdlg32.dll we have to create a class named ComDlg32 to handle its functions.

So create ComDlg32 class in org.xvolks.jnative.util package.


package org.xvolks.jnative.util;

import org.xvolks.jnative.JNative;
import org.xvolks.jnative.Type;
import org.xvolks.jnative.exceptions.NativeException;
import org.xvolks.jnative.misc.ChooseColor;
import org.xvolks.jnative.misc.basicStructures.HWND;
import org.xvolks.jnative.misc.basicStructures.LONG;
import org.xvolks.jnative.misc.basicStructures.LPARAM;

public class ComDlg32 {
        public static final String DLL_NAME = "COMDLG32.DLL";

        //Cache the JNative object between calls.
        private static JNative nChooseColor;
       
        /**
         *
         * @param lOwner
         * @param hInstance
         * @param Flags
         * @param lCustData
         * @param lCallback
         * @param lTemplateName
         * @return -1 if the use does not click on OK button, the RGB value else.
         * @throws NativeException
         * @throws IllegalAccessException
         */
        public static int ChooseColor(HWND lOwner, HWND hInstance, LONG Flags, LPARAM lCustData, Callback lCallback, String lTemplateName) throws NativeException, IllegalAccessException {
                if(nChooseColor == null) {
                        //JNative uses ANSI version ChooseColorA vs ChooseColorW
                        nChooseColor = new JNative(DLL_NAME, "ChooseColorA");
                        //BOOL is in fact an INT
                        nChooseColor.setRetVal(Type.INT);
                }
                ChooseColor nChooseColorStruct = new ChooseColor();
                nChooseColorStruct.setOwner(lOwner);
                nChooseColorStruct.setInstance(hInstance);
                nChooseColorStruct.setFlags(Flags);
                nChooseColorStruct.setCustData(lCustData);
                nChooseColorStruct.addCallback(lCallback);
                nChooseColorStruct.setTemplateName(lTemplateName);
               
                nChooseColor.setParameter(0, nChooseColorStruct.getPointer());
                nChooseColor.invoke();
                if("0".equals(nChooseColor.getRetVal())) {
                        return -1;
                } else {
                        return nChooseColorStruct.getValueFromPointer().rgbResult.getValue();
                }
        }
}

Conclusion

The callback implementation is missing you’ll have to create it yourself, see the EnumWindows sample in the sources.

  The full source of ChooseColor class


package org.xvolks.jnative.misc;

import org.xvolks.jnative.JNative;
import org.xvolks.jnative.exceptions.NativeException;
import org.xvolks.jnative.misc.basicStructures.AbstractBasicData;
import org.xvolks.jnative.misc.basicStructures.HWND;
import org.xvolks.jnative.misc.basicStructures.LONG;
import org.xvolks.jnative.misc.basicStructures.LPARAM;
import org.xvolks.jnative.pointers.NullPointer;
import org.xvolks.jnative.pointers.Pointer;
import org.xvolks.jnative.pointers.memory.GlobalMemoryBlock;
import org.xvolks.jnative.pointers.memory.MemoryBlockFactory;
import org.xvolks.jnative.util.Callback;

public class ChooseColor extends AbstractBasicData<ChooseColor> {
   LONG lStructSize;
   HWND hwndOwner;
   HWND hInstance;
   public LONG rgbResult;
   static Pointer lpCustColors;
   LONG Flags;
   LPARAM lCustData;
   int lpfnHook;
   Callback fnHook;
   Pointer lpTemplateName;
   
   static {
           try {
                        lpCustColors = new Pointer(MemoryBlockFactory.createMemoryBlock(16));
                } catch (NativeException e) {
                        e.printStackTrace();
                        throw new RuntimeException(e);
                }           
   }

        public ChooseColor() throws NativeException {
                super(null);
                mValue = this;
                createPointer();
        }

        public void removeCallback() throws NativeException {
                if(fnHook != null) {
                        JNative.releaseCallback(fnHook);
                        fnHook = null;
                }
        }
        public void addCallback(Callback lCallback) throws NativeException {
                removeCallback();
                fnHook = lCallback;
                //The callback object must handle 4 parameters from
                //CCHookProc(HWND hdlg, UINT uiMsg, WPARAM wParam, LPARAM lParam)
                lpfnHook = JNative.createCallback(4, lCallback);
                pointer.setIntAt(28, lpfnHook);
        }
       
        public ChooseColor getValueFromPointer() throws NativeException {
                offset = 0;
                lStructSize = new LONG(getNextInt());         // 0
                hwndOwner = new HWND(getNextInt());           // 4
                hInstance = new HWND(getNextInt());                // 8
                rgbResult = new LONG(getNextInt());         //12
                //Skip lpCustColor
                offset += 4;                                                         //16
                Flags = new LONG(getNextInt());                        //20
                lCustData = new LPARAM(getNextInt());        //24
                //Skip callback                                                 //28
                //Skip TemplateName                                         //32
                                                                                                //36 = size
                return getValue();
        }

        public int getSizeOf() {
                return 36;
        }

        public Pointer createPointer() throws NativeException {
                pointer = new Pointer(new GlobalMemoryBlock(getSizeOf()));
                pointer.setIntAt(0, getSizeOf());
                pointer.setIntAt(16, lpCustColors.getPointer());
                return pointer;
        }

        public void setOwner(HWND owner) throws NativeException {
                hwndOwner = owner;
                pointer.setIntAt(4, hwndOwner.getValue());
        }

        public void setInstance(HWND instance) throws NativeException {
                hInstance = instance;
                pointer.setIntAt(8, hInstance.getValue());
        }

        public void setFlags(LONG flags) throws NativeException {
                Flags = flags;
                pointer.setIntAt(20, Flags.getValue());
        }

        public void setCustData(LPARAM custData) throws NativeException {
                lCustData = custData;
                pointer.setIntAt(24, lCustData.getValue());
        }

        public void setTemplateName(String templateName) throws NativeException {
                if(templateName == null) {
                        lpTemplateName = new NullPointer();
                } else {
                        lpTemplateName = new Pointer(MemoryBlockFactory.createMemoryBlock(templateName.length() + 1));
                        lpTemplateName.setMemory(templateName);
                }
                pointer.setIntAt(32, lpTemplateName.getPointer());
        }
       
       
}

This tutorial was not tested and therefore is not guaranted to work, post comments if you think you need more help.

— Marc

[1] recommanded

[2] free

[3] method getSizeOf()

[4] on 32 bits computers and OS

[MSDN1]see COLORREF help

[MSDN1]see COLORREF help

[MSDN2]see CCHookProc help

Reply to this article

明天星期四
关注
jnative 从指针中获得传出值
LzwGlory的专栏
08-08 4189
import org.xvolks.jnative.JNative; import org.xvolks.jnative.Type; import org.xvolks.jnative.exceptions.NativeException; import org.xvolks.jnative.misc.basicStructures.AbstractBasicData; import org.xv
EnumWindows的使用方法
June19860709的专栏
06-26 3755
#include "tlhelp32.h" //定义一个进程ID和窗口句柄的结构体 typedef struct tagWNDINFO { DWORD dwProcessId; HWND hWnd; } WNDINFO, *LPWNDINFO; #include "stdafx.h" #include "Com_NetStatusThread.h" #includ
JAVA调用动态链接库
weixin_34379433的博客
01-26 202
上一篇《JAVA本地接口（JNI）》中介绍了JAVA的JNI技术，通过JAVA自有的方式调用动态链接库，这一篇将继续为大家介绍使用其他方式调用动态链接库。 首先，我们编写一个用于测试的链接库 头文件 print.h #ifdef DLL_IMPLEMENT #define DLL_API __declspec(dllex...
java 调用win32 api 学习总结
热门推荐
bcbobo21cn的专栏
03-18 1万+
java使用JInvoke调用windows API 使用jinvoke调用windowsAPI。jna使用比较麻烦，需要写c代码和参数转换，jinvoke的使用就像jdk中的包一样。  官网使用参考：http://www.jinvoke.com/calling-the-win32-api-from-java  一个弹出框的例子（这种代码用于调用任何dll，不只是windows的
jnative.rar
03-26
《JNative：Java调用DLL的桥梁》 在软件开发中，有时我们需要在Java应用程序中调用本地系统库，例如Windows平台下的动态链接库（DLL）。为了实现这一目标，Java提供了一个名为JNative的库，它允许Java代码与C/C++...
JNative完整jar
09-27
《JNative完整jar详解》 在Java编程领域，有时候我们需要调用本地系统资源或库，这时JNative就显得尤为重要。JNative是一个Java Native Interface (JNI)的封装库，它简化了Java程序与C/C++代码之间的交互过程。本文...
JNative.jar以及JNative源码
02-27
《深入理解JNative：Java调用DLL的桥梁》 在Java世界中，由于其平台无关性的特性，直接调用本地动态链接库（DLL）并非易事。然而，JNative库的出现，为Java程序员提供了一个方便的解决方案，使得Java能够无缝地与C/...
org.xvolks.jnative 源码
05-27
《深入解析org.xvolks.jnative源码》 在Java世界中，为了实现与本地代码的交互，开发者经常需要借助JNI（Java Native Interface）技术。然而，JNI的使用门槛相对较高，涉及到C/C++编程，这给许多Java开发者带来了...
JNative.jar
03-29
《JNative.jar：Java与本地代码交互的利器》 在Java世界中，有时我们需要调用非Java语言编写的代码，例如C或C++库，来实现特定的功能或优化性能。这时，Java Native Interface（JNI）就显得尤为重要。JNative.jar...
jnative callback 回调函数的实现
Reasonsoft的专栏
06-21 864
jnative 1.3.2版本发布了，可以完美支持C回调函数。不过令我很恼火的是还不支持activex dll的调用，问了jnative的作者，他说会在jnative 后继版本支持，大家期待吧！不然要用jacob，在一个项目里面用两种技术，我想任何人都不愿意这样做。 首先定义一个回调类模板： [code="java"]package com.syct.jnative.wrap...
jnative
iteye_14076的博客
06-03 142
http://jnative.free.fr/SPIP-v1-8-3/article.php3?id_article=4 public class JnativeRect extends AbstractBasicData{ protected JnativeRect(JnativeRect lValue) throws NativeException { su...
JAVA调用动态链接库DLL之JNative学习
无知人生，记录点滴
05-25 1419
JAVA调用动态链接库DLL的方法有：JNI（Java Native Interface），JInvoke，JNative（Java to native interface），JNI是JAVA自身提供的方法；JInvoke从何而来不得而知，好像还需要注册付费的，64位的JDK、JIR环境下运行不了，在VMware下安装的WindowsXP下同样有问题；JNative是开源的，但相关资料文档也特别的...
基于大模型技术的算力产业监测服务平台设计
最新发布
09-17
内容概要：本文提出了一种新型算力产业监测服务平台的设计理念，运用国内自主研发的大模型技术支持，通过对传统技术的改进和完善，提出了三层架构的设计方法，即基础设施层（含向量数据库和模型训练）、大模型应用框架层（强化数据处理与多维关系挖掘）及业务层（如智能分析助手）。这种设计方案旨在提高算力产业发展监测与决策制定的质量。 适合人群：电信行业的从业人员及研究人员；算力产业链各环节管理者；政府相关机构和政策决策者。 使用场景及目标：在多种算力相关的应用场景（如云计算中心管理，数据中心监测，政策分析）中辅助决策者进行快速有效的信息获取和技术选择；助力算力产业发展方向的精确把控和战略调整。 其他说明：随着大模型技术的日臻成熟，该算力产业监测服务平台预计将进一步丰富自身的应用领域和服务深度，以促进算力行业更智慧化发展。
使用JNative轻松调用DLL：Java JNI实践
"本资源主要介绍了如何使用JNative框架来实现Java调用DLL动态库，适用于希望在Java程序中集成C/C++功能的开发者。文中提到了JNative相对于其他类似库如JNA、Jawin等的优势，并提供了详细的操作步骤和数据类型映射...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值