Support new Xexun protocol (fix #4727)

3 files changed, 308 insertions, 0 deletions

diff --git a/src/main/java/org/traccar/protocol/Xexun2FrameDecoder.java b/src/main/java/org/traccar/protocol/Xexun2FrameDecoder.java
new file mode 100644
index 000000000..521d0209c
--- /dev/null
+++ b/src/main/java/org/traccar/protocol/Xexun2FrameDecoder.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2021 Anton Tananaev (anton@traccar.org)
+ *
+ * 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 org.traccar.protocol;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelHandlerContext;
+import org.traccar.BaseFrameDecoder;
+import org.traccar.helper.BufferUtil;
+
+public class Xexun2FrameDecoder extends BaseFrameDecoder {
+
+    @Override
+    protected Object decode(
+            ChannelHandlerContext ctx, Channel channel, ByteBuf buf) throws Exception {
+
+        if (buf.readableBytes() < 5) {
+            return null;
+        }
+
+        ByteBuf flag = Unpooled.wrappedBuffer(new byte[] {(byte) 0xfa, (byte) 0xaf});
+        int index;
+        try {
+            index = BufferUtil.indexOf(flag, buf, buf.readerIndex() + 2, buf.writerIndex());
+        } finally {
+            flag.release();
+        }
+
+        if (index >= 0) {
+            ByteBuf result = Unpooled.buffer(index + 2 - buf.readerIndex());
+
+            while (buf.readerIndex() < index + 2) {
+                int b = buf.readUnsignedByte();
+                if (b == 0xfb && buf.isReadable() && buf.getUnsignedByte(buf.readerIndex()) == 0xbf) {
+                    buf.readUnsignedByte(); // skip
+                    int ext = buf.readUnsignedByte();
+                    if (ext == 0x01) {
+                        result.writeByte(0xfa);
+                        result.writeByte(0xaf);
+                    } else if (ext == 0x02) {
+                        result.writeByte(0xfb);
+                        result.writeByte(0xbf);
+                    }
+                } else {
+                    result.writeByte(b);
+                }
+            }
+
+            return result;
+        }
+
+        return null;
+    }
+
+}
diff --git a/src/main/java/org/traccar/protocol/Xexun2Protocol.java b/src/main/java/org/traccar/protocol/Xexun2Protocol.java
new file mode 100644
index 000000000..265841c77
--- /dev/null
+++ b/src/main/java/org/traccar/protocol/Xexun2Protocol.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2021 Anton Tananaev (anton@traccar.org)
+ *
+ * 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 org.traccar.protocol;
+
+import org.traccar.BaseProtocol;
+import org.traccar.PipelineBuilder;
+import org.traccar.TrackerServer;
+
+public class Xexun2Protocol extends BaseProtocol {
+
+    public Xexun2Protocol() {
+        addServer(new TrackerServer(false, getName()) {
+            @Override
+            protected void addProtocolHandlers(PipelineBuilder pipeline) {
+                pipeline.addLast(new Xexun2FrameDecoder());
+                pipeline.addLast(new Xexun2ProtocolDecoder(Xexun2Protocol.this));
+            }
+        });
+    }
+
+}
diff --git a/src/main/java/org/traccar/protocol/Xexun2ProtocolDecoder.java b/src/main/java/org/traccar/protocol/Xexun2ProtocolDecoder.java
new file mode 100644
index 000000000..766a3f05b
--- /dev/null
+++ b/src/main/java/org/traccar/protocol/Xexun2ProtocolDecoder.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright 2021 Anton Tananaev (anton@traccar.org)
+ *
+ * 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 org.traccar.protocol;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufUtil;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.Channel;
+import org.traccar.BaseProtocolDecoder;
+import org.traccar.DeviceSession;
+import org.traccar.NetworkMessage;
+import org.traccar.Protocol;
+import org.traccar.helper.BitUtil;
+import org.traccar.helper.UnitsConverter;
+import org.traccar.model.CellTower;
+import org.traccar.model.Network;
+import org.traccar.model.Position;
+import org.traccar.model.WifiAccessPoint;
+
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+public class Xexun2ProtocolDecoder extends BaseProtocolDecoder {
+
+    public Xexun2ProtocolDecoder(Protocol protocol) {
+        super(protocol);
+    }
+
+    public static final int MSG_POSITION = 0x14;
+
+    private void sendResponse(Channel channel, int type, int index, ByteBuf imei) {
+        if (channel != null) {
+            ByteBuf response = Unpooled.buffer();
+            response.writeByte(0xfa);
+            response.writeByte(0xaf);
+
+            response.writeShort(type);
+            response.writeShort(index);
+            response.writeBytes(imei);
+            response.writeShort(1); // attributes / length
+            response.writeShort(0xfffe); // checksum
+            response.writeByte(1); // response
+
+            response.writeByte(0xfa);
+            response.writeByte(0xaf);
+
+            channel.writeAndFlush(new NetworkMessage(response, channel.remoteAddress()));
+        }
+    }
+
+    private String decodeAlarm(long value) {
+        if (BitUtil.check(value, 0)) {
+            return Position.ALARM_SOS;
+        }
+        if (BitUtil.check(value, 15)) {
+            return Position.ALARM_FALL_DOWN;
+        }
+        return null;
+    }
+
+    private double convertCoordinate(double value) {
+        double degrees = Math.floor(value / 100);
+        double minutes = value - degrees * 100;
+        return degrees + minutes / 60;
+    }
+
+    @Override
+    protected Object decode(
+            Channel channel, SocketAddress remoteAddress, Object msg) throws Exception {
+
+        ByteBuf buf = (ByteBuf) msg;
+
+        buf.skipBytes(2); // flag
+        int type = buf.readUnsignedShort();
+        int index = buf.readUnsignedShort();
+
+        ByteBuf imei = buf.readSlice(8);
+        DeviceSession deviceSession = getDeviceSession(
+                channel, remoteAddress, ByteBufUtil.hexDump(imei).substring(0, 15));
+        if (deviceSession == null) {
+            return null;
+        }
+
+        sendResponse(channel, type, index, imei);
+
+        buf.readUnsignedShort(); // attributes
+        buf.readUnsignedShort(); // checksum
+
+        if (type == MSG_POSITION) {
+            List<Integer> lengths = new ArrayList<>();
+            List<Position> positions = new ArrayList<>();
+
+            int count = buf.readUnsignedByte();
+            for (int i = 0; i < count; i++) {
+                lengths.add(buf.readUnsignedShort());
+            }
+
+            for (int i = 0; i < count; i++) {
+                int endIndex = buf.readerIndex() + lengths.get(i);
+
+                Position position = new Position(getProtocolName());
+                position.setDeviceId(deviceSession.getDeviceId());
+
+                position.set(Position.KEY_INDEX, buf.readUnsignedByte());
+
+                position.setDeviceTime(new Date(buf.readUnsignedInt() * 1000));
+
+                position.set(Position.KEY_RSSI, buf.readUnsignedByte());
+
+                int battery = buf.readUnsignedShort();
+                position.set(Position.KEY_CHARGE, BitUtil.check(battery, 15));
+                position.set(Position.KEY_BATTERY_LEVEL, BitUtil.to(battery, 15));
+
+                int mask = buf.readUnsignedByte();
+
+                if (BitUtil.check(mask, 0)) {
+                    position.set(Position.KEY_ALARM, decodeAlarm(buf.readUnsignedInt()));
+                }
+                if (BitUtil.check(mask, 1)) {
+                    int positionMask = buf.readUnsignedByte();
+                    if (BitUtil.check(positionMask, 0)) {
+                        position.setValid(true);
+                        position.setFixTime(position.getDeviceTime());
+                        position.set(Position.KEY_SATELLITES, buf.readUnsignedByte());
+                        position.setLongitude(convertCoordinate(buf.readFloat()));
+                        position.setLatitude(convertCoordinate(buf.readFloat()));
+                    }
+                    Network network = new Network();
+                    if (BitUtil.check(positionMask, 1)) {
+                        int wifiCount = buf.readUnsignedByte();
+                        for (int j = 0; j < wifiCount; j++) {
+                            String mac = ByteBufUtil.hexDump(buf.readSlice(6)).replaceAll("(..)", "$1:");
+                            network.addWifiAccessPoint(WifiAccessPoint.from(
+                                    mac.substring(0, mac.length() - 1), buf.readUnsignedByte()));
+                        }
+                    }
+                    if (BitUtil.check(positionMask, 2)) {
+                        int cellCount = buf.readUnsignedByte();
+                        for (int j = 0; j < cellCount; j++) {
+                            network.addCellTower(CellTower.from(
+                                    buf.readUnsignedShort(), buf.readUnsignedShort(),
+                                    buf.readInt(), buf.readUnsignedInt(), buf.readUnsignedByte()));
+                        }
+                    }
+                    if (network.getWifiAccessPoints() != null || network.getCellTowers() != null) {
+                        position.setNetwork(network);
+                    }
+                    if (BitUtil.check(positionMask, 3)) {
+                        buf.skipBytes(12 * buf.readUnsignedByte()); // tof
+                    }
+                    if (BitUtil.check(positionMask, 5)) {
+                        position.setSpeed(UnitsConverter.knotsFromKph(buf.readUnsignedShort() * 0.1));
+                        position.setCourse(buf.readUnsignedShort() * 0.1);
+                    }
+                    if (BitUtil.check(positionMask, 6)) {
+                        position.setValid(true);
+                        position.setFixTime(position.getDeviceTime());
+                        position.set(Position.KEY_SATELLITES, buf.readUnsignedByte());
+                        position.setLongitude(convertCoordinate(buf.readDouble()));
+                        position.setLatitude(convertCoordinate(buf.readDouble()));
+
+                    }
+                }
+                if (BitUtil.check(mask, 3)) {
+                    buf.readUnsignedInt(); // fingerprint
+                }
+                if (BitUtil.check(mask, 4)) {
+                    buf.skipBytes(20); // version
+                    buf.skipBytes(8); // imsi
+                    buf.skipBytes(10); // iccid
+                }
+                if (BitUtil.check(mask, 5)) {
+                    buf.skipBytes(12); // device parameters
+                }
+
+                if (!position.getValid()) {
+                    getLastLocation(position, position.getDeviceTime());
+                }
+                positions.add(position);
+
+                buf.readerIndex(endIndex);
+            }
+
+            return positions;
+        }
+
+        return null;
+    }
+
+}