门口机增加433无线模块，用于充当网关功能，将433信号转发给服务器

app/src/main/code/com/wdkl/app/ncs/application/Application.kt

@@ -16,6 +16,7 @@ import com.wdkl.app.ncs.callingdoor.helper.Utils
 import com.wdkl.app.ncs.callingdoor.helper.XCrashUtils
 import com.wdkl.app.ncs.callingdoor.settings.SettingConfig
 import serialporttest.utils.SerialPortUtil
+import serialporttest.utils.SerialPortUtil433
 
 /**
  * @author LDD
@@ -94,6 +95,9 @@ class Application : BaseApplication() {
         //open serial port
         if ("rk3128".equals(Build.MODEL) || "rk3368".equals(Build.MODEL)) {
             SerialPortUtil.getInstance().openSerialPort()
+
+            //打开433串口0
+            SerialPortUtil433.getInstance().openSerialPort()
         }
 
         //屏幕适配方案

bedlib/src/main/java/android_serialport_api/SerialPort.java

@@ -2,6 +2,7 @@ package android_serialport_api;
 
 import android.util.Log;
 
+import java.io.DataOutputStream;
 import java.io.File;
 import java.io.FileDescriptor;
 import java.io.FileInputStream;
@@ -16,35 +17,71 @@ public class SerialPort {
     private FileDescriptor mFd;
     private FileInputStream mFileInputStream;
     private FileOutputStream mFileOutputStream;
+    private Callback callback;
 
-    public SerialPort(File device, int baudrate, int flags) throws SecurityException, IOException {
+    public SerialPort() {
+    }
+
+    public void open(final File device, final int baudrate, final int flags) throws SecurityException, IOException {
 
         //检查访问权限，如果没有读写权限，进行文件操作，修改文件访问权限
         if (!device.canRead() || !device.canWrite()) {
-            try {
-                //通过挂载到linux的方式，修改文件的操作权限
-                Process su = Runtime.getRuntime().exec("/system/xbin/su");
-                String cmd = "chmod 777 " + device.getAbsolutePath() + "\n" + "exit\n";
-                su.getOutputStream().write(cmd.getBytes());
-
-                if ((su.waitFor() != 0) || !device.canRead() || !device.canWrite()) {
-                    throw new SecurityException();
+            new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    try {
+                        //修改文件的操作权限
+                        Process p = Runtime.getRuntime().exec("su");
+                        OutputStream op = p.getOutputStream();
+                        DataOutputStream os = new DataOutputStream(op);
+                        String cmd = "chmod 777 " + device.getAbsolutePath() + "\n";
+                        os.writeBytes(cmd);
+                        os.writeBytes("exit\n");
+                        os.flush();
+                        os.close();
+                        op.close();
+                        Log.d(TAG, "start open serialPort:---- " + device.getAbsolutePath());
+
+                        //等待5s后再打开串口
+                        Thread.sleep(3000L);
+
+                        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);
+
+                        if (callback != null) {
+                            callback.onOpen(true);
+                        }
+
+                        Log.d(TAG, "open serialPort success: " + device.getAbsolutePath());
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                        throw new SecurityException();
+                    }
                 }
-            } catch (Exception e) {
-                e.printStackTrace();
-                throw new SecurityException();
+            }).start();
+        } else {
+            mFd = open(device.getAbsolutePath(), baudrate, flags);
+
+            if (mFd == null) {
+                Log.e(TAG, "native open returns null");
+                throw new IOException();
             }
-        }
 
-        mFd = open(device.getAbsolutePath(), baudrate, flags);
+            mFileInputStream = new FileInputStream(mFd);
+            mFileOutputStream = new FileOutputStream(mFd);
 
-        if (mFd == null) {
-            Log.e(TAG, "native open returns null");
-            throw new IOException();
-        }
+            if (callback != null) {
+                callback.onOpen(true);
+            }
 
-        mFileInputStream = new FileInputStream(mFd);
-        mFileOutputStream = new FileOutputStream(mFd);
+            Log.d(TAG, "open serialPort success: " + device.getAbsolutePath());
+        }
     }
 
     // Getters and setters
@@ -56,6 +93,13 @@ public class SerialPort {
         return mFileOutputStream;
     }
 
+    public void setCallback(Callback callback) {
+        this.callback = callback;
+    }
+
+    public interface Callback {
+        void onOpen(boolean success);
+    }
 
     // JNI(调用java本地接口，实现串口的打开和关闭)
 /**串口有五个重要的参数：串口设备名，波特率，检验位，数据位，停止位

bedlib/src/main/java/serialporttest/utils/SerialPortUtil.java

@@ -57,15 +57,21 @@ public class SerialPortUtil {
      * 打开串口的方法
      */
     public void openSerialPort() {
-        Log.i(TAG, "打开串口");
+        Log.i(TAG, "打开串口1");
         try {
-            serialPort = new SerialPort(new File("/dev/" + getSystemPort()), getSystemBaudrate(), 0);
-            //获取打开的串口中的输入输出流，以便于串口数据的收发
-            inputStream = serialPort.getInputStream();
-            outputStream = serialPort.getOutputStream();
-            isOpenSerialPortUtil = true;
-            receiveSerialPort();
-        } catch (IOException e) {
+            serialPort = new SerialPort();
+            serialPort.setCallback(new SerialPort.Callback() {
+                @Override
+                public void onOpen(boolean success) {
+                    //获取打开的串口中的输入输出流，以便于串口数据的收发
+                    inputStream = serialPort.getInputStream();
+                    outputStream = serialPort.getOutputStream();
+                    isOpenSerialPortUtil = true;
+                    receiveSerialPort();
+                }
+            });
+            serialPort.open(new File("/dev/" + getSystemPort()), getSystemBaudrate(), 0);
+        } catch (Exception e) {
             e.printStackTrace();
         }
     }

bedlib/src/main/java/serialporttest/utils/SerialPortUtil433.java

@@ -0,0 +1,161 @@
+package serialporttest.utils;
+
+import android.util.Log;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import android_serialport_api.SerialPort;
+
+public class SerialPortUtil433 {
+    private String TAG = "SerialPortUtil433";
+
+    public SerialPort serialPort = null;
+    public InputStream inputStream = null;
+    public OutputStream outputStream = null;
+
+    ISerialPort433Data dataReceiveListener = null;
+    public boolean isOpenSerialPortUtil = false;
+
+    public Thread receiveThread = null;
+
+    public static SerialPortUtil433 instance = null;
+
+    public SerialPortUtil433() {
+    }
+
+    public static SerialPortUtil433 getInstance() {
+        if (instance == null) {
+            synchronized (SerialPortUtil433.class) {
+                if (instance == null) {
+                    instance = new SerialPortUtil433();
+                }
+            }
+        }
+        return instance;
+    }
+
+    /**
+     * 打开串口的方法
+     */
+    public void openSerialPort() {
+        Log.i(TAG, "打开串口0");
+        try {
+            serialPort = new SerialPort();
+            serialPort.setCallback(new SerialPort.Callback() {
+                @Override
+                public void onOpen(boolean success) {
+                    //获取打开的串口中的输入输出流，以便于串口数据的收发
+                    inputStream = serialPort.getInputStream();
+                    outputStream = serialPort.getOutputStream();
+                    isOpenSerialPortUtil = true;
+
+                    Log.i(TAG, "open openSerialPort0 success...");
+                    receiveSerialPort();
+                }
+            });
+            serialPort.open(new File("/dev/ttyS0"), 115200, 0);
+        } catch (Exception e) {
+            e.printStackTrace();
+            Log.e(TAG, "open openSerialPort0 failed...");
+        }
+    }
+
+    public void receiveSerialPort() {
+        Log.i(TAG, "接收433串口数据");
+        if (receiveThread != null)
+            return;
+
+        receiveThread = new Thread() {
+            @Override
+            public void run() {
+                while (isOpenSerialPortUtil) {
+                    try {
+                        Thread.sleep(100);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+
+                    int size;
+                    try {
+                        byte[] buffer = new byte[64];
+                        if (inputStream == null) {
+                            return;
+                        }
+
+                        if(inputStream.available()>0) {
+                            size = inputStream.read(buffer);
+                            if (size > 0) {
+                                if (dataReceiveListener != null) {
+                                    dataReceiveListener.onSerial433Data(buffer, size);
+                                }
+                            }
+                        }
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                        return;
+                    }
+                }
+            }
+        };
+        //启动接收线程
+        receiveThread.start();
+    }
+
+    /**
+     * 关闭串口的方法
+     * 关闭串口中的输入输出流
+     * 然后将flag的值设为flag，终止接收数据线程
+     */
+    public void closeSerialPort() {
+        Log.i(TAG, "关闭串口");
+        try {
+            if (inputStream != null) {
+                inputStream.close();
+            }
+            if (outputStream != null) {
+                outputStream.close();
+            }
+            if (receiveThread != null && receiveThread.isAlive()) {
+                receiveThread.interrupt();
+                receiveThread = null;
+            }
+            isOpenSerialPortUtil = false;
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    /**
+     * 发送串口数据的方法
+     *
+     * @param command 要发送的数据
+     */
+    private void send(String command) {
+        try {
+            if (isOpenSerialPortUtil) {
+                byte[] sendData = command.getBytes();
+                outputStream.write(sendData);
+                Log.d("serialPort","==command==" + command);
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+            Log.d("serialPort","==command==" + command);
+        }
+    }
+
+
+    public void setOn433DataReceiveListener(ISerialPort433Data dataReceiveListener) {
+        this.dataReceiveListener = dataReceiveListener;
+    }
+
+
+
+    public interface ISerialPort433Data {
+        void onSerial433Data(final byte[] buffer, final int size);
+    }
+
+}

bedlib/src/main/java/serialporttest/utils/StringUtils.java

@@ -1078,4 +1078,12 @@ public class StringUtils {
         }
         return sb.toString();
     }
+
+    public static String bytesToHex(byte[] bytes) {
+        StringBuilder sb = new StringBuilder();
+        for (byte b : bytes) {
+            sb.append(String.format("%02x", b));
+        }
+        return sb.toString();
+    }
 }

callingdoor/src/main/java/com/wdkl/app/ncs/callingdoor/activity/CallingdoorActivity.kt

@@ -20,6 +20,7 @@ import com.google.gson.Gson
 import com.wdkl.app.ncs.callingdoor.BuildConfig
 import com.wdkl.app.ncs.callingdoor.R
 import com.wdkl.app.ncs.callingdoor.agreement.CallingdoorAgreement
+import com.wdkl.app.ncs.callingdoor.bean.Trans433Data
 import com.wdkl.app.ncs.callingdoor.databinding.CallingdoorMainLayBinding
 import com.wdkl.app.ncs.callingdoor.fragment.*
 import com.wdkl.app.ncs.callingdoor.helper.*
@@ -74,6 +75,8 @@ import org.greenrobot.eventbus.EventBus
 import org.greenrobot.eventbus.Subscribe
 import org.greenrobot.eventbus.ThreadMode
 import serialporttest.utils.SerialPortUtil
+import serialporttest.utils.SerialPortUtil433
+import serialporttest.utils.StringUtils
 import java.io.*
 import java.lang.Process
 import java.util.*
@@ -90,11 +93,11 @@ import kotlin.collections.ArrayList
 
 @Router(path = "/callingdoor/main")
 class CallingdoorActivity :BaseActivity<CallingdoorActivityPresenter, CallingdoorMainLayBinding>(), CallingdoorActivityContract.View, CallingdoorAgreement,
-    SerialPortUtil.ISerialPortBedOnclickEvent, SerialPortUtil.ISerialPortBedOnclickString {
+    SerialPortUtil.ISerialPortBedOnclickEvent, SerialPortUtil.ISerialPortBedOnclickString, SerialPortUtil433.ISerialPort433Data {
     var TAG = CallingdoorActivity::class.java.getSimpleName()
 
     private lateinit var receiver: TimeReceiver
-    private lateinit var curFragment: String
+    private var curFragment = ""
 
     //首页
     private val mainFragment = "main_fragment"
@@ -126,6 +129,8 @@ class CallingdoorActivity :BaseActivity<CallingdoorActivityPresenter, Callingdoo
 
     private var bedCalls = ArrayList<String>()
 
+    private var trans433Data: Trans433Data? = null
+
     //网络异常计数
     private var netErrCount : Int = 0
 
@@ -178,10 +183,10 @@ class CallingdoorActivity :BaseActivity<CallingdoorActivityPresenter, Callingdoo
         updateNetState()
 
         if ("rk3128".equals(Build.MODEL) || "rk3368".equals(Build.MODEL)) {
-            //串口监听
-            setSerialListener()
-
             AppTool.Time.delay(1500) {
+                //串口监听
+                setSerialListener()
+
                 //打开MIC
                 SerialPortHelper.setMIC(false)
                 SerialPortHelper.setHandsFree(true)
@@ -701,6 +706,8 @@ class CallingdoorActivity :BaseActivity<CallingdoorActivityPresenter, Callingdoo
         SerialPortUtil.getInstance().setOnDataReceiveStringListener(this)
         //开启串口心跳
         SerialPortUtil.getInstance().startHeartBeat()
+
+        SerialPortUtil433.getInstance().setOn433DataReceiveListener(this)
     }
 
     override fun checkAppVersion() {
@@ -731,6 +738,7 @@ class CallingdoorActivity :BaseActivity<CallingdoorActivityPresenter, Callingdoo
         if ("rk3128".equals(Build.MODEL) || "rk3368".equals(Build.MODEL)) {
             SerialPortUtil.getInstance().closeHeart()
             SerialPortUtil.getInstance().closeSerialPort()
+            SerialPortUtil433.getInstance().closeSerialPort()
         }
     }
 
@@ -1087,6 +1095,40 @@ class CallingdoorActivity :BaseActivity<CallingdoorActivityPresenter, Callingdoo
         }
     }
 
+    override fun onSerial433Data(buffer: ByteArray?, size: Int) {
+        val bytes = Arrays.copyOfRange(buffer, 0, size)
+        val receiveData: String = StringUtils.bytesToHex(bytes)
+        //val receiveString = String(bytes, 0, size)
+        Log.e(TAG, "receive433Data: $receiveData")
+
+        try {
+            if (receiveData.startsWith("fd") && receiveData.endsWith("df")) {
+                //当前系统时间
+                val curTime = System.currentTimeMillis()
+                //收到的按键数据掐头去尾: fdb50831df --> b50831
+                val cmd = receiveData.substring(2,  receiveData.indexOf("df"))
+                if (trans433Data != null) {
+                    //如果与上次数据相同，1500毫秒内不再重复发
+                    if (trans433Data!!.cmd == cmd && curTime - trans433Data!!.time < 1500) {
+                        return
+                    }
+                    trans433Data!!.time = curTime
+                    trans433Data!!.cmd = cmd
+                } else {
+                    trans433Data = Trans433Data(curTime, cmd)
+                }
+
+                //发送数据: ffcc020006b50831
+                if (Constant.TCP_CONNECTED && !TextUtils.isEmpty(trans433Data!!.cmd)) {
+                    TcpClient.getInstance().sendMsg(AlarmMessageUtil.getAlarmMessage(trans433Data!!.cmd))
+                }
+            }
+        } catch (ex: Exception) {
+            ex.printStackTrace()
+        }
+    }
+
+
     //开始呼叫
     fun startCall(type: Int) {
         if (Constant.DEVICE_STATUS != 1) {

callingdoor/src/main/java/com/wdkl/app/ncs/callingdoor/bean/Trans433Data.java

@@ -0,0 +1,27 @@
+package com.wdkl.app.ncs.callingdoor.bean;
+
+public class Trans433Data {
+    private long time;
+    private String cmd;
+
+    public Trans433Data(long time, String cmd) {
+        this.time = time;
+        this.cmd = cmd;
+    }
+
+    public long getTime() {
+        return time;
+    }
+
+    public void setTime(long time) {
+        this.time = time;
+    }
+
+    public String getCmd() {
+        return cmd;
+    }
+
+    public void setCmd(String cmd) {
+        this.cmd = cmd;
+    }
+}

callingdoor/src/main/java/com/wdkl/app/ncs/callingdoor/helper/AlarmMessageUtil.java

@@ -0,0 +1,14 @@
+package com.wdkl.app.ncs.callingdoor.helper;
+
+public class AlarmMessageUtil {
+
+    public static String getAlarmMessage(String cmd){
+        //----> ffcc020006b50831
+        StringBuilder sb = new StringBuilder();
+        sb.append("ffcc02");
+        sb.append(String.format("%04X",cmd.length()));
+        sb.append(cmd);
+        return sb.toString();
+    }
+
+}