android 读取串口数据的服务

2016-09-1813:10:03

继承Service，定义抽象方法onDataReceived，子类通过实现抽象方法获取接收到数据的回调。

 package com.zrsoft.liftad.serialport;

 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;

 import android.app.Service;
 import android_serialport_api.SerialPort;

 import com.zrsoft.liftad.MyApp;
 import com.zrsoft.liftad.utils.Logger;

 public abstract class SerialPortService extends Service {

     protected SerialPort mSerialPort;
     protected OutputStream mOutputStream;
     private InputStream mInputStream;
     private ReadThread mReadThread;

     private class ReadThread extends Thread {
         byte[] buffer = new byte[128];

         @Override
         public void run() {
             super.run();
             while (!isInterrupted()) {
                 int size;
                 try {

                     if (mInputStream == null)
                         return;
                     size = mInputStream.read(buffer);
                     if (size > 0) {
                         onDataReceived(buffer, size);
                     }
                 } catch (IOException e) {
                     e.printStackTrace();
                     return;
                 }
             }
         }
     }

     @Override
     public void onCreate() {
         try {
             mSerialPort = new SerialPort(new File("/dev/ttyS3"), 9600, 0);
             mOutputStream = mSerialPort.getOutputStream();
             mInputStream = mSerialPort.getInputStream();

             mReadThread = new ReadThread();
             mReadThread.start();
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

     protected abstract void onDataReceived(final byte[] buffer, final int size);

     @Override
     public void onDestroy() {
         if (mReadThread != null){
             mReadThread.interrupt();
         }
         if (mSerialPort != null) {
             mSerialPort.close();
             mSerialPort = null;
         }
         mSerialPort = null;
         super.onDestroy();
     }
 }

SerialPort 类：

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

 package android_serialport_api;

 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;

 import android.util.Log;

 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, int flags) throws SecurityException, IOException {
         try {
             System.loadLibrary("serial_port");
         } catch (Exception ex) {
             Log.d("asdf", ex.getMessage());
         }
         /* 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();
             }
         }
         Log.d("port", "open ready");
         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");
     }
 }