Android中怎么实现串口读写

这篇文章给大家介绍Android中怎么实现串口读写，内容非常详细，感兴趣的小伙伴们可以参考借鉴，希望对大家能有所帮助。

1、SerialPort.cpp

#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即可接受数据；

关于Android中怎么实现串口读写就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到。