钥匙柜

weimingfei

4 天以前 c7376f8d1091b70597ba4430a281496b585b386e

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
package com.doumee.keyCabinet.utils.i485;
 
import android.serialport.SerialPort;
import android.util.Log;
 
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
 
public class SerialPortModel {
 
    public static final String TAG = SerialPortModel.class.getSimpleName();
 
    private void logI(String str) {
        Log.i(TAG, str);
    }
 
    private String serialPortPath;
    private int baudrate;
    private int dataBits;
    private int stopBits;
    private int parity;
    private SerialPort serialPort;
    private ScheduledExecutorService scheduledExecutorService;
    private ExecutorService singleThreadExecutor;
    private ScheduledFuture scheduledFuture;
    private SerialPortReadObserver serialPortReadObserver;
    private boolean isOk = false;
 
    private final Object writeLock = new Object();
 
    public SerialPortModel(String serialPortPath, int baudrate, int dataBits, int stopBits, int parity,SerialPortReadObserver portReadObserver) {
        this.serialPortPath = serialPortPath;
        this.baudrate = baudrate;
        this.dataBits = dataBits;
        this.stopBits = stopBits;
        this.parity = parity;
        this.serialPortReadObserver = portReadObserver;
    }
 
    public boolean open() {
        try {
            File device = new File(serialPortPath);
            serialPort = SerialPort
                    .newBuilder(device, baudrate)
                    .dataBits(dataBits)
                    .stopBits(stopBits)
                    .parity(parity)
                    .build();
            scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
            singleThreadExecutor = Executors.newSingleThreadExecutor();
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
 
    public void close() {
        try {
            serialPort.getInputStream().close();
            serialPort.getOutputStream().close();
            serialPort.close();
            serialPort = null;
            scheduledExecutorService.shutdown();
            singleThreadExecutor.shutdown();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public void startRead() {
        scheduledFuture = scheduledExecutorService.scheduleWithFixedDelay(() -> {
            InputStream inputStream = serialPort.getInputStream();
            byte[] bytes = new byte[2048];
            int length = 0;
            try {
                length = inputStream.read(bytes);
            } catch (IOException e) {
                e.printStackTrace();
            }
//            logI("startRead - length: " + length);
            if (length <= 0) return;
            //String result = new String(bytes, 0, length);
            byte[] bytes2 = new byte[length];
            for(int i=0;i<length;i++){
                bytes2[i] = bytes[i];
            }
            if(serialPortReadObserver!=null) {
                serialPortReadObserver.onResultBytes(bytes2);
            }
        }, 0, 100, TimeUnit.MILLISECONDS);
    }
 
    public void stopRead() {
        scheduledFuture.cancel(true);
    }
 
    public void write(byte[] bytes) {
        singleThreadExecutor.execute(() -> {
            synchronized (writeLock) {
                try {
                    serialPort.getOutputStream().write(bytes);
                    if(serialPortReadObserver!=null) {
                        serialPortReadObserver.onResult(null);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                    if(serialPortReadObserver!=null) {
                        serialPortReadObserver.onResult(e.getMessage());
                    }
                }
            }
        });
    }
 
    public boolean isOk() {
        return isOk;
    }
 
    public void setOk(boolean ok) {
        isOk = ok;
    }
}