Android 的串口編程開發。

Android的串口編程有兩種方法能夠實現。

第一種，使用Android封裝好的API便可操做串口。

android4.2的SDK中已經集成了對串口的JNI和一些串口的服務接口，能夠在framework中找到。裏面主要封裝了兩個類.

  android.hardware.SerialManager

  android.hardware.SerialPort

經過上面兩個類能夠實現對串口的打開，和讀寫操做。可是這個方法有一個坑，就是這兩個類要在編譯系統的時候將它激活，不然在應用層沒法調用這兩個類。具體方法參照：http://blog.csdn.net/jancyliu/article/details/8954896。demo下載地址爲：            http://pan.baidu.com/s/1qWNsRTU

第二種，就要運用一些ndk的知識了。

無論是windows、linux、或是android操做系統，串口編程無非是如下幾步：

打開串口

串口配置

串口操做（讀寫）

關閉串口

操做很簡單，在C語言裏無非就是open、write、read、close幾個操做就能輕鬆搞定的東西。這跟文件的輸入輸出流實際上是一個概念，因此在windows中能夠用CreateFile操做串口，一樣的道理，在java中能夠使用FileDescriptor操做串口。

下面是android 串口編程的具體步驟，先建立一個串口類SerialPort：

private static final String TAG = "SerialPort";  

  

/* 

 * Do not remove or rename the field mFd: it is used by native method close(); 

 */  

private FileDescriptor mFd;  

private FileInputStream mFileInputStream;  

private FileOutputStream mFileOutputStream;  

  public SerialPort(File device, int baudrate, int flags) throws SecurityException, IOException {   

    /* Check access permission */  

    if (!device.canRead() || !device.canWrite()) {  

        try {  

            /* Missing read/write permission, trying to chmod the file */  

            Process su;  

            su = Runtime.getRuntime().exec("/system/bin/su");  

            String cmd = "chmod 666 " + device.getAbsolutePath() + "\n"+ "exit\n";  

            su.getOutputStream().write(cmd.getBytes());  

            if ((su.waitFor() != 0) || !device.canRead()  

                    || !device.canWrite()) {  

                throw new SecurityException();  

           }  

        } catch (Exception e) {  

            e.printStackTrace();  

            throw new SecurityException();  

        }  

    }    

    mFd = open(device.getAbsolutePath(), baudrate, flags);  

    if (mFd == null) {  

        Log.e(TAG, "native open returns null");  

        throw new IOException();  

    }  

    mFileInputStream = new FileInputStream(mFd);  

    mFileOutputStream = new FileOutputStream(mFd);  

}    

// Getters and setters  

public InputStream getInputStream() {  

    return mFileInputStream;  

}    

public OutputStream getOutputStream() {  

    return mFileOutputStream;  

}    

// JNI  

private native static FileDescriptor open(String path, int baudrate, int flags);  

public native void close();  

static {  

    System.loadLibrary("serial_port");  

}  

這個類中主要乾了兩件事情：
建立了打開串口和關閉串口的本地方法

private native static FileDescriptor open(String path, int baudrate, int flags);  

public native void close();  

關聯串口的文件描述符（FileDescriptor），並把文件的輸入輸出流與之關聯，在代碼之中

private FileDescriptor mFd;  

private FileInputStream mFileInputStream;  

private FileOutputStream mFileOutputStream;    

mFd = open(device.getAbsolutePath(), baudrate, flags);  

mFileInputStream = new FileInputStream(mFd);  

mFileOutputStream = new FileOutputStream(mFd);  

這段代碼的意思就是把串口打開，並取得串口的輸入輸出操做（讀寫操做）。

到了這裏，有個問題，如何打開串口？

代碼上可知，打開串口的操做用的是一個本地方法open，那隻能在JNI中實現這個接口，下面是jni中的實現：

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:     android_serialport_SerialPort 

 * Method:    open 

 * Signature: (Ljava/lang/String;II)Ljava/io/FileDescriptor; 

 */  

JNIEXPORT jobject JNICALL Java_android_1serialport_1api_SerialPort_open  

  (JNIEnv *env, jclass thiz, jstring path, jint baudrate, jint flags)  

{  

    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 iscopy;  

        const char *path_utf = (*env)->GetStringUTFChars(env, path, &iscopy);  

        LOGD("Opening serial port %s with flags 0x%x", path_utf, O_RDWR | flags);  

        fd = open(path_utf, O_RDWR | flags);  

        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_1serialport_1api_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_android_1serialport_1api_SerialPort_open接口中，能發現一些熟悉的東西：

fd = open(path_utf, O_RDWR | flags);  

tcgetattr(fd, &cfg)  

cfmakeraw(&cfg);  

cfsetispeed(&cfg, speed);  

cfsetospeed(&cfg, speed);  
這些都是在linux下的串口編程，分別是打開串口設備節點，配置數據流控、波特率等，這些東西其實不是重點，重點是如何把打開的串口設備與FileDescriptor關聯，即把fd封裝到FileDescriptor中去：

/* 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;  

上面的代碼簡單解釋來講就是mFileDescriptor與fd關聯並返回給JAVA層。

至此，其實串口的JAVA封裝已經完成，這個類其實已經能夠完成串口的全部操做（打開，配置，讀寫，關閉），接下來的事情只是邏輯層面的事情了。