jni, java native interface, java的本地介面,如果java程式碼想去呼叫native方法(實際就是c/c++函式),就需要用jni技術,在傳統的java中jni技術就已經存在,但是由於傳統的java程式碼中,不太去寫架構或者平臺相關的程式碼,所以以前jni不是太惹人注意,直到android出現後,android本身是一個linux作業系統, linux中的應用程式設計中就使用c/c++程式碼去呼叫驅動,假如android的應用apk想去呼叫底層的裝置驅動,那麼就必須要去呼叫c/c++程式碼,所以此時jni就顯得很重要,它起著承上啟下的作用.

           jni的寫法有好幾種,在這裡先介紹在android原始碼包+linux環境下的jni程式設計方式,隨後會介紹ndk中的jni的程式設計方式

           程式設計之前首先需要給大家介紹一個大體的框架,我們需要在apk中去點一個led燈,此時就像做飯一樣,介紹幾個主料:

            1, apk,實現button點燈

             2, jni程式碼,呼叫linux的系統呼叫,去控制驅動

             3, 驅動,完成控制led硬體

首先介紹apk中使用jni中的幾個介面

介面一: 呼叫動態庫

             static{

              System.loadLibrary("led_jni"); // /system/lib/libled_jni.so

       }

介面二: 宣告本地方法

              public native int OpenDev();

              public native int DevOn();

              public native int DevOff();

              public native int CloseDev();

介面三: 直接呼叫本地方方法

           OpenDev();

apk程式碼的內容如下，非常簡單

package fs.hq; import android.app.Activity; import android.os.Bundle; import android.view.View; import android.view.View.OnClickListener; import android.widget.Button; import android.widget.Toast; public class LedActivity extends Activity { @Override protected void onDestroy() { // TODO Auto-generated method stub super.onDestroy(); DevClose();//介面三： 呼叫native方法 this.finish(); } Button ledBtnOn; Button ledBtnOff; private void init() { ledBtnOn =(Button)this.findViewById(R.id.btnOn); ledBtnOn.setOnClickListener(onClickListener); ledBtnOff =(Button)this.findViewById(R.id.btnOff); ledBtnOff.setOnClickListener(onClickListener); } OnClickListener onClickListener = new OnClickListener() { @Override public void onClick(View v) { switch (v.getId()) { case R.id.btnOn: Toast.makeText(LedActivity.this, "led on", 2000).show(); DevOn();//介面三： 呼叫native方法 break; case R.id.btnOff: Toast.makeText(LedActivity.this, "led off", 2000).show(); DevOff();//介面三： 呼叫native方法 break; default: break; } } }; public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); init(); //介面三： 呼叫native方法 OpenDev(); } //介面一：靜態區域程式碼，完整載入動態庫，並且會完成對映表的註冊 static{ System.loadLibrary("led_jni"); //該動態庫的名字叫libled_jni.so，所在路徑/system/lib/ } private native int OpenDev(); //介面二： 通過native宣告本地方法，只有宣告，而沒有定義 private native int DevOn(); private native int DevOff(); private native int DevClose(); }

jni程式碼的編寫原理: java中呼叫c程式碼的基本原理是通過檢視一個對映表來完成的，比如java中呼叫OpenDev方法時，實際是有一個c/c++函式與它一一對應，所以需要一個對映表，並且將其註冊給dvm，當dvm解析java中的native方法是，會去檢視這個對映表，並執行對應的c/c++函式，同時jni程式碼所在的檔案是需要編譯成動態庫，

jni程式碼可以寫成c檔案或者是cpp檔案，但是建議大家寫成cpp檔案，在此，以下程式碼是寫成一個檔案led_jni.cpp

1, 動態庫中的介面:

 a, 獲取dvm的環境變數物件,並測試jni的版本(1.4)            jint JNI_OnLoad(JavaVM* vm, void* reserved) { JNIEnv* env = NULL; jint ret = -1; jint result = -1; if (vm->GetEnv((void **)&env, JNI_VERSION_1_4) != JNI_OK) { LOGE("ERROR: GetEnv failed"); goto bail; } ret = myRegisterNatives(env); if(ret != JNI_TRUE) { LOGE("ERROR: registerNatives failed"); goto bail; } result = JNI_VERSION_1_4; bail: return result; }

   vm->GetEnv((void **)&env, JNI_VERSION_1_4)該方法是dvm給我們提供的方法，用於獲取環境變數物件JNIEnv* env，同時會檢測jni的版本是否是1.4， 該方法正常返回JNI_OK

    myRegisterNatives(env);該法是自己去實現的，引數就是通過vm->GetENv方法獲取的

b, myRegisterNatives(env)的實現，主要是為了完成對映表的註冊，會呼叫env->RegisterNatives()方法

static char *clsStr = "fs/hq/LedActivity"; static int myRegisterNatives(JNIEnv* env) { jint ret = -1; jclass myClz = env->FindClass(clsStr); if (myClz == NULL) { LOGE("Native registration unable to find class '%s'", clsStr); return JNI_FALSE; } ret = env->RegisterNatives(myClz, myMethod, sizeof(myMethod)/sizeof(myMethod[0])); if(ret < 0) { LOGE("%s, RegisterNatives failed", __FUNCTION__); return JNI_FALSE; } LOGD("RegisterNatives Ok\n"); return JNI_TRUE; } 

 env->RegisterNatives(jclass clazz, const JNINativeMethod* methods,jint nMethods)

第一個引數：　將java中native修飾的方法所在的類轉換成jni的class型別(jclass)

          jclass mycls = env->FindClass("com/hq/JniLedTestActivity");

     env->FindClass中的引數是java中的native方法所在包和類的路徑，這個是必須要注意的，路徑是用Linux常用的路徑表示方式，而不是用windows，也不是用java中的點分方式，同時路徑必須要指定正確，否則會出錯

第二個引數: jni的對映表:

static JNINativeMethod myMethod[] ={ {"OpenDev", "()I", (void *)led_open}, {"DevOn", "()I", (void *)led_on}, {"DevOff", "()I", (void *)led_off}, {"DevClose", "()I", (void *)led_close}, }; 

第三個引數: 對映表表的成員個數sizeof(myMethods)/sizeof(myMethods[0])

返回: JNI_OnLoad正常 返回JNI_VERSION_1_4

         錯誤返回一個負數

c,接下來就是介紹對映表的構造了：

typedef struct { const char* name; // java的native修飾的方法名 const char* signature; // 方法的返回值和引數的描述，比如(I)I，表示返回值為int，帶有一個int型的引數 void* fnPtr; //c/c++中的函式名 } JNINativeMethod; 所以接下來就是c/c++函式的實現了 #define GPG3DAT2_ON _IO('L', 0x30) #define GPG3DAT2_OFF _IO('L', 0x31) static int fd = -1; static jint led_open(JNIEnv *env, jobject obj) { //系統呼叫 LOGD("%s\n", __FUNCTION__); fd = open("/dev/led", O_RDWR); //開啟led裝置 if(fd < 0) { LOGE("open dev error"); return -1; } return 0; } static jint led_on(JNIEnv *env, jobject obj) { LOGD("%s\n", __FUNCTION__); int ret = -1; ret = ioctl(fd,GPG3DAT2_ON,NULL); // if(ret < 0) { LOGE("ioctl error\n"); return -1; } return 0; } static jint led_off(JNIEnv *env, jobject obj) { LOGD("%s\n", __FUNCTION__); int ret = -1; ret = ioctl(fd,GPG3DAT2_OFF,NULL); if(ret < 0) { LOGE("ioctl error\n"); return -1; } return 0; } static jint led_close(JNIEnv *env, jobject obj) { LOGD("%s\n", __FUNCTION__); close(fd); return 0; } static JNINativeMethod myMethod[] ={ {"OpenDev", "()I", (void *)led_open}, {"DevOn", "()I", (void *)led_on}, {"DevOff", "()I", (void *)led_off}, {"DevClose", "()I", (void *)led_close}, };

程式碼的片段介紹完了，貼出完整程式碼

#define LOG_TAG "myledjni" #include <utils/Log.h> #include "jni.h" #include <stdio.h> #include <stdlib.h> #include <fcntl.h> #include <errno.h> #include <sys/ioctl.h> #define GPG3DAT2_ON _IO('L', 0x31) #define GPG3DAT2_OFF _IO('L', 0x31) static int fd = -1; static jint led_open(JNIEnv *env, jobject obj) { //緋葷粺璋冪敤 LOGD("%s\n", __FUNCTION__); fd = open("/dev/led", O_RDWR); if(fd < 0) { LOGE("open dev error"); return -1; } return 0; } static jint led_on(JNIEnv *env, jobject obj) { LOGD("%s\n", __FUNCTION__); int ret = -1; ret = ioctl(fd,GPG3DAT2_ON,NULL); if(ret < 0) { LOGE("ioctl error\n"); return -1; } return 0; } static jint led_off(JNIEnv *env, jobject obj) { LOGD("%s\n", __FUNCTION__); int ret = -1; ret = ioctl(fd,GPG3DAT2_OFF,NULL); if(ret < 0) { LOGE("ioctl error\n"); return -1; } return 0; } static jint led_close(JNIEnv *env, jobject obj) { LOGD("%s\n", __FUNCTION__); close(fd); return 0; } static jint led_read(JNIEnv *env, jobject obj) { //read(fd, buf, size); return 0 ; } static jint led_write(JNIEnv *env, jobject obj) { //write(); return 0 ; } static JNINativeMethod myMethod[] ={ {"OpenDev", "()I", (void *)led_open}, {"DevOn", "()I", (void *)led_on}, {"DevOff", "()I", (void *)led_off}, {"DevClose", "()I", (void *)led_close}, }; static char *clsStr = "fs/hq/LedActivity"; static int myRegisterNatives(JNIEnv* env) { jint ret = -1; jclass myClz = env->FindClass(clsStr); if (myClz == NULL) { LOGE("Native registration unable to find class '%s'", clsStr); return JNI_FALSE; } ret = env->RegisterNatives(myClz, myMethod, sizeof(myMethod)/sizeof(myMethod[0])); if(ret < 0) { LOGE("%s, RegisterNatives failed", __FUNCTION__); return JNI_FALSE; } LOGD("RegisterNatives Ok\n"); return JNI_TRUE; } jint JNI_OnLoad(JavaVM* vm, void* reserved) { JNIEnv* env = NULL; jint ret = -1; jint result = -1; if (vm->GetEnv((void **)&env, JNI_VERSION_1_4) != JNI_OK) { LOGE("ERROR: GetEnv failed"); goto bail; } ret = myRegisterNatives(env); if(ret != JNI_TRUE) { LOGE("ERROR: registerNatives failed"); goto bail; } result = JNI_VERSION_1_4; bail: return result; }  

d,程式碼寫好了,Android.mk是為了編譯我們寫的程式碼，程式碼最終會編譯成動態庫：

LOCAL_PATH:= $(call my-dir) include $(CLEAR_VARS) LOCAL_SRC_FILES:= \ led_jni.cpp #編譯的時候要連線libutils.so,因為我們使用了LOGD LOCAL_SHARED_LIBRARIES := \ libutils #指定jni.h標頭檔案所在路徑 LOCAL_C_INCLUDES += \ $(JNI_H_INCLUDE) #目標檔案的名字，最終會被編譯成libled_jni.so，和apk中呼叫的動態庫名字要一致 LOCAL_MODULE:= libled_jni #編譯動態庫需要加上這個標誌，不要預連線 LOCAL_PRELINK_MODULE := false #編譯動態庫 include $(BUILD_SHARED_LIBRARY)  

 3,接下來就是驅動部分了，對於不同平臺，led的驅動的寫法是不一樣的，但是基本的寫法就是按照字元裝置的方式去寫，這個算是一個字元裝置驅動的簡單模板，可以參考一下看看

/* * Simple - REALLY simple memory mapping demonstration. */ #include <linux/module.h> #include <linux/moduleparam.h> #include <linux/init.h> #include <linux/kernel.h> /* printk() */ #include <linux/slab.h> /* kmalloc() */ #include <linux/fs.h> /* everything... */ #include <linux/errno.h> /* error codes */ #include <linux/types.h> /* size_t */ #include <linux/mm.h> #include <linux/kdev_t.h> #include <linux/cdev.h> #include <linux/delay.h> #include <linux/device.h> #include <asm/io.h> #include <asm/uaccess.h> #define pGPG3CON 0xE03001C0 #define pGPG3DAT 0xE03001C4 static void *vGPG3CON , *vGPG3DAT; #define GPG3CON (*(volatile unsigned int *) vGPG3CON) #define GPG3DAT (*(volatile unsigned int *) vGPG3DAT) #define LED_ON _IO('L', 0x31) #define LED_OFF _IO('L', 0x30) static int simple_major = 252; module_param(simple_major, int, 0); MODULE_AUTHOR("farsight"); MODULE_LICENSE("Dual BSD/GPL"); //static int flag = 0; /* * Open the device; in fact, there's nothing to do here. */ int simple_open (struct inode *inode, struct file *filp) { vGPG3CON=ioremap(pGPG3CON,0x10); vGPG3DAT=vGPG3CON+0x04; GPG3CON=0x1111; //GPG3DAT=0xff; return 0; } ssize_t simple_read(struct file *file, char __user *buff, size_t count, loff_t *offp) { return 0; } ssize_t simple_write(struct file *file, const char __user *buff, size_t count, loff_t *offp) { return 0; } void led_off( void ) { GPG3DAT=GPG3DAT&(~(1<<2)); //printk("stop led\n"); } void led_on( void ) { GPG3DAT=GPG3DAT|(1<<2 printk="" start="" led="" n="" static="" int="" simple_ioctl="" struct="" inode="" inode="" struct="" file="" file="" unsigned="" int="" cmd="" unsigned="" long="" arg="" switch="" cmd="" case="" led_on:="" led_on="" break="" case="" led_off:="" led_off="" break="" default:="" break="" return="" 0="" static="" int="" simple_release="" struct="" inode="" node="" struct="" file="" file="" return="" 0="" set="" up="" the="" cdev="" structure="" for="" a="" device="" static="" void="" simple_setup_cdev="" struct="" cdev="" dev="" int="" minor="" struct="" file_operations="" fops="" int="" err="" devno="MKDEV(simple_major," minor="" cdev_init="" dev="" fops="" dev-="">owner = THIS_MODULE; dev->ops = fops; err = cdev_add (dev, devno, 1); /* Fail gracefully if need be */ if (err) printk (KERN_NOTICE "Error %d adding simple%d", err, minor); } /* * Our various sub-devices. */ /* Device 0 uses remap_pfn_range */ static struct file_operations simple_remap_ops = { .owner = THIS_MODULE, .open = simple_open, .release = simple_release, .read = simple_read, .write = simple_write, .ioctl = simple_ioctl, }; /* * We export two simple devices. There's no need for us to maintain any * special housekeeping info, so we just deal with raw cdevs. */ static struct cdev SimpleDevs; /* * Module housekeeping. */ static struct class *my_class; static int simple_init(void) { int result; dev_t dev = MKDEV(simple_major, 0); /* Figure out our device number. */ if (simple_major) result = register_chrdev_region(dev, 1, "simple"); else { result = alloc_chrdev_region(&dev, 0, 1, "simple"); simple_major = MAJOR(dev); } if (result < 0) { printk(KERN_WARNING "simple: unable to get major %d\n", simple_major); return result; } if (simple_major == 0) simple_major = result; /* Now set up two cdevs. */ simple_setup_cdev(&SimpleDevs, 0, &simple_remap_ops); printk("simple device installed, with major %d\n", simple_major); my_class= class_create(THIS_MODULE, "simple"); device_create(my_class, NULL, MKDEV(simple_major, 0), NULL, "led"); return 0; } static void simple_cleanup(void) { cdev_del(&SimpleDevs); unregister_chrdev_region(MKDEV(simple_major, 0), 1); device_destroy(my_class,MKDEV(simple_major,0)); printk("simple device uninstalled\n"); } module_init(simple_init); module_exit(simple_cleanup);