feat: add device discover request

Signed-off-by: wei <[email protected]>

mdtp-client/src/main/java/io/github/protocol/mdtp/client/MdtpClient.java

@@ -1,6 +1,11 @@
 package io.github.protocol.mdtp.client;
 
+import io.github.protocol.mdtp.common.model.CDATHeader;
+import io.github.protocol.mdtp.common.model.DeviceDiscoveryRequest;
+import io.github.protocol.mdtp.common.model.MdtpPacket;
+import io.github.protocol.mdtp.common.model.MessageBodyHeader;
 import io.netty.bootstrap.Bootstrap;
+import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelInitializer;
 import io.netty.channel.EventLoopGroup;
@@ -16,6 +21,8 @@
 public class MdtpClient implements Closeable {
     private final MdtpClientConfig config;
 
+    private ChannelFuture channelFuture;
+
     private EventLoopGroup group;
 
     public MdtpClient(MdtpClientConfig config) {
@@ -35,9 +42,13 @@ public void start() throws Exception {
                 .handler(new ChannelInitializer<SocketChannel>() {
                     @Override
                     protected void initChannel(SocketChannel ch) throws Exception {
+//                        ChannelPipeline pipeline = ch.pipeline();
+//                        pipeline.addLast(new MdtpDecoder());
+//                        pipeline.addLast(new MdtpEncoder());
+//                        pipeline.addLast(new MdtpClientHandler());
                     }
                 });
-        ChannelFuture channelFuture = bootstrap.connect().sync();
+        this.channelFuture = bootstrap.connect().sync();
         if (channelFuture.isSuccess()) {
             log.info("mdtp client started");
         } else {
@@ -55,4 +66,40 @@ public void close() throws IOException {
         this.group.shutdownGracefully();
         log.info("mdtp client closed");
     }
+
+    public void sendDeviceDiscoveryRequest(int[] deviceTypes) {
+        log.info("start to send device discovery request.");
+        DeviceDiscoveryRequest request = new DeviceDiscoveryRequest();
+        request.setMessageBodyHeader(MessageBodyHeader.DEVICE_DISCOVERY_REQUEST);
+        log.info("" + request.getMessageBodyHeader().toShort());
+        request.setRequestId(request.generateRequestId());
+
+        if (deviceTypes == null) {
+            request.setDeviceTypeCount((byte) 0);
+        }
+
+        if (deviceTypes != null && deviceTypes.length > 0) {
+            request.setMask((byte) 1);
+            request.setDeviceTypeCount((byte) deviceTypes.length);
+            request.setDeviceTypes(deviceTypes);
+        }
+
+        CDATHeader cdatHeader = new CDATHeader();
+        cdatHeader.setFormatType((byte) 0x02);
+        cdatHeader.setProtocolVersion((byte) 1);
+        cdatHeader.setMessageLength((short) 0);
+        cdatHeader.setTimestamp(System.currentTimeMillis());
+        cdatHeader.setFlags((byte) 0b01100000);
+        cdatHeader.setSequenceNumber(0);
+        cdatHeader.setLogicalChannelId(0);
+
+        MdtpPacket packet = new MdtpPacket();
+        packet.setHeader(cdatHeader);
+        packet.setSecurityHeader(null);
+        packet.setBody(request);
+        packet.setSignature(null);
+
+        this.channelFuture.channel().writeAndFlush(packet.toByteBuf(Unpooled.buffer()));
+        log.info("send device discovery request success: " + packet);
+    }
 }

mdtp-common/src/main/java/io/github/protocol/mdtp/common/codec/DeviceDiscoveryRequestDecoder.java

@@ -0,0 +1,12 @@
+package io.github.protocol.mdtp.common.codec;
+
+import io.github.protocol.mdtp.common.model.AbstractMessageBody;
+import io.github.protocol.mdtp.common.model.DeviceDiscoveryRequest;
+import io.netty.buffer.ByteBuf;
+
+public class DeviceDiscoveryRequestDecoder implements MessageBodyDecoder {
+    @Override
+    public AbstractMessageBody handle(ByteBuf in) {
+        return DeviceDiscoveryRequest.fromByteBuf(in);
+    }
+}

mdtp-common/src/main/java/io/github/protocol/mdtp/common/codec/MdtpDecoder.java

@@ -0,0 +1,34 @@
+package io.github.protocol.mdtp.common.codec;
+
+
+import io.github.protocol.mdtp.common.model.AbstractMessageBody;
+import io.github.protocol.mdtp.common.model.CDATHeader;
+import io.github.protocol.mdtp.common.model.MdtpPacket;
+import io.github.protocol.mdtp.common.model.MessageBodyHeader;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.ByteToMessageDecoder;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.List;
+
+@Slf4j
+public class MdtpDecoder extends ByteToMessageDecoder {
+
+    @Override
+    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
+
+        MdtpPacket mdtpPacket = new MdtpPacket();
+        CDATHeader header = CDATHeader.fromByteBuf(in);
+
+        MessageBodyHeader messageBodyHeader = MessageBodyHeader.fromByteBuf(in);
+        MessageBodyDecoder messageDecode = MessageDecoderFactory.getDecoder(messageBodyHeader);
+        AbstractMessageBody messageBody = messageDecode.handle(in);
+        messageBody.setMessageBodyHeader(messageBodyHeader);
+
+        mdtpPacket.setHeader(header);
+        mdtpPacket.setBody(messageBody);
+
+        out.add(mdtpPacket);
+    }
+}

mdtp-common/src/main/java/io/github/protocol/mdtp/common/codec/MessageBodyDecoder.java

@@ -0,0 +1,8 @@
+package io.github.protocol.mdtp.common.codec;
+
+import io.github.protocol.mdtp.common.model.AbstractMessageBody;
+import io.netty.buffer.ByteBuf;
+
+public interface MessageBodyDecoder {
+    AbstractMessageBody handle(ByteBuf in);
+}

mdtp-common/src/main/java/io/github/protocol/mdtp/common/codec/MessageDecoderFactory.java

@@ -0,0 +1,19 @@
+package io.github.protocol.mdtp.common.codec;
+
+import io.github.protocol.mdtp.common.model.MessageBodyHeader;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class MessageDecoderFactory {
+
+    private static final Map<Short, MessageBodyDecoder> decoders = new HashMap<>();
+
+    static {
+        decoders.put(MessageBodyHeader.DEVICE_DISCOVERY_REQUEST.toShort(), new DeviceDiscoveryRequestDecoder());
+    }
+
+    public static MessageBodyDecoder getDecoder(MessageBodyHeader header) {
+        return decoders.get(header.toShort());
+    }
+}

mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/AbstractMessageBody.java

@@ -7,22 +7,15 @@
 
 @Data
 public abstract class AbstractMessageBody {
-    private short messageBodyHeader;
-
-    public void setMessageBodyHeader(MessageType messageType, ServiceGroup serviceGroup, DiscoveryServiceCode serviceCode) {
-        this.messageBodyHeader = 0;
-        this.messageBodyHeader |= (short) (messageType.getCode() & 0b111);
-        this.messageBodyHeader |= (short) ((serviceGroup.getCode() & 0b1111111) << 3);
-        this.messageBodyHeader |= (short) ((serviceCode.getCode() & 0b111111) << 10);
-    }
+    private MessageBodyHeader messageBodyHeader;
 
     public short generateRequestId() {
         UUID uuid = UUID.randomUUID();
         return (short) (uuid.getLeastSignificantBits() & 0xFFFF);
     }
 
     public ByteBuf toByteBuf(ByteBuf buffer) {
-        buffer.writeShort(messageBodyHeader);
+        messageBodyHeader.toByteBuf(buffer);
         return buffer;
     }
 }

mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/CDATHeader.java

@@ -35,4 +35,18 @@ public ByteBuf toByteBuf(ByteBuf buffer) {
         buffer.writeInt(logicalChannelId);
         return buffer;
     }
+
+    public static CDATHeader fromByteBuf(ByteBuf buffer) {
+        CDATHeader header = new CDATHeader();
+
+        header.setFormatType(buffer.readByte());
+        header.setProtocolVersion(buffer.readByte());
+        header.setMessageLength(buffer.readShort());
+        header.setTimestamp(buffer.readLong());
+        header.setFlags(buffer.readByte());
+        header.setSequenceNumber(buffer.readInt());
+        header.setLogicalChannelId(buffer.readInt());
+
+        return header;
+    }
 }

mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/DeviceDiscoveryRequest.java

@@ -5,7 +5,8 @@
 
 
 @Data
-public class DeviceDiscoveryRequest extends AbstractMessageBody {
+public class DeviceDiscoveryRequest extends AbstractMessageBody{
+
     private short requestId;
 
     private byte mask;
@@ -19,8 +20,10 @@ public ByteBuf toByteBuf(ByteBuf buffer) {
         buffer.writeShort(requestId);
         buffer.writeByte(mask);
         buffer.writeByte(deviceTypeCount);
-        for (int deviceType : deviceTypes) {
-            buffer.writeInt(deviceType);
+        if (deviceTypeCount > 0) {
+            for (int deviceType : deviceTypes) {
+                buffer.writeInt(deviceType);
+            }
         }
         return buffer;
     }

mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/DiscoveryServiceCode.java

@@ -16,4 +16,12 @@ public enum DiscoveryServiceCode {
         this.description = description;
     }
 
+    public static DiscoveryServiceCode fromCode(int value) {
+        for (DiscoveryServiceCode serviceCode : DiscoveryServiceCode.values()) {
+            if (serviceCode.getCode() == value) {
+                return serviceCode;
+            }
+        }
+        throw new IllegalArgumentException("Invalid DiscoveryServiceCode: " + value);
+    }
 }

mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/MessageBodyHeader.java

@@ -0,0 +1,47 @@
+package io.github.protocol.mdtp.common.model;
+
+import io.netty.buffer.ByteBuf;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Slf4j
+public class MessageBodyHeader {
+    private MessageType messageType;
+
+    private ServiceGroup serviceGroup;
+
+    private DiscoveryServiceCode serviceCode;
+
+    public static final MessageBodyHeader DEVICE_DISCOVERY_REQUEST =
+            new MessageBodyHeader(MessageType.REQUEST, ServiceGroup.DISCOVERY_SERVICE, DiscoveryServiceCode.DEVICE_DISCOVERY);
+
+    public static final MessageBodyHeader DEVICE_DISCOVERY_RESPONSE =
+            new MessageBodyHeader(MessageType.RESPONSE, ServiceGroup.DISCOVERY_SERVICE, DiscoveryServiceCode.DEVICE_DISCOVERY);
+
+    public short toShort() {
+        short messageBodyHeader = 0;
+        messageBodyHeader |= (short) (this.messageType.getCode() & 0b111);
+        messageBodyHeader |= (short) ((this.serviceGroup.getCode() & 0b1111111) << 3);
+        messageBodyHeader |= (short) ((this.serviceCode.getCode() & 0b111111) << 10);
+        return messageBodyHeader;
+    }
+
+    public ByteBuf toByteBuf(ByteBuf buffer) {
+        buffer.writeShort(toShort());
+        return buffer;
+    }
+
+    public static MessageBodyHeader fromByteBuf(ByteBuf buffer) {
+        short messageBodyHeader = buffer.readShort();
+        MessageType messageType = MessageType.fromCode((short) (messageBodyHeader & 0b111));
+        ServiceGroup serviceGroup = ServiceGroup.fromCode((short) ((messageBodyHeader >> 3) & 0b1111111));
+        DiscoveryServiceCode serviceCode = DiscoveryServiceCode.fromCode((short) ((messageBodyHeader >> 10) & 0b111111));
+        return new MessageBodyHeader(messageType, serviceGroup, serviceCode);
+    }
+}

mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/MessageType.java

@@ -16,4 +16,13 @@ public enum MessageType {
     public int getCode() {
         return code;
     }
+
+    public static MessageType fromCode(int value) {
+        for (MessageType type : MessageType.values()) {
+            if (type.getCode() == value) {
+                return type;
+            }
+        }
+        throw new IllegalArgumentException("Invalid MessageType code: " + value);
+    }
 }

mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/ServiceGroup.java

@@ -25,4 +25,13 @@ public enum ServiceGroup {
         this.code = code;
         this.description = description;
     }
+
+    public static ServiceGroup fromCode(int value) {
+        for (ServiceGroup group : ServiceGroup.values()) {
+            if (group.getCode() == value) {
+                return group;
+            }
+        }
+        throw new IllegalArgumentException("Invalid ServiceGroup code: " + value);
+    }
 }

mdtp-common/src/test/java/io/github/protocol/mdtp/common/AbstractMessageBodyTest.java

@@ -1,18 +1,11 @@
 package io.github.protocol.mdtp.common;
 
 import io.github.protocol.mdtp.common.model.AbstractMessageBody;
-import io.github.protocol.mdtp.common.model.DiscoveryServiceCode;
-import io.github.protocol.mdtp.common.model.MessageType;
-import io.github.protocol.mdtp.common.model.ServiceGroup;
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.Unpooled;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotEquals;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
 
 public class AbstractMessageBodyTest {
 
@@ -23,22 +16,6 @@ void setUp() {
         messageBody = new AbstractMessageBody(){};
     }
 
-    @Test
-    void testSetMessageBodyHeader() {
-        MessageType messageType = mock(MessageType.class);
-        ServiceGroup serviceGroup = mock(ServiceGroup.class);
-        DiscoveryServiceCode serviceCode = mock(DiscoveryServiceCode.class);
-
-        when(messageType.getCode()).thenReturn(1);
-        when(serviceGroup.getCode()).thenReturn(2);
-        when(serviceCode.getCode()).thenReturn( 3);
-
-        messageBody.setMessageBodyHeader(messageType, serviceGroup, serviceCode);
-
-        short expectedHeader = (short) ((1 & 0b111) | ((2 & 0b1111111) << 3) | ((3 & 0b111111) << 10));
-
-        assertEquals(expectedHeader, messageBody.getMessageBodyHeader());
-    }
 
     @Test
     void testGenerateRequestId() {
@@ -49,25 +26,4 @@ void testGenerateRequestId() {
         assertEquals(Short.class, ((Object) requestId2).getClass());
         assertNotEquals(requestId1, requestId2);
     }
-
-    @Test
-    void testToByteBuf() {
-        ByteBuf buffer = Unpooled.buffer();
-
-        MessageType messageType = mock(MessageType.class);
-        ServiceGroup serviceGroup = mock(ServiceGroup.class);
-        DiscoveryServiceCode serviceCode = mock(DiscoveryServiceCode.class);
-
-        when(messageType.getCode()).thenReturn(1);
-        when(serviceGroup.getCode()).thenReturn(2);
-        when(serviceCode.getCode()).thenReturn( 3);
-
-        messageBody.setMessageBodyHeader(messageType, serviceGroup, serviceCode);
-
-        messageBody.toByteBuf(buffer);
-
-        assertEquals(messageBody.getMessageBodyHeader(), buffer.readShort());
-
-        buffer.release();
-    }
 }