Android串口通信：串口读写实例

http://gqdy365.iteye.com/blog/2188906 作者地址

在Android串口通信：基本知识梳理（http://gqdy365.iteye.com/admin/blogs/2188846）的基础上，我结合我项目中使用串口的实例，进行总结； 

Android使用jni直接进行串口设备的读写网上已经有开源项目了，本文是基于网上的开源项目在实际项目中的使用做的调整和优化； 
Google串口开源项目见：https://code.google.com/p/android-serialport-api/ 

下面是我项目中的相关代码及介绍： 

1、SerialPort.cpp 

/* 
 * 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 copy 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 <stdlib.h>  
#include <stdio.h>  
#include <jni.h>  
#include <assert.h>  
  
#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 native_open(JNIEnv *env, jobject thiz, jstring path,jint baudrate) {  
    int fd;  
    speed_t speed;  
    jobject mFileDescriptor;  
  
    LOGD("init native Check arguments");  
    /* Check arguments */  
    {  
        speed = getBaudrate(baudrate);  
        if (speed == -1) {  
            /* TODO: throw an exception */  
            LOGE("Invalid baudrate");  
            return NULL;  
        }  
    }  
  
    LOGD("init native Opening device!");  
    /* Opening device */  
    {  
        jboolean iscopy;  
        const char *path_utf = env->GetStringUTFChars(path, &iscopy);  
        LOGD("Opening serial port %s", path_utf);  
//      fd = open(path_utf, O_RDWR | O_DIRECT | O_SYNC);  
        fd = open(path_utf, O_RDWR | O_NOCTTY | O_NONBLOCK | O_NDELAY);  
        LOGD("open() fd = %d", fd);  
        env->ReleaseStringUTFChars(path, path_utf);  
        if (fd == -1) {  
            /* Throw an exception */  
            LOGE("Cannot open port %d",baudrate);  
            /* TODO: throw an exception */  
            return NULL;  
        }  
    }  
  
    LOGD("init native Configure device!");  
    /* Configure device */  
    {  
        struct termios cfg;  
        if (tcgetattr(fd, &cfg)) {  
            LOGE("Configure device tcgetattr() failed 1");  
            close(fd);  
            return NULL;  
        }  
  
        cfmakeraw(&cfg);  
        cfsetispeed(&cfg, speed);  
        cfsetospeed(&cfg, speed);  
  
        if (tcsetattr(fd, TCSANOW, &cfg)) {  
            LOGE("Configure device tcsetattr() failed 2");  
            close(fd);  
            /* TODO: throw an exception */  
            return NULL;  
        }  
    }  
  
    /* Create a corresponding file descriptor */  
    {  
        jclass cFileDescriptor = env->FindClass("java/io/FileDescriptor");  
        jmethodID iFileDescriptor = env->GetMethodID(cFileDescriptor,"<init>", "()V");  
        jfieldID descriptorID = env->GetFieldID(cFileDescriptor,"descriptor", "I");  
        mFileDescriptor = env->NewObject(cFileDescriptor,iFileDescriptor);  
        env->SetIntField(mFileDescriptor, descriptorID, (jint) fd);  
    }  
  
    return mFileDescriptor;  
}  
  
/* 
 * Class:     cedric_serial_SerialPort 
 * Method:    close 
 * Signature: ()V 
 */  
JNIEXPORT jint JNICALL native_close(JNIEnv * env, jobject thiz)  
{  
    jclass SerialPortClass = env->GetObjectClass(thiz);  
    jclass FileDescriptorClass = env->FindClass("java/io/FileDescriptor");  
  
    jfieldID mFdID = env->GetFieldID(SerialPortClass, "mFd", "Ljava/io/FileDescriptor;");  
    jfieldID descriptorID = env->GetFieldID(FileDescriptorClass, "descriptor", "I");  
  
    jobject mFd = env->GetObjectField(thiz, mFdID);  
    jint descriptor = env->GetIntField(mFd, descriptorID);  
  
    LOGD("close(fd = %d)", descriptor);  
    close(descriptor);  
    return 1;  
}  
  
static JNINativeMethod gMethods[] = {  
        { "open", "(Ljava/lang/String;I)Ljava/io/FileDescriptor;",(void*) native_open },  
        { "close", "()I",(void*) native_close },  
};  
  
/* 
 * 为某一个类注册本地方法 
 */  
static int registerNativeMethods(JNIEnv* env, const char* className,  
        JNINativeMethod* gMethods, int numMethods) {  
    jclass clazz;  
    clazz = env->FindClass(className);  
    if (clazz == NULL) {  
        return JNI_FALSE;  
    }  
    if (env->RegisterNatives(clazz, gMethods, numMethods) < 0) {  
        return JNI_FALSE;  
    }  
  
    return JNI_TRUE;  
}  
  
/* 
 * 为所有类注册本地方法 
 */  
static int registerNatives(JNIEnv* env) {  
    const char* kClassName = "com/jerome/serialport/SerialPort"; //指定要注册的类  
    return registerNativeMethods(env, kClassName, gMethods,  
            sizeof(gMethods) / sizeof(gMethods[0]));  
}  
  
/* 
 * System.loadLibrary("lib")时调用 
 * 如果成功返回JNI版本, 失败返回-1 
 */  
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) {  
    JNIEnv* env = NULL;  
    jint result = -1;  
  
    if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {  
        return -1;  
    }  
    assert(env != NULL);  
  
    if (!registerNatives(env)) { //注册  
        return -1;  
    }  
    //成功  
    result = JNI_VERSION_1_4;  
  
    return result;  
}  

在编译时注意修改const char* kClassName = "com/jerome/serialport/SerialPort";为你Java层与jni对应得包名； 

2、Android.mk 

LOCAL_PATH := $(call my-dir)  
  
include $(CLEAR_VARS)  
  
TARGET_PLATFORM := android-3  
LOCAL_MODULE    := serial_port  
LOCAL_SRC_FILES := SerialPort.cpp  
LOCAL_LDLIBS    := -llog  
  
include $(BUILD_SHARED_LIBRARY)  

如果要修改生成so文件的名称，请修改LOCAL_MODULE    := serial_port 

3、SerialPort.java 

package com.jerome.serialport;  
  
import java.io.File;  
import java.io.FileDescriptor;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.OutputStream;  
  
public class 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) throws SecurityException, IOException {  
        mFd = open(device.getAbsolutePath(), baudrate);  
        if (mFd == null) {  
            throw new IOException();  
        }  
        mFileInputStream = new FileInputStream(mFd);  
        mFileOutputStream = new FileOutputStream(mFd);  
    }  
  
    public InputStream getInputStream() {  
        return mFileInputStream;  
    }  
  
    public OutputStream getOutputStream() {  
        return mFileOutputStream;  
    }  
  
    private native FileDescriptor open(String path, int baudrate);  
    public native int close();  
  
    static {  
        System.loadLibrary("serial_port");  
    }  
}  

4、SerialPortUtil.java 

package com.jerome.serialport;  
  
import java.io.BufferedWriter;  
import java.io.File;  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.OutputStream;  
import java.io.OutputStreamWriter;  
import java.io.PrintWriter;  
  
/** 
 * 串口操作类 
 *  
 * @author Jerome 
 *  
 */  
public class SerialPortUtil {  
    private String TAG = SerialPortUtil.class.getSimpleName();  
    private SerialPort mSerialPort;  
    private OutputStream mOutputStream;  
    private InputStream mInputStream;  
    private ReadThread mReadThread;  
    private String path = "/dev/ttyMT1";  
    private int baudrate = 115200;  
    private static SerialPortUtil portUtil;  
    private OnDataReceiveListener onDataReceiveListener = null;  
    private boolean isStop = false;  
  
    public interface OnDataReceiveListener {  
        public void onDataReceive(byte[] buffer, int size);  
    }  
  
    public void setOnDataReceiveListener(  
            OnDataReceiveListener dataReceiveListener) {  
        onDataReceiveListener = dataReceiveListener;  
    }  
      
    public static SerialPortUtil getInstance() {  
        if (null == portUtil) {  
            portUtil = new SerialPortUtil();  
            portUtil.onCreate();  
        }  
        return portUtil;  
    }  
  
    /** 
     * 初始化串口信息 
     */  
    public void onCreate() {  
        try {  
            mSerialPort = new SerialPort(new File(path), baudrate);  
            mOutputStream = mSerialPort.getOutputStream();  
            mInputStream = mSerialPort.getInputStream();  
              
            mReadThread = new ReadThread();  
            isStop = false;  
            mReadThread.start();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        initBle();  
    }  
  
    /** 
     * 发送指令到串口 
     *  
     * @param cmd 
     * @return 
     */  
    public boolean sendCmds(String cmd) {  
        boolean result = true;  
        byte[] mBuffer = (cmd+"\r\n").getBytes();  
//注意：我得项目中需要在每次发送后面加\r\n，大家根据项目项目做修改，也可以去掉，直接发送mBuffer  
        try {  
            if (mOutputStream != null) {  
                mOutputStream.write(mBuffer);  
            } else {  
                result = false;  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
            result = false;  
        }  
        return result;  
    }  
  
    public boolean sendBuffer(byte[] mBuffer) {  
        boolean result = true;  
        String tail = "\r\n";  
        byte[] tailBuffer = tail.getBytes();  
        byte[] mBufferTemp = new byte[mBuffer.length+tailBuffer.length];  
        System.arraycopy(mBuffer, 0, mBufferTemp, 0, mBuffer.length);  
        System.arraycopy(tailBuffer, 0, mBufferTemp, mBuffer.length, tailBuffer.length);  
//注意：我得项目中需要在每次发送后面加\r\n，大家根据项目项目做修改，也可以去掉，直接发送mBuffer  
        try {  
            if (mOutputStream != null) {  
                mOutputStream.write(mBufferTemp);  
            } else {  
                result = false;  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
            result = false;  
        }  
        return result;  
    }  
  
    private class ReadThread extends Thread {  
  
        @Override  
        public void run() {  
            super.run();  
            while (!isStop && !isInterrupted()) {  
                int size;  
                try {  
                    if (mInputStream == null)  
                        return;  
                    byte[] buffer = new byte[512];  
                    size = mInputStream.read(buffer);  
                    if (size > 0) {  
                        if(MyLog.isDyeLevel()){  
                            MyLog.log(TAG, MyLog.DYE_LOG_LEVEL, "length is:"+size+",data is:"+new String(buffer, 0, size));  
                        }  
                        if (null != onDataReceiveListener) {  
                            onDataReceiveListener.onDataReceive(buffer, size);  
                        }  
                    }  
                    Thread.sleep(10);  
                } catch (Exception e) {  
                    e.printStackTrace();  
                    return;  
                }  
            }  
        }  
    }  
  
    /** 
     * 关闭串口 
     */  
    public void closeSerialPort() {  
        sendShellCommond1();  
        isStop = true;  
        if (mReadThread != null) {  
            mReadThread.interrupt();  
        }  
        if (mSerialPort != null) {  
            mSerialPort.close();  
        }  
    }  
      
}  

5、使用方法： 
a、配置ndk开发环境，具体百度一下； 
b、工程根目录下新建jni文件夹，将Android.mk和SerialPort.cpp放进去； 
c、ndk中进入jni目录，编译生成so文件，默认so生成在libs/armeabi下； 
d、新建com.jerom.serialport目录，将SerialPort和SerialPortUtil放进去； 
f、在你要使用的地方初始化SerialPortUtil，实现回调接口OnDataReceiveListener即可接受数据； 


总结： 
1、串口发送实质就是向串口设备（类似于文件操作）写入字节流，串口读取也是一样； 
2、主要jni与Java native得对应；