Android串口通信开发

下载所需要jni和jniLibs文件

这里我提供了下载地址
jni和jniLibs
下载成功后，将jni和jniLibs这两个文件导入到项目中，且放在main目录下
同时在build.gradle中添加如下代码

sourceSets {main { jni.srcDirs = [] } }

导入SerialPort类

这里需要注意一点，SerialPort类需要直接放在java目录下且需要新建包名android_serialport_api

 private static final String TAG = "SerialPort";
    public FileDescriptor mFd;
    private FileInputStream mFileInputStream;
    private FileOutputStream mFileOutputStream;

	/**
     * @param device 串口号
     * @param baudrate 波特率
     * @param dataBits 数据位
     * @param stopBits 停止位
     * @param parity 奇偶检验
     * @throws SecurityException
     * @throws IOException
     */
    pubic SerialPort(File device, int baudrate, int dataBits, int stopBits, char parity) throws SecurityException, IOException {

        //检查访问权限，如果没有读写权限，进行文件操作，修改文件访问权限
        if (!device.canRead() || !device.canWrite()) {

            try {
                //通过挂载到linux的方式，修改文件的操作权限
                Process 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()) {
                    Log.e("SerialPort", "SerialPort: 没有权限");
                    throw new SecurityException();
                }
            } catch (Exception e) {
                e.printStackTrace();
                throw new SecurityException();
            }
        }

        mFd = open(device.getAbsolutePath(), baudrate, dataBits,stopBits,parity);

        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(调用java本地接口，实现串口的打开和关闭)
    private native static FileDescriptor open(String path, int baudrate, int dataBits, int stopBits, char parity);
    //关闭串口
    public native void close();

    static {//加载jni下的C文件库
        Log.d(TAG, "本地库加载中");
        System.loadLibrary("serial_port");
    }

新建串口工具类SerialPortUtils

 private final String TAG = "SerialPortUtils";
    private String path = "串口地址";
    private int baudrate = 波特率;
    public boolean serialPortStatus = false; //是否打开串口标志
    public String data_;//已发送的数据
    public boolean threadStatus; //线程状态，为了安全终止线程

    public SerialPort serialPort = null;
    public InputStream inputStream = null;
    public OutputStream outputStream = null;
    public ChangeTool changeTool = new ChangeTool();


    /**
     * 打开串口
     *
     * @return serialPort串口对象
     */
    public SerialPort openSerialPort() {
        try {
            //这里的数据位、停止位以及奇偶检验根据你们的实际情况来定
            serialPort = new SerialPort(new File(path), baudrate, 8,1,'N');
            this.serialPortStatus = true;
            threadStatus = false; //线程状态

            //获取打开的串口中的输入输出流，以便于串口数据的收发
            inputStream = serialPort.getInputStream();
            outputStream = serialPort.getOutputStream();

            new ReadThread().start(); //开始线程监控是否有数据要接收
        } catch (IOException e) {
            Log.e(TAG, "openSerialPort: 打开串口异常：" + e.toString());
            return serialPort;
        }
        Log.d(TAG, "openSerialPort: 打开串口");
        return serialPort;
    }

    /**
     * 关闭串口
     */
    public void closeSerialPort() {
        try {
            inputStream.close();
            outputStream.close();

            this.serialPortStatus = false;
            this.threadStatus = true; //线程状态
            serialPort.close();
        } catch (IOException e) {
            Log.e(TAG, "closeSerialPort: 关闭串口异常：" + e.toString());
            return;
        }
        Log.d(TAG, "closeSerialPort: 关闭串口成功");
    }

    /**
     * 发送串口指令（字符串）
     *
     * @param data String数据指令
     */
    public void sendSerialPort(String data) {
        Log.d(TAG, "sendSerialPort: 发送数据");

        try {
            byte[] sendData = data.getBytes(); //string转byte[]
            this.data_ = new String(sendData); //byte[]转string
            if (sendData.length > 0) {
                outputStream.write(sendData);
                outputStream.write('\n');
                outputStream.flush();
                Log.d(TAG, "sendSerialPort: 串口数据发送成功");
            }
        } catch (IOException e) {
            Log.e(TAG, "sendSerialPort: 串口数据发送失败：" + e.toString());
        }

    }

    /**
     * 单开一线程，来读数据
     */
    private class ReadThread extends Thread {
        @Override
        public void run() {
            super.run();
            //判断进程是否在运行，更安全的结束进程
            while (!threadStatus) {
                Log.d(TAG, "进入线程run");
                //64   1024
                byte[] buffer = new byte[32];
                int size; //读取数据的大小
                try {
                    size = inputStream.read(buffer);
                    if (size > 0) {
                        Log.i(TAG, "run: 接收到了数据：" + changeTool.ByteArrToHex(buffer));
                        Log.i(TAG, "run: 接收到了数据大小：" + String.valueOf(size));
                        Log.i(TAG, "run: 接收到的数据：：" + new String(buffer));
                        onDataReceiveListener.onDataReceive(buffer, size);
                    }
                } catch (IOException e) {
                    Log.e(TAG, "run: 数据读取异常：" + e.toString());
                }
            }

        }
    }

    public OnDataReceiveListener onDataReceiveListener = null;

    public static interface OnDataReceiveListener {
        public void onDataReceive(byte[] buffer, int size);
    }

    public void setOnDataReceiveListener(OnDataReceiveListener dataReceiveListener) {
        onDataReceiveListener = dataReceiveListener;
    }

在Activity中的具体操作

private SerialPortUtils serialPortUtils = new SerialPortUtils();
private SerialPort serialPort;
//然后创建主线程的handler，用于更新UI
handler = new Handler(); 
//打开串口
serialPort = serialPortUtils.openSerialPort();
//向串口发送数据
 serialPortUtils.sendSerialPort("数据");
 //这里可以打印看下是否发送成功
 Log.i(TAG,"发送的内容："+serialPortUtils.data_)
 //串口数据的监听事件
  serialPortUtils.setOnDataReceiveListener(new SerialPortUtils.OnDataReceiveListener() {
            @Override
            public void onDataReceive(byte[] buffer, int size) {
                Log.d(TAG, "由串口发送过来的数据" + new String(buffer));
                //在线程中直接操作UI会报异常 解决方法：handler
                mBuffer = buffer;
                handler.post(runnable);
            }
            //开线程更新UI
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                   //需要更新的UI操作
               }
           };
  });
  //关闭串口
serialPortUtils.closeSerialPort();

到这就全部结束啦，谢谢