編譯jclass程序的命令_誰有沒有Android串口的使用例子

① 如何在C/C++中調用java

如何在C/C++中調用Java

java跨平台的特性使Java越來越受開發人員的歡迎，但也往往會聽到不少的抱怨：用Java開發的圖形用戶窗口界面每次在啟動的時候都會跳出一個控制台窗口，這個控制台窗口讓本來非常棒的界面失色不少。怎麼能夠讓通過Java開發的GUI程序不彈出Java的控制台窗口呢?其實現在很多流行的開發環境例如JBuilder、Eclipse都是使用純Java開發的集成環境。這些集成環境啟動的時候並不會打開一個命令窗口，因為它使用了JNI(Java Native Interface)的技術。通過這種技術，開發人員不一定要用命令行來啟動Java程序，可以通過編寫一個本地GUI程序直接啟動Java程序，這樣就可避免另外打開一個命令窗口，讓開發的Java程序更加專業。
JNI答應運行在虛擬機的Java程序能夠與其它語言(例如C和C++)編寫的程序或者類庫進行相互間的調用。同時JNI提供的一整套的API，答應將Java虛擬機直接嵌入到本地的應用程序中。圖1是Sun站點上對JNI的基本結構的描述。
如何在C/C++中調用Java 三聯
本文將介紹如何在C/C++中調用Java方法，並結合可能涉及到的問題介紹整個開發的步驟及可能碰到的難題和解決方法。本文所採用的工具是Sun公司創建的 Java Development Kit (JDK) 版本 1.3.1，以及微軟公司的Visual C++ 6開發環境。
環境搭建
為了讓本文以下部分的代碼能夠正常工作，我們必須建立一個完整的開發環境。首先需要下載並安裝JDK 1.3.1，其下載地址為「http://java.sun.com」。假設安裝路徑為C：JDK。下一步就是設置集成開發環境，通過Visual C++ 6的菜單Tools→Options打開選項對話框如圖2。

將目錄C:JDKinclude和C:JDKincludewin32加入到開發環境的Include Files目錄中，同時將C:JDKlib目錄添加到開發環境的Library Files目錄中。這三個目錄是JNI定義的一些常量、結構及方法的頭文件和庫文件。集成開發環境已經設置完畢，同時為了執行程序需要把Java虛擬機所用到的動態鏈接庫所在的目錄C:JDK jreinclassic設置到系統的Path環境變數中。這里需要提出的是，某些開發人員為了方便直接將JRE所用到的DLL文件直接拷貝到系統目錄下。這樣做是不行的，將導致初始化Java虛擬機環境失敗(返回值-1)，原因是Java虛擬機是以相對路徑來尋找所用到的庫文件和其它一些相關文件的。至此整個JNI的開發環境設置完畢，為了讓此次JNI旅程能夠順利進行，還必須先預備一個Java類。在這個類中將用到Java中幾乎所有有代表性的屬性及方法，如靜態方法與屬性、數組、異常拋出與捕捉等。我們定義的Java程序(Demo.java)如下，本文中所有的代碼演示都將基於該Java程序，代碼如下：
package jni.test; /** * 該類是為了演示JNI如何訪問各種對象屬性等 * @author liudong */ public class Demo { //用於演示如何訪問靜態的基本類型屬性 public static int COUNT = 8; //演示對象型屬性 public String msg; PRivate int[] counts; public Demo() { this("預設構造函數"); } /** * 演示如何訪問構造器 */ public Demo(String msg) { System.out.println(":" + msg); this.msg = msg; this.counts = null; } /** * 該方法演示如何訪問一個訪問以及中文字元的處理 */ public String getMessage() { return msg; } /** * 演示數組對象的訪問 */ public int[] getCounts() { return counts; } /** * 演示如何構造一個數組對象 */ public void setCounts(int[] counts) { this.counts = counts; } /** * 演示異常的捕捉 */ public void throwExcp() throws IllegalaccessException { throw new IllegalAccessException("exception occur."); } }
初始化虛擬機
本地代碼在調用Java方法之前必須先載入Java虛擬機，而後所有的Java程序都在虛擬機中執行。為了初始化Java虛擬機，JNI提供了一系列的介面函數Invocation API。通過這些API可以很方便地將虛擬機載入到內存中。創建虛擬機可以用函數 jint JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args)。對於這個函數有一點需要注重的是，在JDK 1.1中第三個參數總是指向一個結構JDK1_ 1InitArgs，這個結構無法完全在所有版本的虛擬機中進行無縫移植。在JDK 1.2中已經使用了一個標準的初始化結構JavaVMInitArgs來替代JDK1_1InitArgs。下面我們分別給出兩種不同版本的示例代碼。
在JDK 1.1初始化虛擬機:
#include int main() { JNIEnv *env; JavaVM *jvm; JDK1_1InitArgs vm_args; jint res; /* IMPORTANT: 版本號設置一定不能漏 */ vm_args.version = 0x00010001; /*獲取預設的虛擬機初始化參數*/ JNI_GetDefaultJavaVMInitArgs(&vm_args); /* 添加自定義的類路徑 */ sprintf(classpath, "%s%c%s", vm_args.classpath, PATH_SEPARATOR, USER_CLASSPATH); vm_args.classpath = classpath; /*設置一些其他的初始化參數*/ /* 創建虛擬機 */ res = JNI_CreateJavaVM(&jvm,&env,&vm_args); if (res < 0) { fprintf(stderr, "Can't create Java VM "); exit(1); } /*釋放虛擬機資源*/ (*jvm)->DestroyJavaVM(jvm); }
JDK 1.2初始化虛擬機：
/* invoke2.c */ #include int main() { int res; JavaVM *jvm; JNIEnv *env; JavaVMInitArgs vm_args; JavaVMOption options[3]; vm_args.version=JNI_VERSION_1_2;//這個欄位必須設置為該值 /*設置初始化參數*/ options[0].optionString = "-Djava.compiler=NONE"; options[1].optionString = "-Djava.class.path=."; options[2].optionString = "-verbose:jni";//用於跟蹤運行時的信息 /*版本號設置不能漏*/ vm_args.version = JNI_VERSION_1_2; vm_args.nOptions = 3; vm_args.options = options; vm_args.ignoreUnrecognized = JNI_TRUE; res = JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args); if (res < 0) { fprintf(stderr, "Can't create Java VM "); exit(1); } (*jvm)->DestroyJavaVM(jvm); fprintf(stdout, "Java VM destory. "); }
為了保證JNI代碼的可移植性，建議使用JDK 1.2的方法來創建虛擬機。JNI_CreateJavaVM函數的第二個參數JNIEnv *env，就是貫穿整個JNI始末的一個參數，因為幾乎所有的函數都要求一個參數就是JNIEnv *env。
訪問類方法
初始化了Java虛擬機後，就可以開始調用Java的方法。要調用一個Java對象的方法必須經過幾個步驟：
1.獲取指定對象的類定義(jclass)
有兩種途徑來獲取對象的類定義：第一種是在已知類名的情況下使用FindClass來查找對應的類。但是要注重類名並不同於平時寫的Java代碼，例如要得到類jni.test.Demo的定義必須調用如下代碼：
jclass cls = (*env)->FindClass(env, "jni/test/Demo");//把點號換成斜杠
然後通過對象直接得到其所對應的類定義：
jclass cls = (*env)-> GetObjectClass(env, obj); //其中obj是要引用的對象，類型是jobject
2.讀取要調用方法的定義(jmethodID)
我們先來看看JNI中獲取方法定義的函數：
jmethodID (JNICALL *GetMethodID)(JNIEnv *env, jclass clazz, const char *name, const char *sig); jmethodID (JNICALL *GetStaticMethodID)(JNIEnv *env, jclass class, const char *name, const char *sig);
這兩個函數的區別在於GetStaticMethodID是用來獲取靜態方法的定義，GetMethodID則是獲取非靜態的方法定義。這兩個函數都需要提供四個參數：env就是初始化虛擬機得到的JNI環境;第二個參數class是對象的類定義，也就是第一步得到的obj;第三個參數是方法名稱;最重要的是第四個參數，這個參數是方法的定義。因為我們知道Java中答應方法的多態，僅僅是通過方法名並沒有辦法定位到一個具體的方法，因此需要第四個參數來指定方法的具體定義。但是怎麼利用一個字元串來表示方法的具體定義呢?JDK中已經預備好一個反編譯工具javap，通過這個工具就可以得到類中每個屬性、方法的定義。下面就來看看jni.test.Demo的定義：
打開命令行窗口並運行 javap -s -p jni.test.Demo 得到運行結果如下：
Compiled from Demo.java public class jni.test.Demo extends java.lang.Object { public static int COUNT; /* I */ public java.lang.String msg; /* Ljava/lang/String; */ private int counts[]; /* [I */ public jni.test.Demo(); /* ()V */ public jni.test.Demo(java.lang.String); /* (Ljava/lang/String;)V */ public java.lang.String getMessage(); /* ()Ljava/lang/String; */ public int getCounts()[]; /* ()[I */ public void setCounts(int[]); /* ([I)V */ public void throwExcp() throws java.lang.IllegalAccessException; /* ()V */ static {}; /* ()V */ }
我們看到類中每個屬性和方法下面都有一段注釋。注釋中不包含空格的內容就是第四個參數要填的內容(關於javap具體參數請查詢JDK的使用幫助)。下面這段代碼演示如何訪問jni.test.Demo的getMessage方法：
/* 假設我們已經有一個jni.test.Demo的實例obj */ jmethodID mid; jclass cls = (*env)-> GetObjectClass (env, obj);//獲取實例的類定義 mid=(*env)->GetMethodID(env,cls,"getMessage"," ()Ljava/lang/String; "); /*假如mid為0表示獲取方法定義失敗*/ jstring msg = (*env)-> CallObjectMethod(env, obj, mid); /* 假如該方法是靜態的方法那隻需要將最後一句代碼改為以下寫法即可： jstring msg = (*env)-> CallStaticObjectMethod(env, cls, mid); */
3.調用方法
為了調用對象的某個方法，可以使用函數CallMethod或者CallStaticMethod(訪問類的靜態方法)，根據不同的返回類型而定。這些方法都是使用可變參數的定義，假如訪問某個方法需要參數時，只需要把所有參數按照順序填寫到方法中就可以。在講到構造函數的訪問時，將演示如何訪問帶參數的構造函數。
訪問類屬性
訪問類的屬性與訪問類的方法大體上是一致的，只不過是把方法變成屬性而已。
1.獲取指定對象的類(jclass)
這一步與訪問類方法的第一步完全相同，具體使用參看訪問類方法的第一步。
2.讀取類屬性的定義(jfieldID)
在JNI中是這樣定義獲取類屬性的方法的：
jfieldID (JNICALL *GetFieldID) (JNIEnv *env, jclass clazz, const char *name, const char *sig); jfieldID (JNICALL *GetStaticFieldID) (JNIEnv *env, jclass clazz, const char *name, const char *sig);
這兩個函數中第一個參數為JNI環境;clazz為類的定義;name為屬性名稱;第四個參數同樣是為了表達屬性的類型。前面我們使用javap工具獲取類的具體定義的時候有這樣兩行：
public java.lang.String msg; /* Ljava/lang/String; */
其中第二行注釋的內容就是第四個參數要填的信息，這跟訪問類方法時是相同的。
3.讀取和設置屬性值
有了屬性的定義要訪問屬性值就很輕易了。有幾個方法用來讀取和設置類的屬性，它們是：GetField、SetField、GetStaticField、SetStaticField。比如讀取Demo類的msg屬性就可以用GetObjectField，而訪問COUNT用GetStaticIntField，相關代碼如下：
jfieldID field = (*env)->GetFieldID(env,obj,"msg"," Ljava/lang/String;"); jstring msg = (*env)-> GetObjectField(env, cls, field);//msg就是對應Demo的msg jfieldID field2 = (*env)->GetStaticFieldID(env,obj,"COUNT","I"); jint count = (*env)->GetStaticIntField(env,cls,field2);
訪問構造函數
很多人剛剛接觸JNI的時候往往會在這一節碰到問題，查遍了整個jni.h看到這樣一個函數NewObject，它應該是可以用來訪問類的構造函數。但是該函數需要提供構造函數的方法定義，其類型是jmethodID。從前面的內容我們知道要獲取方法的定義首先要知道方法的名稱，但是構造函數的名稱怎麼來填寫呢?其實訪問構造函數與訪問一個普通的類方法大體上是一樣的，惟一不同的只是方法名稱不同及方法調用時不同而已。訪問類的構造函數時方法名必須填寫「」。下面的代碼演示如何構造一個Demo類的實例：
jclass cls = (*env)->FindClass(env, "jni/test/Demo"); /** 首先通過類的名稱獲取類的定義，相當於Java中的Class.forName方法 */ if (cls == 0) jmethodID mid = (*env)->GetMethodID(env,cls,"","(Ljava/lang/String;)V "); if(mid == 0) jobject demo = jenv->NewObject(cls,mid,0); /** 訪問構造函數必須使用NewObject的函數來調用前面獲取的構造函數的定義上面的代碼我們構造了一個Demo的實例並傳一個空串null */
數組處理
創建一個新數組
要創建一個數組，我們首先應該知道數組元素的類型及數組長度。JNI定義了一批數組的類型jArray及數組操作的函數NewArray，其中就是數組中元素的類型。例如，要創建一個大小為10並且每個位置值分別為1-10的整數數組，編寫代碼如下：
int i = 1; jintArray array;//定義數組對象 (*env)-> NewIntArray(env, 10); for(; i<= 10; i++) (*env)->SetIntArrayRegion(env, array, i-1, 1, &i);
訪問數組中的數據
訪問數組首先應該知道數組的長度及元素的類型。現在我們把創建的數組中的每個元素值列印出來，代碼如下：
int i; /* 獲取數組對象的元素個數 */ int len = (*env)->GetArrayLength(env, array); /* 獲取數組中的所有元素 */ jint* elems = (*env)-> GetIntArrayElements(env, array, 0); for(i=0; i< len; i++) printf("ELEMENT %d IS %d ", i, elems[i]);
中文處理
中文字元的處理往往是讓人比較頭疼的事情，非凡是使用Java語言開發的軟體，在JNI這個問題更加突出。由於Java中所有的字元都是Unicode編碼，但是在本地方法中，例如用VC編寫的程序，假如沒有非凡的定義一般都沒有使用Unicode的編碼方式。為了讓本地方法能夠訪問Java中定義的中文字元及Java訪問本地方法產生的中文字元串，我定義了兩個方法用來做相互轉換。
· 方法一，將Java中文字元串轉為本地字元串
/** 第一個參數是虛擬機的環境指針第二個參數為待轉換的Java字元串定義第三個參數是本地存儲轉換後字元串的內存塊第三個參數是內存塊的大小 */ int JStringToChar(JNIEnv *env, jstring str, LPTSTR desc, int desc_len) { int len = 0; if(desc==NULLstr==NULL) return -1; //在VC中wchar_t是用來存儲寬位元組字元(UNICODE)的數據類型 wchar_t *w_buffer = new wchar_t[1024]; ZeroMemory(w_buffer,1024*sizeof(wchar_t)); //使用GetStringChars而不是GetStringUTFChars wcscpy(w_buffer,env->GetStringChars(str,0)); env->ReleaseStringChars(str,w_buffer); ZeroMemory(desc,desc_len); //調用字元編碼轉換函數(Win32 API)將UNICODE轉為ASCII編碼格式字元串 //關於函數WideCharToMultiByte的使用請參考MSDN len = WideCharToMultiByte(CP_ACP,0,w_buffer,1024,desc,desc_len,NULL,NULL); //len = wcslen(w_buffer); if(len>0 && len
· 方法二，將C的字元串轉為Java能識別的Unicode字元串
jstring NewJString(JNIEnv* env,LPCTSTR str) { if(!env !str) return 0; int slen = strlen(str); jchar* buffer = new jchar[slen]; int len = MultiByteToWideChar(CP_ACP,0,str,strlen(str),buffer,slen); if(len>0 && len < slen) buffer[len]=0; jstring js = env->NewString(buffer,len); delete [] buffer; return js; }
異常
由於調用了Java的方法，因此難免產生操作的異常信息。這些異常沒有辦法通過C++本身的異常處理機制來捕捉到，但JNI可以通過一些函數來獲取Java中拋出的異常信息。之前我們在Demo類中定義了一個方法throwExcp，下面將訪問該方法並捕捉其拋出來的異常信息，代碼如下：
/** 假設我們已經構造了一個Demo的實例obj，其類定義為cls */ jthrowable excp = 0;/* 異常信息定義 */ jmethodID mid=(*env)->GetMethodID(env,cls,"throwExcp","()V"); /*假如mid為0表示獲取方法定義失敗*/ jstring msg = (*env)-> CallVoidMethod(env, obj, mid); /* 在調用該方法後會有一個IllegalAccessException的異常拋出 */ excp = (*env)->ExceptionOccurred(env); if(excp){ (*env)->ExceptionClear(env); //通過訪問excp來獲取具體異常信息 /* 在Java中，大部分的異常信息都是擴展類java.lang.Exception，因此可以訪問excp的toString 或者getMessage來獲取異常信息的內容。訪問這兩個方法同前面講到的如何訪問類的方法是相同的。 */ }
線程和同步訪問
有些時候需要使用多線程的方式來訪問Java的方法。我們知道一個Java虛擬機是非常消耗系統的內存資源，差不多每個虛擬機需要內存大約在20MB左右。為了節省資源要求每個線程使用的是同一個虛擬機，這樣在整個的JNI程序中只需要初始化一個虛擬機就可以了。所有人都是這樣想的，但是一旦子線程訪問主線程創建的虛擬機環境變數，系統就會出現錯誤對話框，然後整個程序終止。
其實這裡面涉及到兩個概念，它們分別是虛擬機(JavaVM *jvm)和虛擬機環境(JNIEnv *env)。真正消耗大量系統資源的是jvm而不是env，jvm是答應多個線程訪問的，但是env只能被創建它本身的線程所訪問，而且每個線程必須創建自己的虛擬機環境env。這時候會有人提出疑問，主線程在初始化虛擬機的時候就創建了虛擬機環境env。為了讓子線程能夠創建自己的env，JNI提供了兩個函數：AttachCurrentThread和DetachCurrentThread。下面代碼就是子線程訪問Java方法的框架：
DWord WINAPI ThreadProc(PVOID dwParam) { JavaVM jvm = (JavaVM*)dwParam;/* 將虛擬機通過參數傳入 */ JNIEnv* env; (*jvm)-> AttachCurrentThread(jvm, (void**)&env, NULL); ......... (*jvm)-> DetachCurrentThread(jvm); }
時間
關於時間的話題是我在實際開發中碰到的一個問題。當要發布使用了JNI的程序時，並不一定要求客戶要安裝一個Java運行環境，因為可以在安裝程序中打包這個運行環境。為了讓打包程序利於下載，這個包要比較小，因此要去除JRE(Java運行環境)中一些不必要的文件。但是假如程序中用到Java中的日歷類型，例如java.util.Calendar等，那麼有個文件一定不能去掉，這個文件就是[JRE]lib zmappings。它是一個時區映射文件，一旦沒有該文件就會發現時間操作上經常出現與正確時間相差幾個小時的情況。下面是打包JRE中必不可少的文件列表(以Windows環境為例)，其中[JRE]為運行環境的目錄，同時這些文件之間的相對路徑不能變。
文件名目錄 hpi.dll [JRE]in ioser12.dll [JRE]in java.dll [JRE]in net.dll [JRE]in verify.dll [JRE]in zip.dll [JRE]in jvm.dll [JRE]inclassic rt.jar [JRE]lib tzmappings [JRE]lib
由於rt.jar有差不多10MB，但是其中有很大一部分文件並不需要，可以根據實際的應用情況進行刪除。例如程序假如沒有用到Java Swing，就可以把涉及到Swing的文件都刪除後重新打包。

② 誰有沒有android串口的使用例子

1 首先做的是創建新的工程然後添加一下文件

3代碼

好了然後就是關於這個頁面的Code了，

這是我的：

package android.serialport;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.BreakIterator;
import java.util.ServiceConfigurationError;

import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.Window;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

public class MyserialActivity extendsActivity
{
EditText sendedit;
EditText receiveedit;
FileInputStream mInStream;
FileOutputStream mOutStream;
SerialPort classserialport;
ReadThread mReadThread;

private class ReadThread extends Thread
{
public void run()
{
super.run();
while(!isInterrupted())
{
int size;
}
}
}

void onDataReceive(final byte[] buffer,finalint size)
{
runOnUiThread(new Runnable()
{

@Override
publicvoid run()
{
// TODO Auto-generated method stub
if(mReadThread != null)
{
receiveedit.append(newString(buffer,0,size));
}
}
});
}
@Override
protectedvoid onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
this.requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.activity_myserial);

sendedit= (EditText)findViewById(R.id.editText1);
receiveedit=(EditText)findViewById(R.id.editText2);

receiveedit.setFocusable(false);//進制輸入
/*
* 打開串口
* */
finalButton openserial =(Button)findViewById(R.id.button1);
openserial.setOnClickListener(newView.OnClickListener()
{

@Override
publicvoid onClick(View arg0)
{
//TODO Auto-generated method stub
try
{
classserialport=new SerialPort(new File("/dev/ttyS2"),9600);
}catch(SecurityExceptione)
{
e.printStackTrace();
}
catch(IOExceptione)
{
e.printStackTrace();
}
mInStream=(FileInputStream) classserialport.getInputStream();
Toast.makeText(MyserialActivity.this,"串口打開成功",Toast.LENGTH_SHORT).show();
}
});
/*
* 發送數據
* */
finalButton sendButton =(Button)findViewById(R.id.button2);
sendButton.setOnClickListener(newView.OnClickListener()
{

@Override
publicvoid onClick(View arg0)
{

Stringindata;
indata=sendedit.getText().toString();
//TODO Auto-generated method stub
try
{
mOutStream=(FileOutputStream) classserialport.getOutputStream();
mOutStream.write(indata.getBytes());
mOutStream.write(' ');
}
catch(IOExceptione)
{
e.printStackTrace();
}
Toast.makeText(MyserialActivity.this,"數據發送成功",Toast.LENGTH_SHORT).show();
sendedit.setText("");
}
});
/*
* 接收數據
* */
finalButton receButton= (Button)findViewById(R.id.button3);
receButton.setOnClickListener(newView.OnClickListener()
{//inttag =0;

@Override
publicvoid onClick(View arg0)
{
// TODO Auto-generated method stub
intsize;
try
{
byte[]buffer = new byte[64];
if(mInStream== null) return;
size= mInStream.read(buffer);
if(size>0)
{
receiveedit.setText("");

}
if(size>0)
{
onDataReceive(buffer,size);
}
inttag =1;

receiveedit.setText(newString(buffer, 0, size));

}catch(IOExceptione)
{
e.printStackTrace();
return;
}
}

privateboolean isInterrupted()
{
// TODO Auto-generated methodstub
returnfalse;
}
});
/*
* 清楚接收區
* */
finalButton ClearButton = (Button)findViewById(R.id.clear);
ClearButton.setOnClickListener(newView.OnClickListener()
{

@Override
publicvoid onClick(View arg0)
{
//TODO Auto-generated method stub
receiveedit.setText("");
}
});}

@Override
publicboolean onCreateOptionsMenu(Menu menu)
{
//Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.myserial,menu);
returntrue;
}

}

好吧你做好了。

3需要載入的文件

下面我把所需要添加的代碼貼一貼

第一個是Serialport.java

/*
* Copyright 2009 Cedric Priscal
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

package android.serialport;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;
import java.util.Iterator;
import java.util.Vector;

import android.util.Log;

public class SerialPortFinder {

/*
* 創建一個驅動程序類
* */
public class Driver {
public Driver(String name, String root) {
mDriverName = name;//String 類型的
mDeviceRoot = root;
}
private String mDriverName;
private String mDeviceRoot;
Vector<File> mDevices = null;
/*
* Vector 類在 java 中可以實現自動增長的對象數組
* 簡單的使用方法如下：
vector<int> test;//建立一個vector
test.push_back(1);
test.push_back(2);//把1和2壓入vector這樣test[0]就是1,test[1]就是2
* */
public Vector<File> getDevices() {
if (mDevices == null) {
mDevices = new Vector<File>();
File dev = new File("/dev");
File[] files = dev.listFiles();
int i;
for (i=0; i<files.length; i++) {
if (files[i].getAbsolutePath().startsWith(mDeviceRoot)) {
Log.d(TAG, "Found new device: " + files[i]);
mDevices.add(files[i]);
}
}
}
return mDevices;
}

public String getName() {
return mDriverName;
}
}
/*
*
*
* */
private static final String TAG = "SerialPort";

private Vector<Driver> mDrivers = null;

Vector<Driver> getDrivers() throws IOException {
if (mDrivers == null) {
mDrivers = new Vector<Driver>();
LineNumberReader r = new LineNumberReader(new FileReader("/proc/tty/drivers"));
String l;
while((l = r.readLine()) != null) {
String[] w = l.split(" +");
if ((w.length == 5) && (w[4].equals("serial"))) {
Log.d(TAG, "Found new driver: " + w[1]);
mDrivers.add(new Driver(w[0], w[1]));
}
}
r.close();
}
return mDrivers;
}

public String[] getAllDevices() {
Vector<String> devices = new Vector<String>();
// Parse each driver
Iterator<Driver> itdriv;
try {
itdriv = getDrivers().iterator();
while(itdriv.hasNext()) {
Driver driver = itdriv.next();
Iterator<File> itdev = driver.getDevices().iterator();
while(itdev.hasNext()) {
String device = itdev.next().getName();
String value = String.format("%s (%s)", device, driver.getName());
devices.add(value);
}
}
} catch (IOException e) {
e.printStackTrace();
}
return devices.toArray(new String[devices.size()]);
}

public String[] getAllDevicesPath() {
Vector<String> devices = new Vector<String>();
// Parse each driver
Iterator<Driver> itdriv;
try {
itdriv = getDrivers().iterator();
while(itdriv.hasNext()) {
Driver driver = itdriv.next();
Iterator<File> itdev = driver.getDevices().iterator();
while(itdev.hasNext()) {
String device = itdev.next().getAbsolutePath();
devices.add(device);
}
}
} catch (IOException e) {
e.printStackTrace();
}
return devices.toArray(new String[devices.size()]);
}
}

第三個是Android.mk

#
# Copyright 2009 Cedric Priscal
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

TARGET_PLATFORM := android-3
LOCAL_MODULE := serial_port
LOCAL_SRC_FILES := SerialPort.c
LOCAL_LDLIBS := -llog

include $(BUILD_SHARED_LIBRARY)

第四個是SerialPort.c

/*
* Copyright 2009 Cedric Priscal
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#include <termios.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <jni.h>

#include "android/log.h"
static const char *TAG="serial_port";
#define LOGI(fmt, args...) __android_log_print(ANDROID_LOG_INFO, TAG, fmt, ##args)
#define LOGD(fmt, args...) __android_log_print(ANDROID_LOG_DEBUG, TAG, fmt, ##args)
#define LOGE(fmt, args...) __android_log_print(ANDROID_LOG_ERROR, TAG, fmt, ##args)

static speed_t getBaudrate(jint baudrate)
{
switch(baudrate) {
case 0: return B0;
case 50: return B50;
case 75: return B75;
case 110: return B110;
case 134: return B134;
case 150: return B150;
case 200: return B200;
case 300: return B300;
case 600: return B600;
case 1200: return B1200;
case 1800: return B1800;
case 2400: return B2400;
case 4800: return B4800;
case 9600: return B9600;
case 19200: return B19200;
case 38400: return B38400;
case 57600: return B57600;
case 115200: return B115200;
case 230400: return B230400;
case 460800: return B460800;
case 500000: return B500000;
case 576000: return B576000;
case 921600: return B921600;
case 1000000: return B1000000;
case 1152000: return B1152000;
case 1500000: return B1500000;
case 2000000: return B2000000;
case 2500000: return B2500000;
case 3000000: return B3000000;
case 3500000: return B3500000;
case 4000000: return B4000000;
default: return -1;
}
}

/*
* Class: cedric_serial_SerialPort
* Method: open
* Signature: (Ljava/lang/String;)V
*/
JNIEXPORT jobject JNICALL Java_android_serialport_SerialPort_open
(JNIEnv *env, jobject thiz, jstring path, jint baudrate)
{
int fd;
speed_t speed;
jobject mFileDescriptor;

/* Check arguments */
{
speed = getBaudrate(baudrate);
if (speed == -1) {
/* TODO: throw an exception */
LOGE("Invalid baudrate");
return NULL;
}
}

/* Opening device */
{
jboolean is;
const char *path_utf = (*env)->GetStringUTFChars(env, path, &is);
LOGD("Opening serial port %s", path_utf);
fd = open(path_utf, O_RDWR | O_DIRECT | O_SYNC);
LOGD("open() fd = %d", fd);
(*env)->ReleaseStringUTFChars(env, path, path_utf);
if (fd == -1)
{
/* Throw an exception */
LOGE("Cannot open port");
/* TODO: throw an exception */
return NULL;
}
}

/* Configure device */
{
struct termios cfg;
LOGD("Configuring serial port");
if (tcgetattr(fd, &cfg))
{
LOGE("tcgetattr() failed");
close(fd);
/* TODO: throw an exception */
return NULL;
}

cfmakeraw(&cfg);
cfsetispeed(&cfg, speed);
cfsetospeed(&cfg, speed);

if (tcsetattr(fd, TCSANOW, &cfg))
{
LOGE("tcsetattr() failed");
close(fd);
/* TODO: throw an exception */
return NULL;
}
}

/* Create a corresponding file descriptor */
{
jclass cFileDescriptor = (*env)->FindClass(env, "java/io/FileDescriptor");
jmethodID iFileDescriptor = (*env)->GetMethodID(env, cFileDescriptor, "<init>", "()V");
jfieldID descriptorID = (*env)->GetFieldID(env, cFileDescriptor, "descriptor", "I");
mFileDescriptor = (*env)->NewObject(env, cFileDescriptor, iFileDescriptor);
(*env)->SetIntField(env, mFileDescriptor, descriptorID, (jint)fd);
}

return mFileDescriptor;
}

/*
* Class: cedric_serial_SerialPort
* Method: close
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_android_serialport_SerialPort_close
(JNIEnv *env, jobject thiz)
{
jclass SerialPortClass = (*env)->GetObjectClass(env, thiz);
jclass FileDescriptorClass = (*env)->FindClass(env, "java/io/FileDescriptor");

jfieldID mFdID = (*env)->GetFieldID(env, SerialPortClass, "mFd", "Ljava/io/FileDescriptor;");
jfieldID descriptorID = (*env)->GetFieldID(env, FileDescriptorClass, "descriptor", "I");

jobject mFd = (*env)->GetObjectField(env, thiz, mFdID);
jint descriptor = (*env)->GetIntField(env, mFd, descriptorID);

LOGD("close(fd = %d)", descriptor);
close(descriptor);
}

③ 寫一段java代碼，調用c程序，都有什麼辦法

JAVA以其跨平台的特性深受人們喜愛，而又正由於它的跨平台的目的，使得它和本地機器的各種內部聯系變得很少，約束了它的功能。解決JAVA對本地操作的一種方法就是JNI。

JAVA通過JNI調用本地方法，而本地方法是以庫文件的形式存放的（在WINDOWS平台上是DLL文件形式，在UNIX機器上是SO文件形式）。通過調用本地的庫文件的內部方法，使JAVA可以實現和本地機器的緊密聯系，調用系統級的各介面方法。

簡單介紹及應用如下：

一、JAVA中所需要做的工作

在JAVA程序中，首先需要在類中聲明所調用的庫名稱，如下：

static {

System.loadLibrary(「goodluck」);

}

在這里，庫的擴展名字可以不用寫出來，究竟是DLL還是SO，由系統自己判斷。

還需要對將要調用的方法做本地聲明，關鍵字為native。並且只需要聲明，而不需要具體實現。如下：

public native static void set(int i);

public native static int get();

然後編譯該JAVA程序文件，生成CLASS，再用JAVAH命令，JNI就會生成C/C++的頭文件。

例如程序testdll.java，內容為：

public class testdll

{

static

{

System.loadLibrary("goodluck");

}

public native static int get();

public native static void set(int i);

public static void main(String[] args)

{

testdll test = new testdll();

test.set(10);

System.out.println(test.get());

}

}

用javac testdll.java編譯它，會生成testdll.class。

再用javah testdll，則會在當前目錄下生成testdll.h文件，這個文件需要被C/C++程序調用來生成所需的庫文件。

二、C/C++中所需要做的工作

對於已生成的.h頭文件，C/C++所需要做的，就是把它的各個方法具體的實現。然後編譯連接成庫文件即可。再把庫文件拷貝到JAVA程序的路徑下面，就可以用JAVA調用C/C++所實現的功能了。

接上例子。我們先看一下testdll.h文件的內容：

/* DO NOT EDIT THIS FILE - it is machine generated */

#include <jni.h>

/* Header for class testdll */

#ifndef _Included_testdll

#define _Included_testdll

#ifdef __cplusplus

extern "C" {

#endif

/*

* Class: testdll

* Method: get

* Signature: ()I

*/

JNIEXPORT jint JNICALL Java_testdll_get

(JNIEnv *, jclass);

/*

* Class: testdll

* Method: set

* Signature: (I)V

*/

JNIEXPORT void JNICALL Java_testdll_set

(JNIEnv *, jclass, jint);

#ifdef __cplusplus

}

#endif

#endif

在具體實現的時候，我們只關心兩個函數原型

JNIEXPORT jint JNICALL Java_testdll_get (JNIEnv *, jclass);

和

JNIEXPORT void JNICALL Java_testdll_set (JNIEnv *, jclass, jint);

這里JNIEXPORT和JNICALL都是JNI的關鍵字，表示此函數是要被JNI調用的。而jint是以JNI為中介使JAVA的int類型與本地的int溝通的一種類型，我們可以視而不見，就當做int使用。函數的名稱是JAVA_再加上java程序的package路徑再加函數名組成的。參數中，我們也只需要關心在JAVA程序中存在的參數，至於JNIEnv*和jclass我們一般沒有必要去碰它。

好，下面我們用testdll.cpp文件具體實現這兩個函數：

#include "testdll.h"

int i = 0;

JNIEXPORT jint JNICALL Java_testdll_get (JNIEnv *, jclass)

{

return i;

}

JNIEXPORT void JNICALL Java_testdll_set (JNIEnv *, jclass, jint j)

{

i = j;

}

編譯連接成庫文件，本例是在WINDOWS下做的，生成的是DLL文件。並且名稱要與JAVA中需要調用的一致，這里就是goodluck.dll

把goodluck.dll拷貝到testdll.class的目錄下，java testdll運行它，就可以觀察到結果了。

導航:首頁 > 源碼編譯 > 編譯jclass程序的命令

編譯jclass程序的命令

與編譯jclass程序的命令相關的資料