android 读取串口数据的服务

             1
            package
             com.zrsoft.liftad.serialport;

             2
             3
            import
             java.io.File;

             4
            import
             java.io.IOException;

             5
            import
             java.io.InputStream;

             6
            import
             java.io.OutputStream;

             7
             8
            import
             android.app.Service;

             9
            import
             android_serialport_api.SerialPort;

            10
            11
            import
             com.zrsoft.liftad.MyApp;

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

            13
            14
            public
            abstract
            class SerialPortService extends Service {
1517protected SerialPort mSerialPort;
18protected OutputStream mOutputStream;
19private InputStream mInputStream;
20private ReadThread mReadThread;
2122privateclass ReadThread extends Thread {
23byte[] buffer = newbyte[128];
2425        @Override
26publicvoid run() {
27super.run();
28while (!isInterrupted()) {
29int size;
30try {
3132if (mInputStream == null)
33return;
34                     size = mInputStream.read(buffer);
35if (size > 0) {
36                        onDataReceived(buffer, size); 38                    }
39                 } catch (IOException e) {
40                    e.printStackTrace();
41return;
42                }
43            }
44        }
45    }
4647    @Override
48publicvoid onCreate() { 50try { 52             mSerialPort = new SerialPort(new File("/dev/ttyS3"), 9600, 0);
53             mOutputStream = mSerialPort.getOutputStream();
54             mInputStream = mSerialPort.getInputStream();
5556             mReadThread = new ReadThread();
57            mReadThread.start();
58         } catch (Exception e) {
59            e.printStackTrace();
60        }
61    }
6263protectedabstractvoid onDataReceived(finalbyte[] buffer, finalint size);
6465    @Override
66publicvoid onDestroy() {
67if (mReadThread != null){
68            mReadThread.interrupt();
69        }
70if (mSerialPort != null) {
71            mSerialPort.close();
72             mSerialPort = null;
73        } 75         mSerialPort = null;
76super.onDestroy();
77    }
78 }

             1
            /*
             2
             * Copyright 2009 Cedric Priscal

             3
             * 

             4
             * Licensed under the Apache License, Version 2.0 (the "License");

             5
             * you may not use this file except in compliance with the License.

             6
             * You may obtain a copy of the License at

             7
             * 

             8
             * 
            http://www.apache.org/licenses/LICENSE-2.0
             9
             * 

            10
             * Unless required by applicable law or agreed to in writing, software

            11
             * distributed under the License is distributed on an "AS IS" BASIS,

            12
             * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

            13
             * See the License for the specific language governing permissions and

            14
             * limitations under the License. 

            15
            */
            16
            17
            package
             android_serialport_api;

            18
            19
            import
             java.io.File;

            20
            import
             java.io.FileDescriptor;

            21
            import
             java.io.FileInputStream;

            22
            import
             java.io.FileOutputStream;

            23
            import
             java.io.IOException;

            24
            import
             java.io.InputStream;

            25
            import
             java.io.OutputStream;

            26
            27
            import
             android.util.Log;

            28
            29
            public
            class
             SerialPort {

            30
            private
            static
            final String TAG = "SerialPort";
3132/*33     * Do not remove or rename the field mFd: it is used by native method
34     * close();
35*/36private FileDescriptor mFd;
37private FileInputStream mFileInputStream;
38private FileOutputStream mFileOutputStream;
3940public SerialPort(File device, int baudrate, int flags) throws SecurityException, IOException {
41try {
42             System.loadLibrary("serial_port");
43         } catch (Exception ex) {
44             Log.d("asdf", ex.getMessage());
45        }
46/* Check access permission */47if (!device.canRead() || !device.canWrite()) {
48try {
49/* Missing read/write permission, trying to chmod the file */50                Process su;
51                 su = Runtime.getRuntime().exec("/system/bin/su");
52                 String cmd = "chmod 666 " + device.getAbsolutePath() + "\n" + "exit\n";
53                su.getOutputStream().write(cmd.getBytes());
54if ((su.waitFor() != 0) || !device.canRead() || !device.canWrite()) {
55thrownew SecurityException();
56                }
57             } catch (Exception e) {
58                e.printStackTrace();
59thrownew SecurityException();
60            }
61        }
62         Log.d("port", "open ready");
63         mFd = open(device.getAbsolutePath(), baudrate, flags);
64if (mFd == null) {
65             Log.e(TAG, "native open returns null");
66thrownew IOException();
67        }
68         mFileInputStream = new FileInputStream(mFd);
69         mFileOutputStream = new FileOutputStream(mFd);
70    }
7172// Getters and setters73public InputStream getInputStream() {
74return mFileInputStream;
75    }
7677public OutputStream getOutputStream() {
78return mFileOutputStream;
79    }
8081// JNI82privatenativestatic FileDescriptor open(String path, int baudrate, int flags);
8384publicnativevoid close();
8586static {
87         System.loadLibrary("serial_port");
88    }
89 }