升级到core3.1,并增加测试用例

src/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808.Protocol.Extensions.JTActiveSafety.Test.csproj

@@ -1,15 +1,20 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp2.2</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.0.1" />
     <PackageReference Include="xunit" Version="2.4.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.0" />
   </ItemGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\JT808.Protocol.Extensions.JTActiveSafety\JT808.Protocol.Extensions.JTActiveSafety.csproj" />
+  </ItemGroup>
+
 </Project>

src/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808_0x0200_0x64_Test.cs

@@ -0,0 +1,94 @@
+using JT808.Protocol.Extensions.JTActiveSafety.MessageBody;
+using JT808.Protocol.MessageBody;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace JT808.Protocol.Extensions.JTActiveSafety.Test
+{
+    public class JT808_0x0200_0x64_Test
+    {
+        JT808Serializer JT808Serializer;
+        public JT808_0x0200_0x64_Test()
+        {
+            ServiceCollection serviceDescriptors = new ServiceCollection();
+            serviceDescriptors.AddJT808Configure()
+                                        .AddJTActiveSafetyConfigure();
+            IJT808Config jT808Config = serviceDescriptors.BuildServiceProvider().GetRequiredService<IJT808Config>();
+            JT808Serializer = new JT808Serializer(jT808Config);
+        }
+        [Fact]
+        public void Serializer()
+        {
+            JT808_0x0200 jT808UploadLocationRequest = new JT808_0x0200
+            {
+                AlarmFlag = 1,
+                Altitude = 40,
+                GPSTime = DateTime.Parse("2018-07-15 10:10:10"),
+                Lat = 12222222,
+                Lng = 132444444,
+                Speed = 60,
+                Direction = 0,
+                StatusFlag = 2,
+                JT808LocationAttachData = new Dictionary<byte, JT808_0x0200_BodyBase>()
+            };
+            jT808UploadLocationRequest.JT808LocationAttachData.Add(JT808_JTActiveSafety_Constants.JT808_0X0200_0x64, new JT808_0x0200_0x64
+            {
+                AlarmId = 1,
+                AlarmIdentification = new Metadata.AlarmIdentificationProperty
+                {
+                    AttachCount = 2,
+                    SN = 3,
+                    TerminalID = "4444444",
+                    Time = Convert.ToDateTime("2019-12-10 18:31:00")
+                },
+                AlarmLevel = 5,
+                AlarmOrEventType = 6,
+                AlarmTime = Convert.ToDateTime("2019-12-11 18:31:00"),
+                Altitude = 7,
+                CarOrPedestrianDistanceAhead = 10,
+                DeviateType = 11,
+                FlagState = 12,
+                Latitude = 13,
+                Longitude = 14,
+                RoadSignIdentificationData = 15,
+                RoadSignIdentificationType = 16,
+                Speed = 17,
+                VehicleSpeed = 18,
+                VehicleState = 19
+            });
+            var hex = JT808Serializer.Serialize(jT808UploadLocationRequest).ToHexString();
+            Assert.Equal("000000010000000200BA7F0E07E4F11C0028003C00001807151010106420000000010C0605120A0B100F1100070000000D0000000E191211183100001334343434343434191210183100030200", hex);
+        }
+        [Fact]
+        public void Deserialize()
+        {
+            var jT808UploadLocationRequest = JT808Serializer.Deserialize<JT808_0x0200>("000000010000000200BA7F0E07E4F11C0028003C00001807151010106420000000010C0605120A0B100F1100070000000D0000000E191211183100001334343434343434191210183100030200".ToHexBytes());
+            jT808UploadLocationRequest.JT808LocationAttachData.TryGetValue(JT808_JTActiveSafety_Constants.JT808_0X0200_0x64, out var value);
+            JT808_0x0200_0x64 jT808_0X0200_0X64 = value as JT808_0x0200_0x64;
+            Assert.Equal(1u, jT808_0X0200_0X64.AlarmId);
+            Assert.Equal(2, jT808_0X0200_0X64.AlarmIdentification.AttachCount);
+            Assert.Equal(3, jT808_0X0200_0X64.AlarmIdentification.SN);
+            Assert.Equal("4444444", jT808_0X0200_0X64.AlarmIdentification.TerminalID);
+            Assert.Equal(Convert.ToDateTime("2019-12-10 18:31:00"), jT808_0X0200_0X64.AlarmIdentification.Time);
+            Assert.Equal(5, jT808_0X0200_0X64.AlarmLevel);
+            Assert.Equal(6, jT808_0X0200_0X64.AlarmOrEventType);
+            Assert.Equal(Convert.ToDateTime("2019-12-11 18:31:00"), jT808_0X0200_0X64.AlarmTime);
+            Assert.Equal(7, jT808_0X0200_0X64.Altitude);
+            Assert.Equal(0x64, jT808_0X0200_0X64.AttachInfoId);
+            Assert.Equal(32, jT808_0X0200_0X64.AttachInfoLength);
+            Assert.Equal(10, jT808_0X0200_0X64.CarOrPedestrianDistanceAhead);
+            Assert.Equal(11, jT808_0X0200_0X64.DeviateType);
+            Assert.Equal(12, jT808_0X0200_0X64.FlagState);
+            Assert.Equal(13, jT808_0X0200_0X64.Latitude);
+            Assert.Equal(14, jT808_0X0200_0X64.Longitude);
+            Assert.Equal(15, jT808_0X0200_0X64.RoadSignIdentificationData);
+            Assert.Equal(16, jT808_0X0200_0X64.RoadSignIdentificationType);
+            Assert.Equal(17, jT808_0X0200_0X64.Speed);
+            Assert.Equal(18, jT808_0X0200_0X64.VehicleSpeed);
+            Assert.Equal(19, jT808_0X0200_0X64.VehicleState);
+        }
+    }
+}

src/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808_0x0200_0x65_Test.cs

@@ -0,0 +1,88 @@
+using JT808.Protocol.Extensions.JTActiveSafety.MessageBody;
+using JT808.Protocol.MessageBody;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace JT808.Protocol.Extensions.JTActiveSafety.Test
+{
+    public class JT808_0x0200_0x65_Test
+    {
+        JT808Serializer JT808Serializer;
+        public JT808_0x0200_0x65_Test()
+        {
+            ServiceCollection serviceDescriptors = new ServiceCollection();
+            serviceDescriptors.AddJT808Configure()
+                                        .AddJTActiveSafetyConfigure();
+            IJT808Config jT808Config = serviceDescriptors.BuildServiceProvider().GetRequiredService<IJT808Config>();
+            JT808Serializer = new JT808Serializer(jT808Config);
+        }
+        [Fact]
+        public void Serializer()
+        {
+            JT808_0x0200 jT808UploadLocationRequest = new JT808_0x0200
+            {
+                AlarmFlag = 1,
+                Altitude = 40,
+                GPSTime = DateTime.Parse("2018-07-15 10:10:10"),
+                Lat = 12222222,
+                Lng = 132444444,
+                Speed = 60,
+                Direction = 0,
+                StatusFlag = 2,
+                JT808LocationAttachData = new Dictionary<byte, JT808_0x0200_BodyBase>()
+            };
+            jT808UploadLocationRequest.JT808LocationAttachData.Add(JT808_JTActiveSafety_Constants.JT808_0X0200_0x65, new JT808_0x0200_0x65
+            {
+                AlarmId = 1,
+                AlarmIdentification = new Metadata.AlarmIdentificationProperty
+                {
+                    AttachCount = 2,
+                    SN = 3,
+                    TerminalID = "4444444",
+                    Time = Convert.ToDateTime("2019-12-10 18:31:00")
+                },
+                AlarmLevel = 5,
+                AlarmOrEventType = 6,
+                AlarmTime = Convert.ToDateTime("2019-12-11 18:31:00"),
+                Altitude = 7,
+                 Retain=new byte[] { 1, 2, 3, 4 },
+                FlagState = 12,
+                Latitude = 13,
+                Longitude = 14,
+                Speed = 17,
+                Fatigue=18,
+                VehicleState = 19
+            });
+            var hex = JT808Serializer.Serialize(jT808UploadLocationRequest).ToHexString();
+            Assert.Equal("000000010000000200BA7F0E07E4F11C0028003C00001807151010106520000000010C060512010203041100070000000D0000000E191211183100001334343434343434191210183100030200", hex);
+        }
+        [Fact]
+        public void Deserialize()
+        {
+            var jT808UploadLocationRequest = JT808Serializer.Deserialize<JT808_0x0200>("000000010000000200BA7F0E07E4F11C0028003C00001807151010106520000000010C060512010203041100070000000D0000000E191211183100001334343434343434191210183100030200".ToHexBytes());
+            jT808UploadLocationRequest.JT808LocationAttachData.TryGetValue(JT808_JTActiveSafety_Constants.JT808_0X0200_0x65, out var value);
+            JT808_0x0200_0x65 jT808_0X0200_0X65 = value as JT808_0x0200_0x65;
+            Assert.Equal(1u, jT808_0X0200_0X65.AlarmId);
+            Assert.Equal(2, jT808_0X0200_0X65.AlarmIdentification.AttachCount);
+            Assert.Equal(3, jT808_0X0200_0X65.AlarmIdentification.SN);
+            Assert.Equal("4444444", jT808_0X0200_0X65.AlarmIdentification.TerminalID);
+            Assert.Equal(Convert.ToDateTime("2019-12-10 18:31:00"), jT808_0X0200_0X65.AlarmIdentification.Time);
+            Assert.Equal(5, jT808_0X0200_0X65.AlarmLevel);
+            Assert.Equal(6, jT808_0X0200_0X65.AlarmOrEventType);
+            Assert.Equal(Convert.ToDateTime("2019-12-11 18:31:00"), jT808_0X0200_0X65.AlarmTime);
+            Assert.Equal(7, jT808_0X0200_0X65.Altitude);
+            Assert.Equal(0x65, jT808_0X0200_0X65.AttachInfoId);
+            Assert.Equal(32, jT808_0X0200_0X65.AttachInfoLength);
+            Assert.Equal(new byte[] { 1, 2, 3, 4 }.ToHexString(), jT808_0X0200_0X65.Retain.ToHexString());
+            Assert.Equal(12, jT808_0X0200_0X65.FlagState);
+            Assert.Equal(13, jT808_0X0200_0X65.Latitude);
+            Assert.Equal(14, jT808_0X0200_0X65.Longitude);
+            Assert.Equal(17, jT808_0X0200_0X65.Speed);
+            Assert.Equal(18, jT808_0X0200_0X65.Fatigue);
+            Assert.Equal(19, jT808_0X0200_0X65.VehicleState);
+        }
+    }
+}

src/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808_0x0200_0x66_Test.cs

@@ -0,0 +1,107 @@
+using JT808.Protocol.Extensions.JTActiveSafety.MessageBody;
+using JT808.Protocol.MessageBody;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace JT808.Protocol.Extensions.JTActiveSafety.Test
+{
+    public class JT808_0x0200_0x66_Test
+    {
+        JT808Serializer JT808Serializer;
+        public JT808_0x0200_0x66_Test()
+        {
+            ServiceCollection serviceDescriptors = new ServiceCollection();
+            serviceDescriptors.AddJT808Configure()
+                                        .AddJTActiveSafetyConfigure();
+            IJT808Config jT808Config = serviceDescriptors.BuildServiceProvider().GetRequiredService<IJT808Config>();
+            JT808Serializer = new JT808Serializer(jT808Config);
+        }
+        [Fact]
+        public void Serializer()
+        {
+            JT808_0x0200 jT808UploadLocationRequest = new JT808_0x0200
+            {
+                AlarmFlag = 1,
+                Altitude = 40,
+                GPSTime = DateTime.Parse("2018-07-15 10:10:10"),
+                Lat = 12222222,
+                Lng = 132444444,
+                Speed = 60,
+                Direction = 0,
+                StatusFlag = 2,
+                JT808LocationAttachData = new Dictionary<byte, JT808_0x0200_BodyBase>()
+            };
+            jT808UploadLocationRequest.JT808LocationAttachData.Add(JT808_JTActiveSafety_Constants.JT808_0X0200_0x66, new JT808_0x0200_0x66
+            {
+                AlarmId = 1,
+                AlarmIdentification = new Metadata.AlarmIdentificationProperty
+                {
+                    AttachCount = 2,
+                    SN = 3,
+                    TerminalID = "4444444",
+                    Time = Convert.ToDateTime("2019-12-10 18:31:00")
+                },
+                AlarmTime = Convert.ToDateTime("2019-12-11 18:31:00"),
+                Altitude = 7,
+                AlarmOrEventCount = 2,
+                AlarmOrEvents = new List<Metadata.AlarmOrEventProperty> {
+                   new Metadata.AlarmOrEventProperty{
+                                AlarmOrEventType=1,
+                                BatteryLevel=2,
+                                TirePressure=3,
+                                TirePressureAlarmPosition=4,
+                                TireTemperature=5
+                                },
+                   new Metadata.AlarmOrEventProperty{
+                                 AlarmOrEventType=6,
+                                 BatteryLevel=7,
+                                 TirePressure=8,
+                                 TirePressureAlarmPosition=9,
+                                 TireTemperature=10
+                                 }
+                 },
+                FlagState = 12,
+                Latitude = 13,
+                Longitude = 14,
+                Speed = 17,
+                VehicleState = 19
+            });
+            var hex = JT808Serializer.Serialize(jT808UploadLocationRequest).ToHexString();
+            Assert.Equal("000000010000000200BA7F0E07E4F11C0028003C0000180715101010663B000000010C1100070000000D0000000E191211183100001334343434343434191210183100030200020400010003000500020900060008000A0007", hex);
+        }
+        [Fact]
+        public void Deserialize()
+        {
+            var jT808UploadLocationRequest = JT808Serializer.Deserialize<JT808_0x0200>("000000010000000200BA7F0E07E4F11C0028003C0000180715101010663B000000010C1100070000000D0000000E191211183100001334343434343434191210183100030200020400010003000500020900060008000A0007".ToHexBytes());
+            jT808UploadLocationRequest.JT808LocationAttachData.TryGetValue(JT808_JTActiveSafety_Constants.JT808_0X0200_0x66, out var value);
+            JT808_0x0200_0x66 jT808_0X0200_0X66 = value as JT808_0x0200_0x66;
+            Assert.Equal(1u, jT808_0X0200_0X66.AlarmId);
+            Assert.Equal(2, jT808_0X0200_0X66.AlarmIdentification.AttachCount);
+            Assert.Equal(3, jT808_0X0200_0X66.AlarmIdentification.SN);
+            Assert.Equal("4444444", jT808_0X0200_0X66.AlarmIdentification.TerminalID);
+            Assert.Equal(Convert.ToDateTime("2019-12-10 18:31:00"), jT808_0X0200_0X66.AlarmIdentification.Time);
+            Assert.Equal(Convert.ToDateTime("2019-12-11 18:31:00"), jT808_0X0200_0X66.AlarmTime);
+            Assert.Equal(7, jT808_0X0200_0X66.Altitude);
+            Assert.Equal(2, jT808_0X0200_0X66.AlarmOrEventCount);
+            Assert.Equal(1, jT808_0X0200_0X66.AlarmOrEvents[0].AlarmOrEventType);
+            Assert.Equal(2, jT808_0X0200_0X66.AlarmOrEvents[0].BatteryLevel);
+            Assert.Equal(3, jT808_0X0200_0X66.AlarmOrEvents[0].TirePressure);
+            Assert.Equal(4, jT808_0X0200_0X66.AlarmOrEvents[0].TirePressureAlarmPosition);
+            Assert.Equal(5, jT808_0X0200_0X66.AlarmOrEvents[0].TireTemperature);
+            Assert.Equal(6, jT808_0X0200_0X66.AlarmOrEvents[1].AlarmOrEventType);
+            Assert.Equal(7, jT808_0X0200_0X66.AlarmOrEvents[1].BatteryLevel);
+            Assert.Equal(8, jT808_0X0200_0X66.AlarmOrEvents[1].TirePressure);
+            Assert.Equal(9, jT808_0X0200_0X66.AlarmOrEvents[1].TirePressureAlarmPosition);
+            Assert.Equal(10, jT808_0X0200_0X66.AlarmOrEvents[1].TireTemperature);
+            Assert.Equal(0x66, jT808_0X0200_0X66.AttachInfoId);
+            Assert.Equal(12, jT808_0X0200_0X66.FlagState);
+            Assert.Equal(13, jT808_0X0200_0X66.Latitude);
+            Assert.Equal(14, jT808_0X0200_0X66.Longitude);
+            Assert.Equal(17, jT808_0X0200_0X66.Speed);
+            Assert.Equal(19, jT808_0X0200_0X66.VehicleState);
+        }
+    }
+}

src/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808_0x0200_0x67_Test.cs

@@ -0,0 +1,84 @@
+using JT808.Protocol.Extensions.JTActiveSafety.MessageBody;
+using JT808.Protocol.MessageBody;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace JT808.Protocol.Extensions.JTActiveSafety.Test
+{
+    public class JT808_0x0200_0x67_Test
+    {
+        JT808Serializer JT808Serializer;
+        public JT808_0x0200_0x67_Test()
+        {
+            ServiceCollection serviceDescriptors = new ServiceCollection();
+            serviceDescriptors.AddJT808Configure()
+                                        .AddJTActiveSafetyConfigure();
+            IJT808Config jT808Config = serviceDescriptors.BuildServiceProvider().GetRequiredService<IJT808Config>();
+            JT808Serializer = new JT808Serializer(jT808Config);
+        }
+        [Fact]
+        public void Serializer()
+        {
+            JT808_0x0200 jT808UploadLocationRequest = new JT808_0x0200
+            {
+                AlarmFlag = 1,
+                Altitude = 40,
+                GPSTime = DateTime.Parse("2018-07-15 10:10:10"),
+                Lat = 12222222,
+                Lng = 132444444,
+                Speed = 60,
+                Direction = 0,
+                StatusFlag = 2,
+                JT808LocationAttachData = new Dictionary<byte, JT808_0x0200_BodyBase>()
+            };
+            jT808UploadLocationRequest.JT808LocationAttachData.Add(JT808_JTActiveSafety_Constants.JT808_0X0200_0x67, new JT808_0x0200_0x67
+            {
+                AlarmId = 1,
+                AlarmIdentification = new Metadata.AlarmIdentificationProperty
+                {
+                    AttachCount = 2,
+                    SN = 3,
+                    TerminalID = "4444444",
+                    Time = Convert.ToDateTime("2019-12-10 18:31:00")
+                },
+                AlarmTime = Convert.ToDateTime("2019-12-11 18:31:00"),
+                Altitude = 7,
+                AlarmLevel=8,
+                AlarmOrEventType=9,
+                FlagState = 12,
+                Latitude = 13,
+                Longitude = 14,
+                Speed = 17,
+                VehicleState = 19
+            });
+            var hex = JT808Serializer.Serialize(jT808UploadLocationRequest).ToHexString();
+            Assert.Equal("000000010000000200BA7F0E07E4F11C0028003C0000180715101010671A000000010C09081100070000000D0000000E191211183100001334343434343434191210183100030200", hex);
+        }
+        [Fact]
+        public void Deserialize()
+        {
+            var jT808UploadLocationRequest = JT808Serializer.Deserialize<JT808_0x0200>("000000010000000200BA7F0E07E4F11C0028003C0000180715101010671A000000010C09081100070000000D0000000E191211183100001334343434343434191210183100030200".ToHexBytes());
+            jT808UploadLocationRequest.JT808LocationAttachData.TryGetValue(JT808_JTActiveSafety_Constants.JT808_0X0200_0x67, out var value);
+            JT808_0x0200_0x67 jT808_0X0200_0X67 = value as JT808_0x0200_0x67;
+            Assert.Equal(1u, jT808_0X0200_0X67.AlarmId);
+            Assert.Equal(2, jT808_0X0200_0X67.AlarmIdentification.AttachCount);
+            Assert.Equal(3, jT808_0X0200_0X67.AlarmIdentification.SN);
+            Assert.Equal("4444444", jT808_0X0200_0X67.AlarmIdentification.TerminalID);
+            Assert.Equal(Convert.ToDateTime("2019-12-10 18:31:00"), jT808_0X0200_0X67.AlarmIdentification.Time);
+            Assert.Equal(Convert.ToDateTime("2019-12-11 18:31:00"), jT808_0X0200_0X67.AlarmTime);
+            Assert.Equal(7, jT808_0X0200_0X67.Altitude);
+            Assert.Equal(8, jT808_0X0200_0X67.AlarmLevel);
+            Assert.Equal(9, jT808_0X0200_0X67.AlarmOrEventType);
+            Assert.Equal(0x67, jT808_0X0200_0X67.AttachInfoId);
+            Assert.Equal(26, jT808_0X0200_0X67.AttachInfoLength);
+            Assert.Equal(12, jT808_0X0200_0X67.FlagState);
+            Assert.Equal(13, jT808_0X0200_0X67.Latitude);
+            Assert.Equal(14, jT808_0X0200_0X67.Longitude);
+            Assert.Equal(17, jT808_0X0200_0X67.Speed);
+            Assert.Equal(19, jT808_0X0200_0X67.VehicleState);
+        }
+    }
+}

src/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808_0x1210_Test.cs

@@ -0,0 +1,76 @@
+using JT808.Protocol.Extensions.JTActiveSafety.MessageBody;
+using JT808.Protocol.MessageBody;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace JT808.Protocol.Extensions.JTActiveSafety.Test
+{
+    public class JT808_0x1210_Test
+    {
+        JT808Serializer JT808Serializer;
+        public JT808_0x1210_Test()
+        {
+            ServiceCollection serviceDescriptors = new ServiceCollection();
+            serviceDescriptors.AddJT808Configure()
+                                        .AddJTActiveSafetyConfigure();
+            IJT808Config jT808Config = serviceDescriptors.BuildServiceProvider().GetRequiredService<IJT808Config>();
+            JT808Serializer = new JT808Serializer(jT808Config);
+        }
+        [Fact]
+        public void Serializer()
+        {
+            JT808_0x1210 jT808UploadLocationRequest = new JT808_0x1210
+            {
+                AlarmId = "11111111111111111111111111111111",
+                AlarmIdentification = new Metadata.AlarmIdentificationProperty
+                {
+                    Retain = 1,
+                    AttachCount = 2,
+                    SN = 3,
+                    TerminalID = "4444444",
+                    Time = Convert.ToDateTime("2019-12-10 18:31:00")
+                }, 
+                AttachInfos = new List<Metadata.AttachProperty> {
+                    new Metadata.AttachProperty{ 
+                        FileName="filename",
+                        FileSize=9
+                    },
+                    new Metadata.AttachProperty{
+                        FileName="filename1",
+                        FileSize=10
+                    }
+                },
+                TerminalID = "4444444",
+                InfoType = 0
+            };
+            var hex = JT808Serializer.Serialize(jT808UploadLocationRequest).ToHexString();
+            Assert.Equal("3434343434343434343434343434191210183100030201313131313131313131313131313131313131313131313131313131313131313100020866696C656E616D65000000090966696C656E616D65310000000A", hex);
+        }
+        [Fact]
+        public void Deserialize()
+        {
+            var jT808UploadLocationRequest = JT808Serializer.Deserialize<JT808_0x1210>("3434343434343434343434343434191210183100030201313131313131313131313131313131313131313131313131313131313131313100020866696C656E616D65000000090966696C656E616D65310000000A".ToHexBytes());
+            Assert.Equal("11111111111111111111111111111111", jT808UploadLocationRequest.AlarmId);
+            Assert.Equal(2, jT808UploadLocationRequest.AlarmIdentification.AttachCount);
+            Assert.Equal(3, jT808UploadLocationRequest.AlarmIdentification.SN);
+            Assert.Equal("4444444", jT808UploadLocationRequest.AlarmIdentification.TerminalID);
+            Assert.Equal(Convert.ToDateTime("2019-12-10 18:31:00"), jT808UploadLocationRequest.AlarmIdentification.Time);
+            Assert.Equal(2, jT808UploadLocationRequest.AttachCount);
+
+            Assert.Equal("filename", jT808UploadLocationRequest.AttachInfos[0].FileName);
+            Assert.Equal(8, jT808UploadLocationRequest.AttachInfos[0].FileNameLength);
+            Assert.Equal(9u, jT808UploadLocationRequest.AttachInfos[0].FileSize);
+
+            Assert.Equal("filename1", jT808UploadLocationRequest.AttachInfos[1].FileName);
+            Assert.Equal(9, jT808UploadLocationRequest.AttachInfos[1].FileNameLength);
+            Assert.Equal(10u, jT808UploadLocationRequest.AttachInfos[1].FileSize);
+
+            Assert.Equal("4444444", jT808UploadLocationRequest.TerminalID);
+            Assert.Equal(0, jT808UploadLocationRequest.InfoType);
+
+        }
+    }
+}

src/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808_0x1211_Test.cs

@@ -0,0 +1,44 @@
+using JT808.Protocol.Extensions.JTActiveSafety.MessageBody;
+using JT808.Protocol.MessageBody;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace JT808.Protocol.Extensions.JTActiveSafety.Test
+{
+    public class JT808_0x1211_Test
+    {
+        JT808Serializer JT808Serializer;
+        public JT808_0x1211_Test()
+        {
+            ServiceCollection serviceDescriptors = new ServiceCollection();
+            serviceDescriptors.AddJT808Configure()
+                                        .AddJTActiveSafetyConfigure();
+            IJT808Config jT808Config = serviceDescriptors.BuildServiceProvider().GetRequiredService<IJT808Config>();
+            JT808Serializer = new JT808Serializer(jT808Config);
+        }
+        [Fact]
+        public void Serializer()
+        {
+            JT808_0x1211 jT808UploadLocationRequest = new JT808_0x1211
+            {
+                FileName= "FileName",
+                FileSize=1,
+                FileType=2                    
+            };
+            var hex = JT808Serializer.Serialize(jT808UploadLocationRequest).ToHexString();
+            Assert.Equal("0846696C654E616D650200000001", hex);
+        }
+        [Fact]
+        public void Deserialize()
+        {
+            var jT808UploadLocationRequest = JT808Serializer.Deserialize<JT808_0x1211>("0846696C654E616D650200000001".ToHexBytes());
+            Assert.Equal("FileName", jT808UploadLocationRequest.FileName);
+            Assert.Equal(1u, jT808UploadLocationRequest.FileSize);
+            Assert.Equal(2, jT808UploadLocationRequest.FileType);
+            Assert.Equal("FileName".Length, jT808UploadLocationRequest.FileNameLength);
+        }
+    }
+}

src/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808_0x1212_Test.cs

@@ -0,0 +1,44 @@
+using JT808.Protocol.Extensions.JTActiveSafety.MessageBody;
+using JT808.Protocol.MessageBody;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace JT808.Protocol.Extensions.JTActiveSafety.Test
+{
+    public class JT808_0x1212_Test
+    {
+        JT808Serializer JT808Serializer;
+        public JT808_0x1212_Test()
+        {
+            ServiceCollection serviceDescriptors = new ServiceCollection();
+            serviceDescriptors.AddJT808Configure()
+                                        .AddJTActiveSafetyConfigure();
+            IJT808Config jT808Config = serviceDescriptors.BuildServiceProvider().GetRequiredService<IJT808Config>();
+            JT808Serializer = new JT808Serializer(jT808Config);
+        }
+        [Fact]
+        public void Serializer()
+        {
+            JT808_0x1212 jT808UploadLocationRequest = new JT808_0x1212
+            {
+                FileName= "FileName",
+                FileSize=1,
+                FileType=2
+            };
+            var hex = JT808Serializer.Serialize(jT808UploadLocationRequest).ToHexString();
+            Assert.Equal("0846696C654E616D650200000001", hex);
+        }
+        [Fact]
+        public void Deserialize()
+        {
+            var jT808UploadLocationRequest = JT808Serializer.Deserialize<JT808_0x1212>("0846696C654E616D650200000001".ToHexBytes());
+            Assert.Equal("FileName", jT808UploadLocationRequest.FileName);
+            Assert.Equal(1u, jT808UploadLocationRequest.FileSize);
+            Assert.Equal(2, jT808UploadLocationRequest.FileType);
+            Assert.Equal("FileName".Length, jT808UploadLocationRequest.FileNameLength);
+        }
+    }
+}

src/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808_0x8103_0xF364_Test.cs

@@ -0,0 +1,133 @@
+using JT808.Protocol.Extensions.JTActiveSafety.MessageBody;
+using JT808.Protocol.MessageBody;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace JT808.Protocol.Extensions.JTActiveSafety.Test
+{
+    public class JT808_0x8103_0xF364_Test
+    {
+        JT808Serializer JT808Serializer;
+        public JT808_0x8103_0xF364_Test()
+        {
+            ServiceCollection serviceDescriptors = new ServiceCollection();
+            serviceDescriptors.AddJT808Configure()
+                                        .AddJTActiveSafetyConfigure();
+            IJT808Config jT808Config = serviceDescriptors.BuildServiceProvider().GetRequiredService<IJT808Config>();
+            JT808Serializer = new JT808Serializer(jT808Config);
+        }
+        [Fact]
+        public void Serializer()
+        {
+            JT808_0x8103 jT808UploadLocationRequest = new JT808_0x8103
+            {                 
+                ParamList=new List<JT808_0x8103_BodyBase> {
+                  new JT808_0x8103_0xF364{
+                    ActiveDistancePhotographyDistanceInterval=1,
+                    ActivelyTimePhotoInterval=2,
+                    ActivePhotographyStrategy=3,
+                    AlarmEnable=4,
+                    AlarmJudgeSpeedThreshold=5,
+                    AlarmPhotoVehicleCloseDistance=6,
+                    AlarmPhotoVehicleCloseDistanceInterval=7,
+                    BarrierAlarmPhotographs=8,
+                    DistanceThresholdObstacleAlarm=9,
+                    EventEnable=10,
+                    ForwardCollisionAlarmInterval=11,
+                    ForwardCollisionAlarmPhotographs=12,
+                    ForwardCollisionWarningTimeThreshold=13,
+                    FrequentAlarmJudgmentNumberChannelChange=14,
+                    FrequentChannelChangeAlarmJudgmentTimePeriod=15,
+                    FrequentChannelChangeAlarmPhotos=16,
+                    FrequentLaneChangeAlarmInterval=17,
+                    GradedSpeedThresholdLaneDeviationAlarm=18,
+                    HierarchicalSpeedThresholdForwardCollisionWarning=19,
+                    HierarchicalSpeedThresholdFrequentChannelChangeAlarm=20,
+                    HierarchicalSpeedThresholdObstacleAlarm=21,
+                    LaneDepartureAlarmPhoto=22,
+                    LaneDepartureAlarmPhotoInterval=23,
+                    ObstacleAlarmInterval=24,
+                    PedestrianCollisionAlarmEnablingSpeedThreshold=25,
+                    PedestrianCollisionAlarmInterval=26,
+                    PedestrianCollisionAlarmPhotos=27,
+                    PedestrianCollisionAlarmTimeThreshold=28,
+                    PhotoResolution=29,
+                    Placeholder1=30,
+                    Placeholder2=new byte[]{1,2,3,4 },
+                    RoadSignRecognitionPhotographs=32,
+                    RoadSignRecognitionPhotographsInterval=33,
+                    SingleInitiativePhotos=34,
+                    SingleInitiativePhotosInterval=35,
+                    VehicleDistanceMonitoringAlarmDistanceThreshold=36,
+                    VehicleDistanceMonitoringAndAlarmClassificationSpeedThreshold=37,
+                    VideoRecordingResolution=38,
+                    VideoRecordingTimeBeforeAndAfterAlarmVehicleProximity=39,
+                    VideoRecordingTimeBeforeAndAfterForwardCollisionAlarm=40,
+                    VideoRecordingTimeBeforeAndAfterFrequentLaneChangeAlarm=41,
+                    VideoRecordingTimeBeforeAndAfterLaneDepartureAlarm=42,
+                    VideoRecordingTimeBeforeAndAfterObstacleAlarm=43,
+                    VideoRecordingTimeBeforeAndAfterPedestrianCollisionAlarm=44,
+                    WarningVolume=45
+                  }
+               }
+            };
+            var hex = JT808Serializer.Serialize(jT808UploadLocationRequest).ToHexString();
+            Assert.Equal("010000F36438052D030002000122231D26000000040000000A1E09152B08180F0E14291011122A16170D13280C0B1C192C1B1A2425270607202101020304", hex);
+        }
+        [Fact]
+        public void Deserialize()
+        {
+            var jT808UploadLocationRequest = JT808Serializer.Deserialize<JT808_0x8103>("010000F36438052D030002000122231D26000000040000000A1E09152B08180F0E14291011122A16170D13280C0B1C192C1B1A2425270607202101020304".ToHexBytes());
+            JT808_0x8103_0xF364 jT808_0X8103_0XF364 = jT808UploadLocationRequest.ParamList[0] as JT808_0x8103_0xF364;
+            Assert.Equal(1, jT808_0X8103_0XF364.ActiveDistancePhotographyDistanceInterval);
+            Assert.Equal(2, jT808_0X8103_0XF364.ActivelyTimePhotoInterval);
+            Assert.Equal(3, jT808_0X8103_0XF364.ActivePhotographyStrategy);
+            Assert.Equal(4u, jT808_0X8103_0XF364.AlarmEnable);
+            Assert.Equal(5, jT808_0X8103_0XF364.AlarmJudgeSpeedThreshold);
+            Assert.Equal(6, jT808_0X8103_0XF364.AlarmPhotoVehicleCloseDistance);
+            Assert.Equal(7, jT808_0X8103_0XF364.AlarmPhotoVehicleCloseDistanceInterval);
+            Assert.Equal(8, jT808_0X8103_0XF364.BarrierAlarmPhotographs);
+            Assert.Equal(9, jT808_0X8103_0XF364.DistanceThresholdObstacleAlarm);
+            Assert.Equal(10u, jT808_0X8103_0XF364.EventEnable);
+            Assert.Equal(11, jT808_0X8103_0XF364.ForwardCollisionAlarmInterval);
+            Assert.Equal(12, jT808_0X8103_0XF364.ForwardCollisionAlarmPhotographs);
+            Assert.Equal(13, jT808_0X8103_0XF364.ForwardCollisionWarningTimeThreshold);
+            Assert.Equal(14, jT808_0X8103_0XF364.FrequentAlarmJudgmentNumberChannelChange);
+            Assert.Equal(15, jT808_0X8103_0XF364.FrequentChannelChangeAlarmJudgmentTimePeriod);
+            Assert.Equal(16, jT808_0X8103_0XF364.FrequentChannelChangeAlarmPhotos);
+            Assert.Equal(17, jT808_0X8103_0XF364.FrequentLaneChangeAlarmInterval);
+            Assert.Equal(18, jT808_0X8103_0XF364.GradedSpeedThresholdLaneDeviationAlarm);
+            Assert.Equal(19, jT808_0X8103_0XF364.HierarchicalSpeedThresholdForwardCollisionWarning);
+            Assert.Equal(20, jT808_0X8103_0XF364.HierarchicalSpeedThresholdFrequentChannelChangeAlarm);
+            Assert.Equal(21, jT808_0X8103_0XF364.HierarchicalSpeedThresholdObstacleAlarm);
+            Assert.Equal(22, jT808_0X8103_0XF364.LaneDepartureAlarmPhoto);
+            Assert.Equal(23, jT808_0X8103_0XF364.LaneDepartureAlarmPhotoInterval);
+            Assert.Equal(24, jT808_0X8103_0XF364.ObstacleAlarmInterval);
+            Assert.Equal(25, jT808_0X8103_0XF364.PedestrianCollisionAlarmEnablingSpeedThreshold);
+            Assert.Equal(26, jT808_0X8103_0XF364.PedestrianCollisionAlarmInterval);
+            Assert.Equal(27, jT808_0X8103_0XF364.PedestrianCollisionAlarmPhotos);
+            Assert.Equal(28, jT808_0X8103_0XF364.PedestrianCollisionAlarmTimeThreshold);
+            Assert.Equal(29, jT808_0X8103_0XF364.PhotoResolution);
+            Assert.Equal(30, jT808_0X8103_0XF364.Placeholder1);
+            Assert.Equal(new byte[] { 1, 2, 3, 4 }.ToHexString(), jT808_0X8103_0XF364.Placeholder2.ToHexString());
+            Assert.Equal(32, jT808_0X8103_0XF364.RoadSignRecognitionPhotographs);
+            Assert.Equal(33, jT808_0X8103_0XF364.RoadSignRecognitionPhotographsInterval);
+            Assert.Equal(34, jT808_0X8103_0XF364.SingleInitiativePhotos);
+            Assert.Equal(35, jT808_0X8103_0XF364.SingleInitiativePhotosInterval);
+            Assert.Equal(36, jT808_0X8103_0XF364.VehicleDistanceMonitoringAlarmDistanceThreshold);
+            Assert.Equal(37, jT808_0X8103_0XF364.VehicleDistanceMonitoringAndAlarmClassificationSpeedThreshold);
+            Assert.Equal(38, jT808_0X8103_0XF364.VideoRecordingResolution);
+            Assert.Equal(39, jT808_0X8103_0XF364.VideoRecordingTimeBeforeAndAfterAlarmVehicleProximity);
+            Assert.Equal(40, jT808_0X8103_0XF364.VideoRecordingTimeBeforeAndAfterForwardCollisionAlarm);
+            Assert.Equal(41, jT808_0X8103_0XF364.VideoRecordingTimeBeforeAndAfterFrequentLaneChangeAlarm);
+            Assert.Equal(42, jT808_0X8103_0XF364.VideoRecordingTimeBeforeAndAfterLaneDepartureAlarm);
+            Assert.Equal(43, jT808_0X8103_0XF364.VideoRecordingTimeBeforeAndAfterObstacleAlarm);
+            Assert.Equal(44, jT808_0X8103_0XF364.VideoRecordingTimeBeforeAndAfterPedestrianCollisionAlarm);
+            Assert.Equal(45, jT808_0X8103_0XF364.WarningVolume);
+            Assert.Equal(JT808_JTActiveSafety_Constants.JT808_0X8103_0xF364, jT808_0X8103_0XF364.ParamId);
+        }
+    }
+}

src/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808_0x8103_0xF365_Test.cs

@@ -0,0 +1,111 @@
+using JT808.Protocol.Extensions.JTActiveSafety.MessageBody;
+using JT808.Protocol.MessageBody;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace JT808.Protocol.Extensions.JTActiveSafety.Test
+{
+    public class JT808_0x8103_0xF365_Test
+    {
+        JT808Serializer JT808Serializer;
+        public JT808_0x8103_0xF365_Test()
+        {
+            ServiceCollection serviceDescriptors = new ServiceCollection();
+            serviceDescriptors.AddJT808Configure()
+                                        .AddJTActiveSafetyConfigure();
+            IJT808Config jT808Config = serviceDescriptors.BuildServiceProvider().GetRequiredService<IJT808Config>();
+            JT808Serializer = new JT808Serializer(jT808Config);
+        }
+        [Fact]
+        public void Serializer()
+        {
+            JT808_0x8103 jT808UploadLocationRequest = new JT808_0x8103
+            {                 
+                ParamList=new List<JT808_0x8103_BodyBase> {
+                  new JT808_0x8103_0xF365{
+                        ActiveDistancePhotographyDistanceInterval=1,
+                        ActivelyTimePhotoInterval=2,
+                        ActivePhotographyStrategy=3,
+                        AlarmEnable=4,
+                        AlarmJudgeSpeedThreshold=5,
+                        EventEnable=10,      
+                        PhotoResolution=29,
+                        SingleInitiativePhotos=34,
+                        SingleInitiativePhotosInterval=35,
+                        VideoRecordingResolution=38,
+                        WarningVolume=45,
+                        CallAlarmDetermineTimeInterval=46,
+                        CallAlarmTakePicturesDriverFacialFeatures=47,
+                        CallAlarmTakePicturesDriverFacialFeaturesInterval=48,
+                        ClassifiedSpeedThresholdCallAlarm=49,
+                        ClassifiedSpeedThresholdDistractedDrivingAlarm=50,
+                        ClassifiedSpeedThresholdSmokingAlarm=51,
+                        DistractedDrivingAlarmPhotography=52,
+                        DistractedDrivingAlarmPhotographyInterval=53,
+                        DriverIdentificationTrigger=54,
+                        FatigueDrivingAlarmPhotograph=55,
+                        FatigueDrivingAlarmPhotographInterval=56,
+                        GradedSpeedThresholdFatigueDrivingAlarm=57,
+                        PhotographsAbnormalDrivingBehavior=58,
+                        PictureIntervalAbnormalDrivingBehavior=59,
+                        Reserve=new byte[]{1,2,3 },
+                        Retain=new byte[]{5,6 },
+                        SmokingAlarmPhotographsDriverFaceCharacteristics=60,
+                        SmokingAlarmPhotographsDriverFaceCharacteristicsInterval=61,
+                        TimeIntervalSmokingAlarmJudgment=62,
+                        VideoRecordingTimeAbnormalDrivingBehavior=63,
+                        VideoRecordingTimeBeforeAndAfterCallAlarm=64,
+                        VideoRecordingTimeBeforeAndAfterFatigueDrivingAlarm=65,
+                        VideoRecordingTimeBeforeAndAfterSmokingAlarm=66
+                  }
+               }
+            };
+            var hex = JT808Serializer.Serialize(jT808UploadLocationRequest).ToHexString();
+            Assert.Equal("010000F3652F052D030002000122231D26000000040000000A003E002E0102033941373831402F3033423C3D3234353F3A3B360506", hex);
+        }
+        [Fact]
+        public void Deserialize()
+        {
+            var jT808UploadLocationRequest = JT808Serializer.Deserialize<JT808_0x8103>("010000F3652F052D030002000122231D26000000040000000A003E002E0102033941373831402F3033423C3D3234353F3A3B360506".ToHexBytes());
+            JT808_0x8103_0xF365 jT808_0X8103_0XF365 = jT808UploadLocationRequest.ParamList[0] as JT808_0x8103_0xF365;
+            Assert.Equal(1, jT808_0X8103_0XF365.ActiveDistancePhotographyDistanceInterval);
+            Assert.Equal(2, jT808_0X8103_0XF365.ActivelyTimePhotoInterval);
+            Assert.Equal(3, jT808_0X8103_0XF365.ActivePhotographyStrategy);
+            Assert.Equal(4u, jT808_0X8103_0XF365.AlarmEnable);
+            Assert.Equal(5, jT808_0X8103_0XF365.AlarmJudgeSpeedThreshold);
+            Assert.Equal(10u, jT808_0X8103_0XF365.EventEnable);
+            Assert.Equal(29, jT808_0X8103_0XF365.PhotoResolution);
+            Assert.Equal(34, jT808_0X8103_0XF365.SingleInitiativePhotos);
+            Assert.Equal(35, jT808_0X8103_0XF365.SingleInitiativePhotosInterval);
+            Assert.Equal(38, jT808_0X8103_0XF365.VideoRecordingResolution);
+            Assert.Equal(45, jT808_0X8103_0XF365.WarningVolume);
+            Assert.Equal(46, jT808_0X8103_0XF365.CallAlarmDetermineTimeInterval);
+            Assert.Equal(47, jT808_0X8103_0XF365.CallAlarmTakePicturesDriverFacialFeatures);
+            Assert.Equal(48, jT808_0X8103_0XF365.CallAlarmTakePicturesDriverFacialFeaturesInterval);
+            Assert.Equal(49, jT808_0X8103_0XF365.ClassifiedSpeedThresholdCallAlarm);
+            Assert.Equal(50, jT808_0X8103_0XF365.ClassifiedSpeedThresholdDistractedDrivingAlarm);
+            Assert.Equal(51, jT808_0X8103_0XF365.ClassifiedSpeedThresholdSmokingAlarm);
+            Assert.Equal(52, jT808_0X8103_0XF365.DistractedDrivingAlarmPhotography);
+            Assert.Equal(53, jT808_0X8103_0XF365.DistractedDrivingAlarmPhotographyInterval);
+            Assert.Equal(54, jT808_0X8103_0XF365.DriverIdentificationTrigger);
+            Assert.Equal(55, jT808_0X8103_0XF365.FatigueDrivingAlarmPhotograph);
+            Assert.Equal(56, jT808_0X8103_0XF365.FatigueDrivingAlarmPhotographInterval);
+            Assert.Equal(57, jT808_0X8103_0XF365.GradedSpeedThresholdFatigueDrivingAlarm);
+            Assert.Equal(58, jT808_0X8103_0XF365.PhotographsAbnormalDrivingBehavior);
+            Assert.Equal(59, jT808_0X8103_0XF365.PictureIntervalAbnormalDrivingBehavior);
+            Assert.Equal(new byte[] { 1, 2, 3 }.ToHexString(), jT808_0X8103_0XF365.Reserve.ToHexString());
+            Assert.Equal(new byte[] { 5, 6 }.ToHexString(), jT808_0X8103_0XF365.Retain.ToHexString());
+            Assert.Equal(60, jT808_0X8103_0XF365.SmokingAlarmPhotographsDriverFaceCharacteristics);
+            Assert.Equal(61, jT808_0X8103_0XF365.SmokingAlarmPhotographsDriverFaceCharacteristicsInterval);
+            Assert.Equal(62, jT808_0X8103_0XF365.TimeIntervalSmokingAlarmJudgment);
+            Assert.Equal(63, jT808_0X8103_0XF365.VideoRecordingTimeAbnormalDrivingBehavior);
+            Assert.Equal(64, jT808_0X8103_0XF365.VideoRecordingTimeBeforeAndAfterCallAlarm);
+            Assert.Equal(65, jT808_0X8103_0XF365.VideoRecordingTimeBeforeAndAfterFatigueDrivingAlarm);
+            Assert.Equal(66, jT808_0X8103_0XF365.VideoRecordingTimeBeforeAndAfterSmokingAlarm);
+            Assert.Equal(JT808_JTActiveSafety_Constants.JT808_0X8103_0xF365, jT808_0X8103_0XF365.ParamId);
+        }
+    }
+}

src/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808_0x8103_0xF366_Test.cs

@@ -0,0 +1,64 @@
+using JT808.Protocol.Extensions.JTActiveSafety.MessageBody;
+using JT808.Protocol.MessageBody;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace JT808.Protocol.Extensions.JTActiveSafety.Test
+{
+    public class JT808_0x8103_0xF366_Test
+    {
+        JT808Serializer JT808Serializer;
+        public JT808_0x8103_0xF366_Test()
+        {
+            ServiceCollection serviceDescriptors = new ServiceCollection();
+            serviceDescriptors.AddJT808Configure()
+                                        .AddJTActiveSafetyConfigure();
+            IJT808Config jT808Config = serviceDescriptors.BuildServiceProvider().GetRequiredService<IJT808Config>();
+            JT808Serializer = new JT808Serializer(jT808Config);
+        }
+        [Fact]
+        public void Serializer()
+        {
+            JT808_0x8103 jT808UploadLocationRequest = new JT808_0x8103
+            {                 
+                ParamList=new List<JT808_0x8103_BodyBase> {
+                  new JT808_0x8103_0xF366{
+                        HighTemperatureThreshold=1,
+                        HighVoltageThreshold=2,
+                        LowVoltageThreshold=3,
+                        NormalFetalPressure=4,
+                        Retain=new byte[]{1,2,3,4,5,6 },
+                        SlowLeakageThreshold=5,
+                        ThresholdUnbalancedTirePressure=6,
+                        TimedReportingInterval=7,
+                        TyrePressureUnit=8,
+                        TyreSpecificationType="999999999999",
+                        VoltageThreshold=10
+                  }
+               }
+            };
+            var hex = JT808Serializer.Serialize(jT808UploadLocationRequest).ToHexString();
+            Assert.Equal("010000F366243939393939393939393939390008000400060005000300020001000A0007010203040506", hex);
+        }
+        [Fact]
+        public void Deserialize()
+        {
+            var jT808UploadLocationRequest = JT808Serializer.Deserialize<JT808_0x8103>("010000F366243939393939393939393939390008000400060005000300020001000A0007010203040506".ToHexBytes());
+            JT808_0x8103_0xF366 jT808_0x8103_0xF366 = jT808UploadLocationRequest.ParamList[0] as JT808_0x8103_0xF366;
+            Assert.Equal(1, jT808_0x8103_0xF366.HighTemperatureThreshold);
+            Assert.Equal(2, jT808_0x8103_0xF366.HighVoltageThreshold);
+            Assert.Equal(3, jT808_0x8103_0xF366.LowVoltageThreshold);
+            Assert.Equal(4, jT808_0x8103_0xF366.NormalFetalPressure);
+            Assert.Equal(new byte[] { 1, 2, 3, 4, 5, 6 }.ToHexString(), jT808_0x8103_0xF366.Retain.ToHexString());
+            Assert.Equal(5, jT808_0x8103_0xF366.SlowLeakageThreshold);
+            Assert.Equal(6, jT808_0x8103_0xF366.ThresholdUnbalancedTirePressure);
+            Assert.Equal(7, jT808_0x8103_0xF366.TimedReportingInterval);
+            Assert.Equal(8, jT808_0x8103_0xF366.TyrePressureUnit);
+            Assert.Equal("999999999999", jT808_0x8103_0xF366.TyreSpecificationType);
+            Assert.Equal(10, jT808_0x8103_0xF366.VoltageThreshold);
+        }
+    }
+}

src/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808_0x8103_0xF367_Test.cs

@@ -0,0 +1,46 @@
+using JT808.Protocol.Extensions.JTActiveSafety.MessageBody;
+using JT808.Protocol.MessageBody;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace JT808.Protocol.Extensions.JTActiveSafety.Test
+{
+    public class JT808_0x8103_0xF367_Test
+    {
+        JT808Serializer JT808Serializer;
+        public JT808_0x8103_0xF367_Test()
+        {
+            ServiceCollection serviceDescriptors = new ServiceCollection();
+            serviceDescriptors.AddJT808Configure()
+                                        .AddJTActiveSafetyConfigure();
+            IJT808Config jT808Config = serviceDescriptors.BuildServiceProvider().GetRequiredService<IJT808Config>();
+            JT808Serializer = new JT808Serializer(jT808Config);
+        }
+        [Fact]
+        public void Serializer()
+        {
+            JT808_0x8103 jT808UploadLocationRequest = new JT808_0x8103
+            {                 
+                ParamList=new List<JT808_0x8103_BodyBase> {
+                  new JT808_0x8103_0xF367{
+                     LateralRearApproachAlarmTimeThreshold=1,
+                     RearApproachAlarmTimeThreshold=2
+                  }
+               }
+            };
+            var hex = JT808Serializer.Serialize(jT808UploadLocationRequest).ToHexString();
+            Assert.Equal("010000F367020201", hex);
+        }
+        [Fact]
+        public void Deserialize()
+        {
+            var jT808UploadLocationRequest = JT808Serializer.Deserialize<JT808_0x8103>("010000F367020201".ToHexBytes());
+            JT808_0x8103_0xF367 jT808_0x8103_0xF367 = jT808UploadLocationRequest.ParamList[0] as JT808_0x8103_0xF367;
+            Assert.Equal(1, jT808_0x8103_0xF367.LateralRearApproachAlarmTimeThreshold);
+            Assert.Equal(2, jT808_0x8103_0xF367.RearApproachAlarmTimeThreshold);
+        }
+    }
+}

src/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808_0x9208_Test.cs

@@ -0,0 +1,58 @@
+using JT808.Protocol.Extensions.JTActiveSafety.MessageBody;
+using JT808.Protocol.MessageBody;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace JT808.Protocol.Extensions.JTActiveSafety.Test
+{
+    public class JT808_0x9208_Test
+    {
+        JT808Serializer JT808Serializer;
+        public JT808_0x9208_Test()
+        {
+            ServiceCollection serviceDescriptors = new ServiceCollection();
+            serviceDescriptors.AddJT808Configure()
+                                        .AddJTActiveSafetyConfigure();
+            IJT808Config jT808Config = serviceDescriptors.BuildServiceProvider().GetRequiredService<IJT808Config>();
+            JT808Serializer = new JT808Serializer(jT808Config);
+        }
+        [Fact]
+        public void Serializer()
+        {
+            JT808_0x9208 jT808UploadLocationRequest = new JT808_0x9208
+            {
+                AlarmId="11111111111111111111111111111111",
+                AlarmIdentification=new Metadata.AlarmIdentificationProperty {
+                    Retain=1,
+                    AttachCount = 2,
+                    SN = 3,
+                    TerminalID = "4444444",
+                    Time = Convert.ToDateTime("2019-12-10 18:31:00")
+                },
+                AttachmentServerIP="192.168.1.1",
+                AttachmentServerIPTcpPort=5000,
+                AttachmentServerIPUdpPort=5001
+            };
+            var hex = JT808Serializer.Serialize(jT808UploadLocationRequest).ToHexString();
+            Assert.Equal("0B3139322E3136382E312E311388138934343434343434191210183100030201313131313131313131313131313131313131313131313131313131313131313100000000000000000000000000000000", hex);
+        }
+        [Fact]
+        public void Deserialize()
+        {
+            var jT808UploadLocationRequest = JT808Serializer.Deserialize<JT808_0x9208>("0B3139322E3136382E312E311388138934343434343434191210183100030201313131313131313131313131313131313131313131313131313131313131313100000000000000000000000000000000".ToHexBytes());
+            Assert.Equal("11111111111111111111111111111111", jT808UploadLocationRequest.AlarmId);
+            Assert.Equal(1, jT808UploadLocationRequest.AlarmIdentification.Retain);
+            Assert.Equal(2, jT808UploadLocationRequest.AlarmIdentification.AttachCount);
+            Assert.Equal(3, jT808UploadLocationRequest.AlarmIdentification.SN);
+            Assert.Equal("4444444", jT808UploadLocationRequest.AlarmIdentification.TerminalID);
+            Assert.Equal(Convert.ToDateTime("2019-12-10 18:31:00"), jT808UploadLocationRequest.AlarmIdentification.Time);
+            Assert.Equal("192.168.1.1", jT808UploadLocationRequest.AttachmentServerIP);
+            Assert.Equal("192.168.1.1".Length, jT808UploadLocationRequest.AttachmentServerIPLength);
+            Assert.Equal(5000, jT808UploadLocationRequest.AttachmentServerIPTcpPort);
+            Assert.Equal(5001, jT808UploadLocationRequest.AttachmentServerIPUdpPort);
+        }
+    }
+}

src/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808_0x9212_Test.cs

@@ -0,0 +1,61 @@
+using JT808.Protocol.Extensions.JTActiveSafety.MessageBody;
+using JT808.Protocol.MessageBody;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace JT808.Protocol.Extensions.JTActiveSafety.Test
+{
+    public class JT808_0x9212_Test
+    {
+        JT808Serializer JT808Serializer;
+        public JT808_0x9212_Test()
+        {
+            ServiceCollection serviceDescriptors = new ServiceCollection();
+            serviceDescriptors.AddJT808Configure()
+                                        .AddJTActiveSafetyConfigure();
+            IJT808Config jT808Config = serviceDescriptors.BuildServiceProvider().GetRequiredService<IJT808Config>();
+            JT808Serializer = new JT808Serializer(jT808Config);
+        }
+        [Fact]
+        public void Serializer()
+        {
+            JT808_0x9212 jT808UploadLocationRequest = new JT808_0x9212
+            {
+                DataPackageCount=2,
+                DataPackages=new List<Metadata.DataPackageProperty> {
+                new Metadata.DataPackageProperty{ 
+                        Length=10,
+                        Offset=20
+                      },
+                new Metadata.DataPackageProperty{
+                        Length=30,
+                        Offset=40
+                      }
+                },
+                FileName= "FileName",
+                FileType=1,
+                UploadResult=2
+            };
+            var hex = JT808Serializer.Serialize(jT808UploadLocationRequest).ToHexString();
+            Assert.Equal("0846696C654E616D65010202000000140000000A000000280000001E", hex);
+        }
+        [Fact]
+        public void Deserialize()
+        {
+            var jT808UploadLocationRequest = JT808Serializer.Deserialize<JT808_0x9212>("0846696C654E616D65010202000000140000000A000000280000001E".ToHexBytes());
+            Assert.Equal(2, jT808UploadLocationRequest.DataPackageCount);
+            Assert.Equal("FileName", jT808UploadLocationRequest.FileName);
+            Assert.Equal(1, jT808UploadLocationRequest.FileType);
+            Assert.Equal(2, jT808UploadLocationRequest.UploadResult);
+
+            Assert.Equal(10u, jT808UploadLocationRequest.DataPackages[0].Length);
+            Assert.Equal(20u, jT808UploadLocationRequest.DataPackages[0].Offset);
+
+            Assert.Equal(30u, jT808UploadLocationRequest.DataPackages[1].Length);
+            Assert.Equal(40u, jT808UploadLocationRequest.DataPackages[1].Offset);
+        }
+    }
+}

src/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808_JTActiveSafety_0x0900_Test.cs

@@ -0,0 +1,79 @@
+using JT808.Protocol.Extensions.JTActiveSafety.MessageBody;
+using JT808.Protocol.MessageBody;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace JT808.Protocol.Extensions.JTActiveSafety.Test
+{
+    public class JT808_JTActiveSafety_0x0900_Test
+    {
+        JT808Serializer JT808Serializer;
+        public JT808_JTActiveSafety_0x0900_Test()
+        {
+            ServiceCollection serviceDescriptors = new ServiceCollection();
+            serviceDescriptors.AddJT808Configure()
+                                        .AddJTActiveSafetyConfigure();
+            IJT808Config jT808Config = serviceDescriptors.BuildServiceProvider().GetRequiredService<IJT808Config>();
+            JT808Serializer = new JT808Serializer(jT808Config);
+        }
+        [Fact]
+        public void Serializer()
+        {
+            JT808_JTActiveSafety_0x0900 jT808UploadLocationRequest = new JT808_JTActiveSafety_0x0900
+            {
+                USBMessageCount=2,
+                USBMessages=new List<JT808_JTActiveSafety_0x0900_USBMessage> {
+                            new JT808_JTActiveSafety_0x0900_USBMessage{
+                                USBID=1,
+                                MessageContentObejct=new JT808_JTActiveSafety_0x0900_USB_0xF7{
+                                AlarmStatus=1,
+                                WorkingCondition=2
+                            }
+                        },
+                new JT808_JTActiveSafety_0x0900_USBMessage{
+                            USBID=2,
+                            MessageContentObejct=new JT808_JTActiveSafety_0x0900_USB_0xF8{
+                                CompantName="CompantName",
+                                CustomerCode="CustomerCode",
+                                DevicesID="DevicesID",
+                                HardwareVersionNumber="HardwareVersionNumber",
+                                ProductModel="ProductModel",
+                                SoftwareVersionNumber="SoftwareVersionNumber"
+                            }                             
+                         }
+                }
+            };
+            var hex = JT808Serializer.Serialize(jT808UploadLocationRequest).ToHexString();
+            Assert.Equal("0201050200000001025C0B436F6D70616E744E616D650C50726F647563744D6F64656C15486172647761726556657273696F6E4E756D62657215536F66747761726556657273696F6E4E756D626572094465766963657349440C437573746F6D6572436F6465", hex);
+        }
+        [Fact]
+        public void Deserialize()
+        {
+            var jT808UploadLocationRequest = JT808Serializer.Deserialize<JT808_JTActiveSafety_0x0900>("0201050200000001025C0B436F6D70616E744E616D650C50726F647563744D6F64656C15486172647761726556657273696F6E4E756D62657215536F66747761726556657273696F6E4E756D626572094465766963657349440C437573746F6D6572436F6465".ToHexBytes());
+            Assert.Equal(2, jT808UploadLocationRequest.USBMessageCount);
+
+            Assert.Equal(1, jT808UploadLocationRequest.USBMessages[0].USBID);
+            JT808_JTActiveSafety_0x0900_USB_0xF7 jT808_JTActiveSafety_0X0900_USB_0XF7 = JT808Serializer.Deserialize< JT808_JTActiveSafety_0x0900_USB_0xF7 >(jT808UploadLocationRequest.USBMessages[0].MessageContent) ;
+            Assert.Equal(1u, jT808_JTActiveSafety_0X0900_USB_0XF7.AlarmStatus);
+            Assert.Equal(2, jT808_JTActiveSafety_0X0900_USB_0XF7.WorkingCondition);
+
+            Assert.Equal(2, jT808UploadLocationRequest.USBMessages[1].USBID);
+            JT808_JTActiveSafety_0x0900_USB_0xF8 jT808_JTActiveSafety_0X0900_USB_0XF8 = JT808Serializer.Deserialize<JT808_JTActiveSafety_0x0900_USB_0xF8>(jT808UploadLocationRequest.USBMessages[1].MessageContent); ;
+            Assert.Equal("CompantName", jT808_JTActiveSafety_0X0900_USB_0XF8.CompantName);
+            Assert.Equal("CompantName".Length, jT808_JTActiveSafety_0X0900_USB_0XF8.CompantNameLength);
+            Assert.Equal("CustomerCode", jT808_JTActiveSafety_0X0900_USB_0XF8.CustomerCode);
+            Assert.Equal("CustomerCode".Length, jT808_JTActiveSafety_0X0900_USB_0XF8.CustomerCodeLength);
+            Assert.Equal("DevicesID", jT808_JTActiveSafety_0X0900_USB_0XF8.DevicesID);
+            Assert.Equal("DevicesID".Length, jT808_JTActiveSafety_0X0900_USB_0XF8.DevicesIDLength);
+            Assert.Equal("HardwareVersionNumber", jT808_JTActiveSafety_0X0900_USB_0XF8.HardwareVersionNumber);
+            Assert.Equal("HardwareVersionNumber".Length, jT808_JTActiveSafety_0X0900_USB_0XF8.HardwareVersionNumberLength);
+            Assert.Equal("ProductModel", jT808_JTActiveSafety_0X0900_USB_0XF8.ProductModel);
+            Assert.Equal("ProductModel".Length, jT808_JTActiveSafety_0X0900_USB_0XF8.ProductModelLength);
+            Assert.Equal("SoftwareVersionNumber", jT808_JTActiveSafety_0X0900_USB_0XF8.SoftwareVersionNumber);
+            Assert.Equal("SoftwareVersionNumber".Length, jT808_JTActiveSafety_0X0900_USB_0XF8.SoftwareVersionNumberLength);
+        }
+    }
+}

src/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808_JTActiveSafety_0x8900_Test.cs

@@ -0,0 +1,41 @@
+using JT808.Protocol.Extensions.JTActiveSafety.MessageBody;
+using JT808.Protocol.MessageBody;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace JT808.Protocol.Extensions.JTActiveSafety.Test
+{
+    public class JT808_JTActiveSafety_0x8900_Test
+    {
+        JT808Serializer JT808Serializer;
+        public JT808_JTActiveSafety_0x8900_Test()
+        {
+            ServiceCollection serviceDescriptors = new ServiceCollection();
+            serviceDescriptors.AddJT808Configure()
+                                        .AddJTActiveSafetyConfigure();
+            IJT808Config jT808Config = serviceDescriptors.BuildServiceProvider().GetRequiredService<IJT808Config>();
+            JT808Serializer = new JT808Serializer(jT808Config);
+        }
+        [Fact]
+        public void Serializer()
+        {
+            JT808_JTActiveSafety_0x8900 jT808UploadLocationRequest = new JT808_JTActiveSafety_0x8900
+            {
+                  USBCount=2,
+                  MultipleUSB=new List<byte> {1,2 }
+            };
+            var hex = JT808Serializer.Serialize(jT808UploadLocationRequest).ToHexString();
+            Assert.Equal("020102", hex);
+        }
+        [Fact]
+        public void Deserialize()
+        {
+            var jT808UploadLocationRequest = JT808Serializer.Deserialize<JT808_JTActiveSafety_0x8900>("020102".ToHexBytes());
+            Assert.Equal(2, jT808UploadLocationRequest.USBCount);
+            Assert.Equal(new List<byte> { 1, 2 }.ToArray().ToHexString(), jT808UploadLocationRequest.MultipleUSB.ToArray().ToHexString());
+        }
+    }
+}

src/JT808.Protocol.Extensions.JTActiveSafety/Extensions/JT808_JTActiveSafety_0x0900_USBMessageExtensions.cs

@@ -1,10 +1,6 @@
 using JT808.Protocol.Extensions.JTActiveSafety.Enums;
-using JT808.Protocol.Extensions.JTActiveSafety.Formatters;
 using JT808.Protocol.Extensions.JTActiveSafety.MessageBody;
 using JT808.Protocol.MessagePack;
-using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace JT808.Protocol.Extensions.JTActiveSafety.Extensions
 {
@@ -22,11 +18,11 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.Extensions
             {
                 case JT808_JTActiveSafety_0x0900_Type.QueryState:
                     JT808MessagePackReader QueryStateMessagePackReader = new JT808MessagePackReader(jT808_JTActiveSafety_0X0900_USBMessage.MessageContent);
-                    jT808_JTActiveSafety_0X0900_USBMessage.MessageContentObejct=JT808_JTActiveSafety_0x0900_USB_0xF7_Formatter.Instance.Deserialize(ref QueryStateMessagePackReader, null);
+                    jT808_JTActiveSafety_0X0900_USBMessage.MessageContentObejct= JT808_JTActiveSafety_0x0900_USB_0xF7.Instance.Deserialize(ref QueryStateMessagePackReader, null);
                     break;
                 case JT808_JTActiveSafety_0x0900_Type.QueryInfomation:
                     JT808MessagePackReader QueryInfomationMessagePackReader = new JT808MessagePackReader(jT808_JTActiveSafety_0X0900_USBMessage.MessageContent);
-                    jT808_JTActiveSafety_0X0900_USBMessage.MessageContentObejct = JT808_JTActiveSafety_0x0900_USB_0xF7_Formatter.Instance.Deserialize(ref QueryInfomationMessagePackReader, null);
+                    jT808_JTActiveSafety_0X0900_USBMessage.MessageContentObejct = JT808_JTActiveSafety_0x0900_USB_0xF7.Instance.Deserialize(ref QueryInfomationMessagePackReader, null);
                     break;
             }
         }

src/JT808.Protocol.Extensions.JTActiveSafety/JT808.Protocol.Extensions.JTActiveSafety.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFrameworks>netstandard2.0;netstandard2.1;</TargetFrameworks>
     <LangVersion>7.3</LangVersion>
     <Copyright>Copyright 2019.</Copyright>
     <Authors>SmallChi(Koike)</Authors>
@@ -15,12 +15,29 @@
     <licenseUrl>https://github.com/SmallChi/JTActiveSafety/blob/master/LICENSE</licenseUrl>
     <license>https://github.com/SmallChi/JTActiveSafety/blob/master/LICENSE</license>
     <GeneratePackageOnBuild>false</GeneratePackageOnBuild>
-    <Version>2.1.6</Version>
+    <Version>2.2.2</Version>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="JT808" Version="2.1.6" />
+    <Compile Remove="Formatters\JT808_0x0200_0x64_Formatter.cs" />
+    <Compile Remove="Formatters\JT808_0x0200_0x65_Formatter.cs" />
+    <Compile Remove="Formatters\JT808_0x0200_0x66_Formatter.cs" />
+    <Compile Remove="Formatters\JT808_0x0200_0x67_Formatter.cs" />
+    <Compile Remove="Formatters\JT808_0x1210_Formatter.cs" />
+    <Compile Remove="Formatters\JT808_0x1211_Formatter.cs" />
+    <Compile Remove="Formatters\JT808_0x1212_Formatter.cs" />
+    <Compile Remove="Formatters\JT808_0x8103_0xF364_Formatter.cs" />
+    <Compile Remove="Formatters\JT808_0x8103_0xF365_Formatter.cs" />
+    <Compile Remove="Formatters\JT808_0x8103_0xF366_Formatter.cs" />
+    <Compile Remove="Formatters\JT808_0x8103_0xF367_Formatter.cs" />
+    <Compile Remove="Formatters\JT808_0x9208_Formatter.cs" />
+    <Compile Remove="Formatters\JT808_0x9212_Formatter.cs" />
+    <Compile Remove="Formatters\JT808_AlarmIdentificationProperty_Formatter.cs" />
+    <Compile Remove="Formatters\JT808_JTActiveSafety_0x0900_Formatter.cs" />
+    <Compile Remove="Formatters\JT808_JTActiveSafety_0x0900_USB_0xF7_Formatter.cs" />
+    <Compile Remove="Formatters\JT808_JTActiveSafety_0x0900_USB_0xF8_Formatter.cs" />
+    <Compile Remove="Formatters\JT808_JTActiveSafety_0x8900_Formatter.cs" />
   </ItemGroup>
 
   <ItemGroup>
@@ -30,6 +47,14 @@
     </None>
   </ItemGroup>
 
+  <ItemGroup>
+    <Folder Include="Formatters\" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="JT808" Version="2.2.2" />
+  </ItemGroup>
+
 
 
 </Project>

src/JT808.Protocol.Extensions.JTActiveSafety/JTActiveSafetyDependencyInjectionExtensions.cs

@@ -14,19 +14,6 @@ namespace JT808.Protocol.Extensions.JTActiveSafety
         public static IJT808Builder AddJTActiveSafetyConfigure(this IJT808Builder jT808Builder)
         {
             jT808Builder.Config.Register(Assembly.GetExecutingAssembly());
-            jT808Builder.Config.MsgIdFactory.SetMap<JT808_0x1210>((ushort)JT808_JTActiveSafety_MsgId.报警附件信息消息, "");
-            jT808Builder.Config.MsgIdFactory.SetMap<JT808_0x1211>((ushort)JT808_JTActiveSafety_MsgId.文件信息上传, "");
-            jT808Builder.Config.MsgIdFactory.SetMap<JT808_0x1212>((ushort)JT808_JTActiveSafety_MsgId.文件上传完成消息, "");
-            jT808Builder.Config.MsgIdFactory.SetMap<JT808_0x9208>((ushort)JT808_JTActiveSafety_MsgId.报警附件上传指令, "");
-            jT808Builder.Config.MsgIdFactory.SetMap<JT808_0x9212>((ushort)JT808_JTActiveSafety_MsgId.文件上传完成消息应答, "");
-            jT808Builder.Config.JT808_0X0200_Factory.JT808LocationAttachMethod.Add(JT808_JTActiveSafety_Constants.JT808_0X0200_0x64, typeof(JT808_0x0200_0x64));
-            jT808Builder.Config.JT808_0X0200_Factory.JT808LocationAttachMethod.Add(JT808_JTActiveSafety_Constants.JT808_0X0200_0x65, typeof(JT808_0x0200_0x65));
-            jT808Builder.Config.JT808_0X0200_Factory.JT808LocationAttachMethod.Add(JT808_JTActiveSafety_Constants.JT808_0X0200_0x66, typeof(JT808_0x0200_0x66));
-            jT808Builder.Config.JT808_0X0200_Factory.JT808LocationAttachMethod.Add(JT808_JTActiveSafety_Constants.JT808_0X0200_0x67, typeof(JT808_0x0200_0x67));
-            jT808Builder.Config.JT808_0X8103_Factory.ParamMethods.Add(JT808_JTActiveSafety_Constants.JT808_0X8103_0xF364, typeof(JT808_0x8103_0xF364));
-            jT808Builder.Config.JT808_0X8103_Factory.ParamMethods.Add(JT808_JTActiveSafety_Constants.JT808_0X8103_0xF365, typeof(JT808_0x8103_0xF365));
-            jT808Builder.Config.JT808_0X8103_Factory.ParamMethods.Add(JT808_JTActiveSafety_Constants.JT808_0X8103_0xF366, typeof(JT808_0x8103_0xF366));
-            jT808Builder.Config.JT808_0X8103_Factory.ParamMethods.Add(JT808_JTActiveSafety_Constants.JT808_0X8103_0xF367, typeof(JT808_0x8103_0xF367));
             return jT808Builder;
         }
     }

src/JT808.Protocol.Extensions.JTActiveSafety/MessageBody/JT808_0x0200_0x64.cs

@@ -1,7 +1,7 @@
-using JT808.Protocol.Attributes;
-using JT808.Protocol.Extensions.JTActiveSafety.Formatters;
-using JT808.Protocol.Extensions.JTActiveSafety.Metadata;
+using JT808.Protocol.Extensions.JTActiveSafety.Metadata;
+using JT808.Protocol.Formatters;
 using JT808.Protocol.MessageBody;
+using JT808.Protocol.MessagePack;
 using System;
 using System.Collections.Generic;
 using System.Text;
@@ -11,8 +11,7 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
     /// <summary>
     /// 高级驾驶辅助系统报警信息
     /// </summary>
-    [JT808Formatter(typeof(JT808_0x0200_0x64_Formatter))]
-    public class JT808_0x0200_0x64 : JT808_0x0200_BodyBase
+    public class JT808_0x0200_0x64 : JT808_0x0200_BodyBase, IJT808MessagePackFormatter<JT808_0x0200_0x64>
     {
         public override byte AttachInfoId { get; set; } = 0x64;
         public override byte AttachInfoLength { get; set; } = 32;
@@ -82,5 +81,65 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
         /// 报警标识号
         /// </summary>
         public AlarmIdentificationProperty AlarmIdentification { get; set; }
+
+        public JT808_0x0200_0x64 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+        {          
+            JT808_0x0200_0x64 jT808_0X0200_0X64 = new JT808_0x0200_0x64();
+            jT808_0X0200_0X64.AttachInfoId = reader.ReadByte();
+            jT808_0X0200_0X64.AttachInfoLength = reader.ReadByte();
+            jT808_0X0200_0X64.AlarmId = reader.ReadUInt32();
+            jT808_0X0200_0X64.FlagState = reader.ReadByte();
+            jT808_0X0200_0X64.AlarmOrEventType = reader.ReadByte();
+            jT808_0X0200_0X64.AlarmLevel = reader.ReadByte();
+            jT808_0X0200_0X64.VehicleSpeed = reader.ReadByte();
+            jT808_0X0200_0X64.CarOrPedestrianDistanceAhead = reader.ReadByte();
+            jT808_0X0200_0X64.DeviateType = reader.ReadByte();
+            jT808_0X0200_0X64.RoadSignIdentificationType = reader.ReadByte();
+            jT808_0X0200_0X64.RoadSignIdentificationData = reader.ReadByte();
+            jT808_0X0200_0X64.Speed = reader.ReadByte();
+            jT808_0X0200_0X64.Altitude = reader.ReadUInt16();
+            jT808_0X0200_0X64.Latitude = (int)reader.ReadUInt32();
+            jT808_0X0200_0X64.Longitude = (int)reader.ReadUInt32();
+            jT808_0X0200_0X64.AlarmTime = reader.ReadDateTime6();
+            jT808_0X0200_0X64.VehicleState = reader.ReadUInt16();
+            jT808_0X0200_0X64.AlarmIdentification = new AlarmIdentificationProperty
+            {
+                TerminalID = reader.ReadString(7),
+                Time = reader.ReadDateTime6(),
+                SN = reader.ReadByte(),
+                AttachCount = reader.ReadByte(),
+                Retain = reader.ReadByte()
+            };
+            return jT808_0X0200_0X64;
+        }
+
+        public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0200_0x64 value, IJT808Config config)
+        {
+            writer.WriteByte(value.AttachInfoId);
+            writer.WriteByte(value.AttachInfoLength);
+            writer.WriteUInt32(value.AlarmId);
+            writer.WriteByte(value.FlagState);
+            writer.WriteByte(value.AlarmOrEventType);
+            writer.WriteByte(value.AlarmLevel);
+            writer.WriteByte(value.VehicleSpeed);
+            writer.WriteByte(value.CarOrPedestrianDistanceAhead);
+            writer.WriteByte(value.DeviateType);
+            writer.WriteByte(value.RoadSignIdentificationType);
+            writer.WriteByte(value.RoadSignIdentificationData);
+            writer.WriteByte(value.Speed);
+            writer.WriteUInt16(value.Altitude);
+            writer.WriteUInt32((uint)value.Latitude);
+            writer.WriteUInt32((uint)value.Longitude);
+            writer.WriteDateTime6(value.AlarmTime);
+            writer.WriteUInt16(value.VehicleState);
+            if (value.AlarmIdentification == null) {
+                throw new NullReferenceException($"{nameof(AlarmIdentificationProperty)}不为空");
+            }
+            writer.WriteString(value.AlarmIdentification.TerminalID);
+            writer.WriteDateTime6(value.AlarmIdentification.Time);
+            writer.WriteByte(value.AlarmIdentification.SN);
+            writer.WriteByte(value.AlarmIdentification.AttachCount);
+            writer.WriteByte(value.AlarmIdentification.Retain);
+        }
     }
 }

src/JT808.Protocol.Extensions.JTActiveSafety/MessageBody/JT808_0x0200_0x65.cs

@@ -1,7 +1,7 @@
-using JT808.Protocol.Attributes;
-using JT808.Protocol.Extensions.JTActiveSafety.Formatters;
-using JT808.Protocol.Extensions.JTActiveSafety.Metadata;
+using JT808.Protocol.Extensions.JTActiveSafety.Metadata;
+using JT808.Protocol.Formatters;
 using JT808.Protocol.MessageBody;
+using JT808.Protocol.MessagePack;
 using System;
 using System.Collections.Generic;
 using System.Text;
@@ -11,8 +11,7 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
     /// <summary>
     /// 驾驶员状态监测系统报警信息
     /// </summary>
-    [JT808Formatter(typeof(JT808_0x0200_0x65_Formatter))]
-    public class JT808_0x0200_0x65 : JT808_0x0200_BodyBase
+    public class JT808_0x0200_0x65 : JT808_0x0200_BodyBase, IJT808MessagePackFormatter<JT808_0x0200_0x65>
     {
         public override byte AttachInfoId { get; set; } = 0x65;
         public override byte AttachInfoLength { get; set; } = 32;
@@ -70,5 +69,64 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
         /// 报警标识号
         /// </summary>
         public AlarmIdentificationProperty AlarmIdentification { get; set; }
+
+        public JT808_0x0200_0x65 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+        {
+            JT808_0x0200_0x65 jT808_0X0200_0X65 = new JT808_0x0200_0x65();
+            jT808_0X0200_0X65.AttachInfoId = reader.ReadByte();
+            jT808_0X0200_0X65.AttachInfoLength = reader.ReadByte();
+            jT808_0X0200_0X65.AlarmId = reader.ReadUInt32();
+            jT808_0X0200_0X65.FlagState = reader.ReadByte();
+            jT808_0X0200_0X65.AlarmOrEventType = reader.ReadByte();
+            jT808_0X0200_0X65.AlarmLevel = reader.ReadByte();
+            jT808_0X0200_0X65.Fatigue = reader.ReadByte();
+            jT808_0X0200_0X65.Retain = reader.ReadArray(4).ToArray();
+            jT808_0X0200_0X65.Speed = reader.ReadByte();
+            jT808_0X0200_0X65.Altitude = reader.ReadUInt16();
+            jT808_0X0200_0X65.Latitude = (int)reader.ReadUInt32();
+            jT808_0X0200_0X65.Longitude = (int)reader.ReadUInt32();
+            jT808_0X0200_0X65.AlarmTime = reader.ReadDateTime6();
+            jT808_0X0200_0X65.VehicleState = reader.ReadUInt16();
+            jT808_0X0200_0X65.AlarmIdentification = new AlarmIdentificationProperty
+            {
+                TerminalID = reader.ReadString(7),
+                Time = reader.ReadDateTime6(),
+                SN = reader.ReadByte(),
+                AttachCount = reader.ReadByte(),
+                Retain = reader.ReadByte()
+            };
+            return jT808_0X0200_0X65;
+        }
+
+        public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0200_0x65 value, IJT808Config config)
+        {
+            writer.WriteByte(value.AttachInfoId);
+            writer.WriteByte(value.AttachInfoLength);
+            writer.WriteUInt32(value.AlarmId);
+            writer.WriteByte(value.FlagState);
+            writer.WriteByte(value.AlarmOrEventType);
+            writer.WriteByte(value.AlarmLevel);
+            writer.WriteByte(value.Fatigue);
+            if (value.Retain.Length != 4)
+            {
+                throw new ArgumentOutOfRangeException($"{nameof(JT808_0x0200_0x65.Retain)} length==4");
+            }
+            writer.WriteArray(value.Retain);
+            writer.WriteByte(value.Speed);
+            writer.WriteUInt16(value.Altitude);
+            writer.WriteUInt32((uint)value.Latitude);
+            writer.WriteUInt32((uint)value.Longitude);
+            writer.WriteDateTime6(value.AlarmTime);
+            writer.WriteUInt16(value.VehicleState);
+            if (value.AlarmIdentification == null)
+            {
+                throw new NullReferenceException($"{nameof(AlarmIdentificationProperty)}不为空");
+            }
+            writer.WriteString(value.AlarmIdentification.TerminalID);
+            writer.WriteDateTime6(value.AlarmIdentification.Time);
+            writer.WriteByte(value.AlarmIdentification.SN);
+            writer.WriteByte(value.AlarmIdentification.AttachCount);
+            writer.WriteByte(value.AlarmIdentification.Retain);
+        }
     }
 }

src/JT808.Protocol.Extensions.JTActiveSafety/MessageBody/JT808_0x0200_0x66.cs

@@ -1,7 +1,7 @@
-using JT808.Protocol.Attributes;
-using JT808.Protocol.Extensions.JTActiveSafety.Formatters;
-using JT808.Protocol.Extensions.JTActiveSafety.Metadata;
+using JT808.Protocol.Extensions.JTActiveSafety.Metadata;
+using JT808.Protocol.Formatters;
 using JT808.Protocol.MessageBody;
+using JT808.Protocol.MessagePack;
 using System;
 using System.Collections.Generic;
 using System.Text;
@@ -11,8 +11,7 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
     /// <summary>
     /// 胎压监测系统报警信息
     /// </summary>
-    [JT808Formatter(typeof(JT808_0x0200_0x66_Formatter))]
-    public class JT808_0x0200_0x66 : JT808_0x0200_BodyBase
+    public class JT808_0x0200_0x66 : JT808_0x0200_BodyBase, IJT808MessagePackFormatter<JT808_0x0200_0x66>
     {
         public override byte AttachInfoId { get; set; } = 0x66;
         public override byte AttachInfoLength { get; set; }
@@ -62,5 +61,80 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
         /// 报警/事件信息列表
         /// </summary>
         public List<AlarmOrEventProperty> AlarmOrEvents { get; set; }
+
+        public JT808_0x0200_0x66 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+        {
+            JT808_0x0200_0x66 jT808_0X0200_0X66 = new JT808_0x0200_0x66();
+            jT808_0X0200_0X66.AttachInfoId = reader.ReadByte();
+            jT808_0X0200_0X66.AttachInfoLength = reader.ReadByte();
+            jT808_0X0200_0X66.AlarmId = reader.ReadUInt32();
+            jT808_0X0200_0X66.FlagState = reader.ReadByte();
+            jT808_0X0200_0X66.Speed = reader.ReadByte();
+            jT808_0X0200_0X66.Altitude = reader.ReadUInt16();
+            jT808_0X0200_0X66.Latitude = (int)reader.ReadUInt32();
+            jT808_0X0200_0X66.Longitude = (int)reader.ReadUInt32();
+            jT808_0X0200_0X66.AlarmTime = reader.ReadDateTime6();
+            jT808_0X0200_0X66.VehicleState = reader.ReadUInt16();
+            jT808_0X0200_0X66.AlarmIdentification = new AlarmIdentificationProperty
+            {
+                TerminalID = reader.ReadString(7),
+                Time = reader.ReadDateTime6(),
+                SN = reader.ReadByte(),
+                AttachCount = reader.ReadByte(),
+                Retain = reader.ReadByte()
+            };
+            jT808_0X0200_0X66.AlarmOrEventCount = reader.ReadByte();
+            if (jT808_0X0200_0X66.AlarmOrEventCount > 0)
+            {
+                jT808_0X0200_0X66.AlarmOrEvents = new List<AlarmOrEventProperty>();
+                for (int i = 0; i < jT808_0X0200_0X66.AlarmOrEventCount; i++)
+                {
+                    AlarmOrEventProperty alarmOrEventProperty = new AlarmOrEventProperty();
+                    alarmOrEventProperty.TirePressureAlarmPosition = reader.ReadByte();
+                    alarmOrEventProperty.AlarmOrEventType = reader.ReadUInt16();
+                    alarmOrEventProperty.TirePressure = reader.ReadUInt16();
+                    alarmOrEventProperty.TireTemperature = reader.ReadUInt16();
+                    alarmOrEventProperty.BatteryLevel = reader.ReadUInt16();
+                    jT808_0X0200_0X66.AlarmOrEvents.Add(alarmOrEventProperty);
+                }
+            }
+            return jT808_0X0200_0X66;
+        }
+
+        public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0200_0x66 value, IJT808Config config)
+        {
+            writer.WriteByte(value.AttachInfoId);
+            writer.Skip(1, out int AttachInfoLengthPosition);
+            writer.WriteUInt32(value.AlarmId);
+            writer.WriteByte(value.FlagState);
+            writer.WriteByte(value.Speed);
+            writer.WriteUInt16(value.Altitude);
+            writer.WriteUInt32((uint)value.Latitude);
+            writer.WriteUInt32((uint)value.Longitude);
+            writer.WriteDateTime6(value.AlarmTime);
+            writer.WriteUInt16(value.VehicleState);
+            if (value.AlarmIdentification == null)
+            {
+                throw new NullReferenceException($"{nameof(AlarmIdentificationProperty)}不为空");
+            }
+            writer.WriteString(value.AlarmIdentification.TerminalID);
+            writer.WriteDateTime6(value.AlarmIdentification.Time);
+            writer.WriteByte(value.AlarmIdentification.SN);
+            writer.WriteByte(value.AlarmIdentification.AttachCount);
+            writer.WriteByte(value.AlarmIdentification.Retain);
+            if (value.AlarmOrEvents.Count > 0)
+            {
+                writer.WriteByte((byte)value.AlarmOrEvents.Count);
+                foreach (var item in value.AlarmOrEvents)
+                {
+                    writer.WriteByte(item.TirePressureAlarmPosition);
+                    writer.WriteUInt16(item.AlarmOrEventType);
+                    writer.WriteUInt16(item.TirePressure);
+                    writer.WriteUInt16(item.TireTemperature);
+                    writer.WriteUInt16(item.BatteryLevel);
+                }
+            }
+            writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - AttachInfoLengthPosition - 1), AttachInfoLengthPosition);
+        }
     }
 }

src/JT808.Protocol.Extensions.JTActiveSafety/MessageBody/JT808_0x0200_0x67.cs

@@ -1,7 +1,7 @@
-using JT808.Protocol.Attributes;
-using JT808.Protocol.Extensions.JTActiveSafety.Formatters;
-using JT808.Protocol.Extensions.JTActiveSafety.Metadata;
+using JT808.Protocol.Extensions.JTActiveSafety.Metadata;
+using JT808.Protocol.Formatters;
 using JT808.Protocol.MessageBody;
+using JT808.Protocol.MessagePack;
 using System;
 using System.Collections.Generic;
 using System.Text;
@@ -11,8 +11,7 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
     /// <summary>
     /// 盲区监测系统报警信息
     /// </summary>
-    [JT808Formatter(typeof(JT808_0x0200_0x67_Formatter))]
-    public class JT808_0x0200_0x67 : JT808_0x0200_BodyBase
+    public class JT808_0x0200_0x67 : JT808_0x0200_BodyBase, IJT808MessagePackFormatter<JT808_0x0200_0x67>
     {
         public override byte AttachInfoId { get; set; } = 0x67;
         public override byte AttachInfoLength { get; set; } = 26;
@@ -62,5 +61,56 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
         /// 报警标识号
         /// </summary>
         public AlarmIdentificationProperty AlarmIdentification { get; set; }
+
+        public JT808_0x0200_0x67 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+        {
+            JT808_0x0200_0x67 jT808_0X0200_0X67 = new JT808_0x0200_0x67();
+            jT808_0X0200_0X67.AttachInfoId = reader.ReadByte();
+            jT808_0X0200_0X67.AttachInfoLength = reader.ReadByte();
+            jT808_0X0200_0X67.AlarmId = reader.ReadUInt32();
+            jT808_0X0200_0X67.FlagState = reader.ReadByte();
+            jT808_0X0200_0X67.AlarmOrEventType = reader.ReadByte();
+            jT808_0X0200_0X67.AlarmLevel = reader.ReadByte();
+            jT808_0X0200_0X67.Speed = reader.ReadByte();
+            jT808_0X0200_0X67.Altitude = reader.ReadUInt16();
+            jT808_0X0200_0X67.Latitude = (int)reader.ReadUInt32();
+            jT808_0X0200_0X67.Longitude = (int)reader.ReadUInt32();
+            jT808_0X0200_0X67.AlarmTime = reader.ReadDateTime6();
+            jT808_0X0200_0X67.VehicleState = reader.ReadUInt16();
+            jT808_0X0200_0X67.AlarmIdentification = new AlarmIdentificationProperty
+            {
+                TerminalID = reader.ReadString(7),
+                Time = reader.ReadDateTime6(),
+                SN = reader.ReadByte(),
+                AttachCount = reader.ReadByte(),
+                Retain = reader.ReadByte()
+            };
+            return jT808_0X0200_0X67;
+        }
+
+        public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0200_0x67 value, IJT808Config config)
+        {
+            writer.WriteByte(value.AttachInfoId);
+            writer.WriteByte(value.AttachInfoLength);
+            writer.WriteUInt32(value.AlarmId);
+            writer.WriteByte(value.FlagState);
+            writer.WriteByte(value.AlarmOrEventType);
+            writer.WriteByte(value.AlarmLevel);
+            writer.WriteByte(value.Speed);
+            writer.WriteUInt16(value.Altitude);
+            writer.WriteUInt32((uint)value.Latitude);
+            writer.WriteUInt32((uint)value.Longitude);
+            writer.WriteDateTime6(value.AlarmTime);
+            writer.WriteUInt16(value.VehicleState);
+            if (value.AlarmIdentification == null)
+            {
+                throw new NullReferenceException($"{nameof(AlarmIdentificationProperty)}不为空");
+            }
+            writer.WriteString(value.AlarmIdentification.TerminalID);
+            writer.WriteDateTime6(value.AlarmIdentification.Time);
+            writer.WriteByte(value.AlarmIdentification.SN);
+            writer.WriteByte(value.AlarmIdentification.AttachCount);
+            writer.WriteByte(value.AlarmIdentification.Retain);
+        }
     }
 }

src/JT808.Protocol.Extensions.JTActiveSafety/MessageBody/JT808_0x1210.cs

@@ -1,6 +1,6 @@
-using JT808.Protocol.Attributes;
-using JT808.Protocol.Extensions.JTActiveSafety.Formatters;
-using JT808.Protocol.Extensions.JTActiveSafety.Metadata;
+using JT808.Protocol.Extensions.JTActiveSafety.Metadata;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
 using System;
 using System.Collections.Generic;
 using System.Text;
@@ -10,8 +10,7 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
     /// <summary>
     /// 报警附件信息消息
     /// </summary>
-    [JT808Formatter(typeof(JT808_0x1210_Formatter))]
-    public class JT808_0x1210:JT808Bodies
+    public class JT808_0x1210:JT808Bodies, IJT808MessagePackFormatter<JT808_0x1210>
     {
         /// <summary>
         /// 终端ID
@@ -41,5 +40,68 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
         /// 附件信息列表
         /// </summary>
         public List<AttachProperty> AttachInfos { get; set; }
+
+        public override ushort MsgId => 0x1210;
+
+        public JT808_0x1210 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+        {
+            JT808_0x1210 jT808_0X1210 = new JT808_0x1210();
+            jT808_0X1210.TerminalID = reader.ReadString(7);
+            jT808_0X1210.AlarmIdentification = new AlarmIdentificationProperty
+            {
+                TerminalID = reader.ReadString(7),
+                Time = reader.ReadDateTime6(),
+                SN = reader.ReadByte(),
+                AttachCount = reader.ReadByte(),
+                Retain = reader.ReadByte()
+            };
+            jT808_0X1210.AlarmId = reader.ReadString(32);
+            jT808_0X1210.InfoType = reader.ReadByte();
+            jT808_0X1210.AttachCount = reader.ReadByte();
+            if (jT808_0X1210.AttachCount > 0)
+            {
+                jT808_0X1210.AttachInfos = new List<AttachProperty>();
+                for (int i = 0; i < jT808_0X1210.AttachCount; i++)
+                {
+                    AttachProperty attachProperty = new AttachProperty();
+                    attachProperty.FileNameLength = reader.ReadByte();
+                    attachProperty.FileName = reader.ReadString(attachProperty.FileNameLength);
+                    attachProperty.FileSize = reader.ReadUInt32();
+                    jT808_0X1210.AttachInfos.Add(attachProperty);
+                }
+            }
+            return jT808_0X1210;
+        }
+
+        public void Serialize(ref JT808MessagePackWriter writer, JT808_0x1210 value, IJT808Config config)
+        {
+            writer.WriteString(value.TerminalID.PadRight(7, '0'));
+            if (value.AlarmIdentification == null)
+            {
+                throw new NullReferenceException($"{nameof(AlarmIdentificationProperty)}不为空");
+            }
+            writer.WriteString(value.AlarmIdentification.TerminalID);
+            writer.WriteDateTime6(value.AlarmIdentification.Time);
+            writer.WriteByte(value.AlarmIdentification.SN);
+            writer.WriteByte(value.AlarmIdentification.AttachCount);
+            writer.WriteByte(value.AlarmIdentification.Retain);
+            writer.WriteString(value.AlarmId);
+            writer.WriteByte(value.InfoType);
+            if (value.AttachInfos != null && value.AttachInfos.Count > 0)
+            {
+                writer.WriteByte((byte)value.AttachInfos.Count);
+                foreach (var item in value.AttachInfos)
+                {
+                    writer.Skip(1, out int FileNameLengthPosition);
+                    writer.WriteString(item.FileName);
+                    writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - FileNameLengthPosition - 1), FileNameLengthPosition);
+                    writer.WriteUInt32(item.FileSize);
+                }
+            }
+            else
+            {
+                writer.WriteByte(0);
+            }
+        }
     }
 }

src/JT808.Protocol.Extensions.JTActiveSafety/MessageBody/JT808_0x1211.cs

@@ -1,16 +1,12 @@
-using JT808.Protocol.Attributes;
-using JT808.Protocol.Extensions.JTActiveSafety.Formatters;
-using System;
-using System.Collections.Generic;
-using System.Text;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
 
 namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
 {
     /// <summary>
     /// 文件信息上传
     /// </summary>
-    [JT808Formatter(typeof(JT808_0x1211_Formatter))]
-    public class JT808_0x1211 : JT808Bodies
+    public class JT808_0x1211 : JT808Bodies, IJT808MessagePackFormatter<JT808_0x1211>
     {
         /// <summary>
         /// 文件名称长度
@@ -29,5 +25,26 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
         /// 文件大小
         /// </summary>
         public uint FileSize { get; set; }
+
+        public override ushort MsgId => 0x1211;
+
+        public JT808_0x1211 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+        {
+            JT808_0x1211 jT808_0X1211 = new JT808_0x1211();
+            jT808_0X1211.FileNameLength = reader.ReadByte();
+            jT808_0X1211.FileName = reader.ReadString(jT808_0X1211.FileNameLength);
+            jT808_0X1211.FileType = reader.ReadByte();
+            jT808_0X1211.FileSize = reader.ReadUInt32();
+            return jT808_0X1211;
+        }
+
+        public void Serialize(ref JT808MessagePackWriter writer, JT808_0x1211 value, IJT808Config config)
+        {
+            writer.Skip(1, out int FileNameLengthPosition);
+            writer.WriteString(value.FileName);
+            writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - FileNameLengthPosition - 1), FileNameLengthPosition);
+            writer.WriteByte(value.FileType);
+            writer.WriteUInt32(value.FileSize);
+        }
     }
 }

src/JT808.Protocol.Extensions.JTActiveSafety/MessageBody/JT808_0x1212.cs

@@ -1,16 +1,12 @@
-using JT808.Protocol.Attributes;
-using JT808.Protocol.Extensions.JTActiveSafety.Formatters;
-using System;
-using System.Collections.Generic;
-using System.Text;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
 
 namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
 {
     /// <summary>
     /// 文件上传完成消息
     /// </summary>
-    [JT808Formatter(typeof(JT808_0x1212_Formatter))]
-    public class JT808_0x1212 : JT808Bodies
+    public class JT808_0x1212 : JT808Bodies, IJT808MessagePackFormatter<JT808_0x1212>
     {
         /// <summary>
         /// 文件名称长度
@@ -29,5 +25,25 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
         /// 文件大小
         /// </summary>
         public uint FileSize { get; set; }
+        public override ushort MsgId => 0x1212;
+
+        public JT808_0x1212 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+        {
+            JT808_0x1212 jT808_0X1212 = new JT808_0x1212();
+            jT808_0X1212.FileNameLength = reader.ReadByte();
+            jT808_0X1212.FileName = reader.ReadString(jT808_0X1212.FileNameLength);
+            jT808_0X1212.FileType = reader.ReadByte();
+            jT808_0X1212.FileSize = reader.ReadUInt32();
+            return jT808_0X1212;
+        }
+
+        public void Serialize(ref JT808MessagePackWriter writer, JT808_0x1212 value, IJT808Config config)
+        {
+            writer.Skip(1, out int FileNameLengthPosition);
+            writer.WriteString(value.FileName);
+            writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - FileNameLengthPosition - 1), FileNameLengthPosition);
+            writer.WriteByte(value.FileType);
+            writer.WriteUInt32(value.FileSize);
+        }
     }
 }

src/JT808.Protocol.Extensions.JTActiveSafety/MessageBody/JT808_0x8103_0xF364.cs

@@ -1,17 +1,13 @@
-using JT808.Protocol.Attributes;
-using JT808.Protocol.Extensions.JTActiveSafety.Formatters;
+using JT808.Protocol.Formatters;
 using JT808.Protocol.MessageBody;
-using System;
-using System.Collections.Generic;
-using System.Text;
+using JT808.Protocol.MessagePack;
 
 namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
 {
     /// <summary>
     /// 高级驾驶辅助系统参数
     /// </summary>
-    [JT808Formatter(typeof(JT808_0x8103_0xF364_Formatter))]
-    public class JT808_0x8103_0xF364 : JT808_0x8103_BodyBase
+    public class JT808_0x8103_0xF364 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter<JT808_0x8103_0xF364>
     {
         public override uint ParamId { get; set; } = 0xF364;
         public override byte ParamLength { get; set; }
@@ -196,5 +192,110 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
         /// 保留字段
         /// </summary>
         public byte[] Placeholder2 { get; set; } = new byte[4];
+
+        public JT808_0x8103_0xF364 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+        {
+            JT808_0x8103_0xF364 jT808_0X8103_0XF364 = new JT808_0x8103_0xF364();
+            jT808_0X8103_0XF364.ParamId = reader.ReadUInt32();
+            jT808_0X8103_0XF364.ParamLength = reader.ReadByte();
+            jT808_0X8103_0XF364.AlarmJudgeSpeedThreshold = reader.ReadByte();
+            jT808_0X8103_0XF364.WarningVolume = reader.ReadByte();
+            jT808_0X8103_0XF364.ActivePhotographyStrategy = reader.ReadByte();
+            jT808_0X8103_0XF364.ActivelyTimePhotoInterval = reader.ReadUInt16();
+            jT808_0X8103_0XF364.ActiveDistancePhotographyDistanceInterval = reader.ReadUInt16();
+            jT808_0X8103_0XF364.SingleInitiativePhotos = reader.ReadByte();
+            jT808_0X8103_0XF364.SingleInitiativePhotosInterval = reader.ReadByte();
+            jT808_0X8103_0XF364.PhotoResolution = reader.ReadByte();
+            jT808_0X8103_0XF364.VideoRecordingResolution = reader.ReadByte();
+            jT808_0X8103_0XF364.AlarmEnable = reader.ReadUInt32();
+            jT808_0X8103_0XF364.EventEnable = reader.ReadUInt32();
+            jT808_0X8103_0XF364.Placeholder1 = reader.ReadByte();
+            jT808_0X8103_0XF364.DistanceThresholdObstacleAlarm = reader.ReadByte();
+            jT808_0X8103_0XF364.HierarchicalSpeedThresholdObstacleAlarm = reader.ReadByte();
+            jT808_0X8103_0XF364.VideoRecordingTimeBeforeAndAfterObstacleAlarm = reader.ReadByte();
+            jT808_0X8103_0XF364.BarrierAlarmPhotographs = reader.ReadByte();
+            jT808_0X8103_0XF364.ObstacleAlarmInterval = reader.ReadByte();
+            jT808_0X8103_0XF364.FrequentChannelChangeAlarmJudgmentTimePeriod = reader.ReadByte();
+            jT808_0X8103_0XF364.FrequentAlarmJudgmentNumberChannelChange = reader.ReadByte();
+            jT808_0X8103_0XF364.HierarchicalSpeedThresholdFrequentChannelChangeAlarm = reader.ReadByte();
+            jT808_0X8103_0XF364.VideoRecordingTimeBeforeAndAfterFrequentLaneChangeAlarm = reader.ReadByte();
+            jT808_0X8103_0XF364.FrequentChannelChangeAlarmPhotos = reader.ReadByte();
+            jT808_0X8103_0XF364.FrequentLaneChangeAlarmInterval = reader.ReadByte();
+            jT808_0X8103_0XF364.GradedSpeedThresholdLaneDeviationAlarm = reader.ReadByte();
+            jT808_0X8103_0XF364.VideoRecordingTimeBeforeAndAfterLaneDepartureAlarm = reader.ReadByte();
+            jT808_0X8103_0XF364.LaneDepartureAlarmPhoto = reader.ReadByte();
+            jT808_0X8103_0XF364.LaneDepartureAlarmPhotoInterval = reader.ReadByte();
+            jT808_0X8103_0XF364.ForwardCollisionWarningTimeThreshold = reader.ReadByte();
+            jT808_0X8103_0XF364.HierarchicalSpeedThresholdForwardCollisionWarning = reader.ReadByte();
+            jT808_0X8103_0XF364.VideoRecordingTimeBeforeAndAfterForwardCollisionAlarm = reader.ReadByte();
+            jT808_0X8103_0XF364.ForwardCollisionAlarmPhotographs = reader.ReadByte();
+            jT808_0X8103_0XF364.ForwardCollisionAlarmInterval = reader.ReadByte();
+            jT808_0X8103_0XF364.PedestrianCollisionAlarmTimeThreshold = reader.ReadByte();
+            jT808_0X8103_0XF364.PedestrianCollisionAlarmEnablingSpeedThreshold = reader.ReadByte();
+            jT808_0X8103_0XF364.VideoRecordingTimeBeforeAndAfterPedestrianCollisionAlarm = reader.ReadByte();
+            jT808_0X8103_0XF364.PedestrianCollisionAlarmPhotos = reader.ReadByte();
+            jT808_0X8103_0XF364.PedestrianCollisionAlarmInterval = reader.ReadByte();
+            jT808_0X8103_0XF364.VehicleDistanceMonitoringAlarmDistanceThreshold = reader.ReadByte();
+            jT808_0X8103_0XF364.VehicleDistanceMonitoringAndAlarmClassificationSpeedThreshold = reader.ReadByte();
+            jT808_0X8103_0XF364.VideoRecordingTimeBeforeAndAfterAlarmVehicleProximity = reader.ReadByte();
+            jT808_0X8103_0XF364.AlarmPhotoVehicleCloseDistance = reader.ReadByte();
+            jT808_0X8103_0XF364.AlarmPhotoVehicleCloseDistanceInterval = reader.ReadByte();
+            jT808_0X8103_0XF364.RoadSignRecognitionPhotographs = reader.ReadByte();
+            jT808_0X8103_0XF364.RoadSignRecognitionPhotographsInterval = reader.ReadByte();
+            jT808_0X8103_0XF364.Placeholder2 = reader.ReadArray(4).ToArray();
+            return jT808_0X8103_0XF364;
+        }
+
+        public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0xF364 value, IJT808Config config)
+        {
+            writer.WriteUInt32(value.ParamId);
+            writer.Skip(1, out int ParamLengthPosition);
+            writer.WriteByte(value.AlarmJudgeSpeedThreshold);
+            writer.WriteByte(value.WarningVolume);
+            writer.WriteByte(value.ActivePhotographyStrategy);
+            writer.WriteUInt16(value.ActivelyTimePhotoInterval);
+            writer.WriteUInt16(value.ActiveDistancePhotographyDistanceInterval);
+            writer.WriteByte(value.SingleInitiativePhotos);
+            writer.WriteByte(value.SingleInitiativePhotosInterval);
+            writer.WriteByte(value.PhotoResolution);
+            writer.WriteByte(value.VideoRecordingResolution);
+            writer.WriteUInt32(value.AlarmEnable);
+            writer.WriteUInt32(value.EventEnable);
+            writer.WriteByte(value.Placeholder1);
+            writer.WriteByte(value.DistanceThresholdObstacleAlarm);
+            writer.WriteByte(value.HierarchicalSpeedThresholdObstacleAlarm);
+            writer.WriteByte(value.VideoRecordingTimeBeforeAndAfterObstacleAlarm);
+            writer.WriteByte(value.BarrierAlarmPhotographs);
+            writer.WriteByte(value.ObstacleAlarmInterval);
+            writer.WriteByte(value.FrequentChannelChangeAlarmJudgmentTimePeriod);
+            writer.WriteByte(value.FrequentAlarmJudgmentNumberChannelChange);
+            writer.WriteByte(value.HierarchicalSpeedThresholdFrequentChannelChangeAlarm);
+            writer.WriteByte(value.VideoRecordingTimeBeforeAndAfterFrequentLaneChangeAlarm);
+            writer.WriteByte(value.FrequentChannelChangeAlarmPhotos);
+            writer.WriteByte(value.FrequentLaneChangeAlarmInterval);
+            writer.WriteByte(value.GradedSpeedThresholdLaneDeviationAlarm);
+            writer.WriteByte(value.VideoRecordingTimeBeforeAndAfterLaneDepartureAlarm);
+            writer.WriteByte(value.LaneDepartureAlarmPhoto);
+            writer.WriteByte(value.LaneDepartureAlarmPhotoInterval);
+            writer.WriteByte(value.ForwardCollisionWarningTimeThreshold);
+            writer.WriteByte(value.HierarchicalSpeedThresholdForwardCollisionWarning);
+            writer.WriteByte(value.VideoRecordingTimeBeforeAndAfterForwardCollisionAlarm);
+            writer.WriteByte(value.ForwardCollisionAlarmPhotographs);
+            writer.WriteByte(value.ForwardCollisionAlarmInterval);
+            writer.WriteByte(value.PedestrianCollisionAlarmTimeThreshold);
+            writer.WriteByte(value.PedestrianCollisionAlarmEnablingSpeedThreshold);
+            writer.WriteByte(value.VideoRecordingTimeBeforeAndAfterPedestrianCollisionAlarm);
+            writer.WriteByte(value.PedestrianCollisionAlarmPhotos);
+            writer.WriteByte(value.PedestrianCollisionAlarmInterval);
+            writer.WriteByte(value.VehicleDistanceMonitoringAlarmDistanceThreshold);
+            writer.WriteByte(value.VehicleDistanceMonitoringAndAlarmClassificationSpeedThreshold);
+            writer.WriteByte(value.VideoRecordingTimeBeforeAndAfterAlarmVehicleProximity);
+            writer.WriteByte(value.AlarmPhotoVehicleCloseDistance);
+            writer.WriteByte(value.AlarmPhotoVehicleCloseDistanceInterval);
+            writer.WriteByte(value.RoadSignRecognitionPhotographs);
+            writer.WriteByte(value.RoadSignRecognitionPhotographsInterval);
+            writer.WriteArray(value.Placeholder2);
+            writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - ParamLengthPosition - 1), ParamLengthPosition);
+        }
     }
 }

src/JT808.Protocol.Extensions.JTActiveSafety/MessageBody/JT808_0x8103_0xF365.cs

@@ -1,17 +1,13 @@
-using JT808.Protocol.Attributes;
-using JT808.Protocol.Extensions.JTActiveSafety.Formatters;
+using JT808.Protocol.Formatters;
 using JT808.Protocol.MessageBody;
-using System;
-using System.Collections.Generic;
-using System.Text;
+using JT808.Protocol.MessagePack;
 
 namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
 {
     /// <summary>
     /// 驾驶员状态监测系统参数
     /// </summary>
-    [JT808Formatter(typeof(JT808_0x8103_0xF365_Formatter))]
-    public class JT808_0x8103_0xF365 : JT808_0x8103_BodyBase
+    public class JT808_0x8103_0xF365 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter<JT808_0x8103_0xF365>
     {
         public override uint ParamId { get; set; } = 0xF365;
         public override byte ParamLength { get; set; }
@@ -151,5 +147,88 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
         /// 保留字段
         /// </summary>
         public byte[] Retain { get; set; } = new byte[2];
+
+        public JT808_0x8103_0xF365 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+        {
+            JT808_0x8103_0xF365 jT808_0X8103_0XF365 = new JT808_0x8103_0xF365();
+            jT808_0X8103_0XF365.ParamId = reader.ReadUInt32();
+            jT808_0X8103_0XF365.ParamLength = reader.ReadByte();
+            jT808_0X8103_0XF365.AlarmJudgeSpeedThreshold = reader.ReadByte();
+            jT808_0X8103_0XF365.WarningVolume = reader.ReadByte();
+            jT808_0X8103_0XF365.ActivePhotographyStrategy = reader.ReadByte();
+            jT808_0X8103_0XF365.ActivelyTimePhotoInterval = reader.ReadUInt16();
+            jT808_0X8103_0XF365.ActiveDistancePhotographyDistanceInterval = reader.ReadUInt16();
+            jT808_0X8103_0XF365.SingleInitiativePhotos = reader.ReadByte();
+            jT808_0X8103_0XF365.SingleInitiativePhotosInterval = reader.ReadByte();
+            jT808_0X8103_0XF365.PhotoResolution = reader.ReadByte();
+            jT808_0X8103_0XF365.VideoRecordingResolution = reader.ReadByte();
+            jT808_0X8103_0XF365.AlarmEnable = reader.ReadUInt32();
+            jT808_0X8103_0XF365.EventEnable = reader.ReadUInt32();
+            jT808_0X8103_0XF365.TimeIntervalSmokingAlarmJudgment = reader.ReadUInt16();
+            jT808_0X8103_0XF365.CallAlarmDetermineTimeInterval = reader.ReadUInt16();
+            jT808_0X8103_0XF365.Reserve = reader.ReadArray(3).ToArray();
+            jT808_0X8103_0XF365.GradedSpeedThresholdFatigueDrivingAlarm = reader.ReadByte();
+            jT808_0X8103_0XF365.VideoRecordingTimeBeforeAndAfterFatigueDrivingAlarm = reader.ReadByte();
+            jT808_0X8103_0XF365.FatigueDrivingAlarmPhotograph = reader.ReadByte();
+            jT808_0X8103_0XF365.FatigueDrivingAlarmPhotographInterval = reader.ReadByte();
+            jT808_0X8103_0XF365.ClassifiedSpeedThresholdCallAlarm = reader.ReadByte();
+            jT808_0X8103_0XF365.VideoRecordingTimeBeforeAndAfterCallAlarm = reader.ReadByte();
+            jT808_0X8103_0XF365.CallAlarmTakePicturesDriverFacialFeatures = reader.ReadByte();
+            jT808_0X8103_0XF365.CallAlarmTakePicturesDriverFacialFeaturesInterval = reader.ReadByte();
+            jT808_0X8103_0XF365.ClassifiedSpeedThresholdSmokingAlarm = reader.ReadByte();
+            jT808_0X8103_0XF365.VideoRecordingTimeBeforeAndAfterSmokingAlarm = reader.ReadByte();
+            jT808_0X8103_0XF365.SmokingAlarmPhotographsDriverFaceCharacteristics = reader.ReadByte();
+            jT808_0X8103_0XF365.SmokingAlarmPhotographsDriverFaceCharacteristicsInterval = reader.ReadByte();
+            jT808_0X8103_0XF365.ClassifiedSpeedThresholdDistractedDrivingAlarm = reader.ReadByte();
+            jT808_0X8103_0XF365.DistractedDrivingAlarmPhotography = reader.ReadByte();
+            jT808_0X8103_0XF365.DistractedDrivingAlarmPhotographyInterval = reader.ReadByte();
+            jT808_0X8103_0XF365.VideoRecordingTimeAbnormalDrivingBehavior = reader.ReadByte();
+            jT808_0X8103_0XF365.PhotographsAbnormalDrivingBehavior = reader.ReadByte();
+            jT808_0X8103_0XF365.PictureIntervalAbnormalDrivingBehavior = reader.ReadByte();
+            jT808_0X8103_0XF365.DriverIdentificationTrigger = reader.ReadByte();
+            jT808_0X8103_0XF365.Retain = reader.ReadArray(reader.ReadCurrentRemainContentLength()).ToArray();
+            return jT808_0X8103_0XF365;
+        }
+
+        public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0xF365 value, IJT808Config config)
+        {
+            writer.WriteUInt32(value.ParamId);
+            writer.Skip(1, out int ParamLengthPosition);
+            writer.WriteByte(value.AlarmJudgeSpeedThreshold);
+            writer.WriteByte(value.WarningVolume);
+            writer.WriteByte(value.ActivePhotographyStrategy);
+            writer.WriteUInt16(value.ActivelyTimePhotoInterval);
+            writer.WriteUInt16(value.ActiveDistancePhotographyDistanceInterval);
+            writer.WriteByte(value.SingleInitiativePhotos);
+            writer.WriteByte(value.SingleInitiativePhotosInterval);
+            writer.WriteByte(value.PhotoResolution);
+            writer.WriteByte(value.VideoRecordingResolution);
+            writer.WriteUInt32(value.AlarmEnable);
+            writer.WriteUInt32(value.EventEnable);
+            writer.WriteUInt16(value.TimeIntervalSmokingAlarmJudgment);
+            writer.WriteUInt16(value.CallAlarmDetermineTimeInterval);
+            writer.WriteArray(value.Reserve);
+            writer.WriteByte(value.GradedSpeedThresholdFatigueDrivingAlarm);
+            writer.WriteByte(value.VideoRecordingTimeBeforeAndAfterFatigueDrivingAlarm);
+            writer.WriteByte(value.FatigueDrivingAlarmPhotograph);
+            writer.WriteByte(value.FatigueDrivingAlarmPhotographInterval);
+            writer.WriteByte(value.ClassifiedSpeedThresholdCallAlarm);
+            writer.WriteByte(value.VideoRecordingTimeBeforeAndAfterCallAlarm);
+            writer.WriteByte(value.CallAlarmTakePicturesDriverFacialFeatures);
+            writer.WriteByte(value.CallAlarmTakePicturesDriverFacialFeaturesInterval);
+            writer.WriteByte(value.ClassifiedSpeedThresholdSmokingAlarm);
+            writer.WriteByte(value.VideoRecordingTimeBeforeAndAfterSmokingAlarm);
+            writer.WriteByte(value.SmokingAlarmPhotographsDriverFaceCharacteristics);
+            writer.WriteByte(value.SmokingAlarmPhotographsDriverFaceCharacteristicsInterval);
+            writer.WriteByte(value.ClassifiedSpeedThresholdDistractedDrivingAlarm);
+            writer.WriteByte(value.DistractedDrivingAlarmPhotography);
+            writer.WriteByte(value.DistractedDrivingAlarmPhotographyInterval);
+            writer.WriteByte(value.VideoRecordingTimeAbnormalDrivingBehavior);
+            writer.WriteByte(value.PhotographsAbnormalDrivingBehavior);
+            writer.WriteByte(value.PictureIntervalAbnormalDrivingBehavior);
+            writer.WriteByte(value.DriverIdentificationTrigger);
+            writer.WriteArray(value.Retain);
+            writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - ParamLengthPosition - 1), ParamLengthPosition);
+        }
     }
 }

src/JT808.Protocol.Extensions.JTActiveSafety/MessageBody/JT808_0x8103_0xF366.cs

@@ -1,22 +1,18 @@
-using JT808.Protocol.Attributes;
-using JT808.Protocol.Extensions.JTActiveSafety.Formatters;
+using JT808.Protocol.Formatters;
 using JT808.Protocol.MessageBody;
-using System;
-using System.Collections.Generic;
-using System.Text;
+using JT808.Protocol.MessagePack;
 
 namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
 {
     /// <summary>
     /// 胎压监测系统参数
     /// </summary>
-    [JT808Formatter(typeof(JT808_0x8103_0xF366_Formatter))]
-    public class JT808_0x8103_0xF366 : JT808_0x8103_BodyBase
+    public class JT808_0x8103_0xF366 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter<JT808_0x8103_0xF366>
     {
         public override uint ParamId { get; set; } = 0xF366;
         public override byte ParamLength { get; set; } = 46;
         /// <summary>
-        /// 轮胎规格型号
+        /// 轮胎规格型号 12位
         /// </summary>
         public string TyreSpecificationType { get; set; }
         /// <summary>
@@ -59,5 +55,42 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
         /// 保留项
         /// </summary>
         public byte[] Retain { get; set; } = new byte[6];
+
+        public JT808_0x8103_0xF366 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+        {
+            JT808_0x8103_0xF366 jT808_0X8103_0XF366 = new JT808_0x8103_0xF366();
+            jT808_0X8103_0XF366.ParamId = reader.ReadUInt32();
+            jT808_0X8103_0XF366.ParamLength = reader.ReadByte();
+            jT808_0X8103_0XF366.TyreSpecificationType = reader.ReadString(12);
+            jT808_0X8103_0XF366.TyrePressureUnit = reader.ReadUInt16();
+            jT808_0X8103_0XF366.NormalFetalPressure = reader.ReadUInt16();
+            jT808_0X8103_0XF366.ThresholdUnbalancedTirePressure = reader.ReadUInt16();
+            jT808_0X8103_0XF366.SlowLeakageThreshold = reader.ReadUInt16();
+            jT808_0X8103_0XF366.LowVoltageThreshold = reader.ReadUInt16();
+            jT808_0X8103_0XF366.HighVoltageThreshold = reader.ReadUInt16();
+            jT808_0X8103_0XF366.HighTemperatureThreshold = reader.ReadUInt16();
+            jT808_0X8103_0XF366.VoltageThreshold = reader.ReadUInt16();
+            jT808_0X8103_0XF366.TimedReportingInterval = reader.ReadUInt16();
+            jT808_0X8103_0XF366.Retain = reader.ReadArray(reader.ReadCurrentRemainContentLength()).ToArray();
+            return jT808_0X8103_0XF366;
+        }
+
+        public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0xF366 value, IJT808Config config)
+        {
+            writer.WriteUInt32(value.ParamId);
+            writer.Skip(1, out int ParamLengthPosition);
+            writer.WriteString(value.TyreSpecificationType);
+            writer.WriteUInt16(value.TyrePressureUnit);
+            writer.WriteUInt16(value.NormalFetalPressure);
+            writer.WriteUInt16(value.ThresholdUnbalancedTirePressure);
+            writer.WriteUInt16(value.SlowLeakageThreshold);
+            writer.WriteUInt16(value.LowVoltageThreshold);
+            writer.WriteUInt16(value.HighVoltageThreshold);
+            writer.WriteUInt16(value.HighTemperatureThreshold);
+            writer.WriteUInt16(value.VoltageThreshold);
+            writer.WriteUInt16(value.TimedReportingInterval);
+            writer.WriteArray(value.Retain);
+            writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - ParamLengthPosition - 1), ParamLengthPosition);
+        }
     }
 }

src/JT808.Protocol.Extensions.JTActiveSafety/MessageBody/JT808_0x8103_0xF367.cs

@@ -1,17 +1,13 @@
-using JT808.Protocol.Attributes;
-using JT808.Protocol.Extensions.JTActiveSafety.Formatters;
+using JT808.Protocol.Formatters;
 using JT808.Protocol.MessageBody;
-using System;
-using System.Collections.Generic;
-using System.Text;
+using JT808.Protocol.MessagePack;
 
 namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
 {
     /// <summary>
     /// 盲区监测系统参数
     /// </summary>
-    [JT808Formatter(typeof(JT808_0x8103_0xF367_Formatter))]
-    public class JT808_0x8103_0xF367 : JT808_0x8103_BodyBase
+    public class JT808_0x8103_0xF367 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter<JT808_0x8103_0xF367>
     {
         public override uint ParamId { get; set; } = 0xF367;
         public override byte ParamLength { get; set; } = 2;
@@ -23,5 +19,23 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
         /// 侧后方接近报警时间阈值
         /// </summary>
         public byte LateralRearApproachAlarmTimeThreshold { get; set; }
+
+        public JT808_0x8103_0xF367 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+        {
+            JT808_0x8103_0xF367 jT808_0X8103_0XF367 = new JT808_0x8103_0xF367();
+            jT808_0X8103_0XF367.ParamId = reader.ReadUInt32();
+            jT808_0X8103_0XF367.ParamLength = reader.ReadByte();
+            jT808_0X8103_0XF367.RearApproachAlarmTimeThreshold = reader.ReadByte();
+            jT808_0X8103_0XF367.LateralRearApproachAlarmTimeThreshold = reader.ReadByte();
+            return jT808_0X8103_0XF367;
+        }
+
+        public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0xF367 value, IJT808Config config)
+        {
+            writer.WriteUInt32(value.ParamId);
+            writer.WriteByte(2);
+            writer.WriteByte(value.RearApproachAlarmTimeThreshold);
+            writer.WriteByte(value.LateralRearApproachAlarmTimeThreshold);
+        }
     }
 }

src/JT808.Protocol.Extensions.JTActiveSafety/MessageBody/JT808_0x9208.cs

@@ -1,17 +1,14 @@
-using JT808.Protocol.Attributes;
-using JT808.Protocol.Extensions.JTActiveSafety.Formatters;
-using JT808.Protocol.Extensions.JTActiveSafety.Metadata;
+using JT808.Protocol.Extensions.JTActiveSafety.Metadata;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
 using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
 {
     /// <summary>
     /// 报警附件上传指令
     /// </summary>
-    [JT808Formatter(typeof(JT808_0x9208_Formatter))]
-    public class JT808_0x9208:JT808Bodies
+    public class JT808_0x9208:JT808Bodies, IJT808MessagePackFormatter<JT808_0x9208>
     {
         public byte AttachmentServerIPLength { get; set; }
         public string AttachmentServerIP { get; set; }
@@ -30,5 +27,47 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
         /// 预留
         /// </summary>
         public byte[] Retain { get; set; } = new byte[16];
+
+        public override ushort MsgId => 0x9208;
+
+        public JT808_0x9208 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+        {
+            JT808_0x9208 jT808_0X9208 = new JT808_0x9208();
+            jT808_0X9208.AttachmentServerIPLength = reader.ReadByte();
+            jT808_0X9208.AttachmentServerIP = reader.ReadString(jT808_0X9208.AttachmentServerIPLength);
+            jT808_0X9208.AttachmentServerIPTcpPort = reader.ReadUInt16();
+            jT808_0X9208.AttachmentServerIPUdpPort = reader.ReadUInt16();
+            jT808_0X9208.AlarmIdentification = new AlarmIdentificationProperty
+            {
+                TerminalID = reader.ReadString(7),
+                Time = reader.ReadDateTime6(),
+                SN = reader.ReadByte(),
+                AttachCount = reader.ReadByte(),
+                Retain = reader.ReadByte()
+            };
+            jT808_0X9208.AlarmId = reader.ReadString(32);
+            jT808_0X9208.Retain = reader.ReadArray(16).ToArray();
+            return jT808_0X9208;
+        }
+
+        public void Serialize(ref JT808MessagePackWriter writer, JT808_0x9208 value, IJT808Config config)
+        {
+            writer.Skip(1, out int AttachmentServerIPLengthPosition);
+            writer.WriteString(value.AttachmentServerIP);
+            writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - AttachmentServerIPLengthPosition - 1), AttachmentServerIPLengthPosition);
+            writer.WriteUInt16(value.AttachmentServerIPTcpPort);
+            writer.WriteUInt16(value.AttachmentServerIPUdpPort);
+            if (value.AlarmIdentification == null)
+            {
+                throw new NullReferenceException($"{nameof(AlarmIdentificationProperty)}不为空");
+            }
+            writer.WriteString(value.AlarmIdentification.TerminalID);
+            writer.WriteDateTime6(value.AlarmIdentification.Time);
+            writer.WriteByte(value.AlarmIdentification.SN);
+            writer.WriteByte(value.AlarmIdentification.AttachCount);
+            writer.WriteByte(value.AlarmIdentification.Retain);
+            writer.WriteString(value.AlarmId);
+            writer.WriteArray(value.Retain);
+        }
     }
 }

src/JT808.Protocol.Extensions.JTActiveSafety/MessageBody/JT808_0x9212.cs

@@ -1,17 +1,14 @@
-using JT808.Protocol.Attributes;
-using JT808.Protocol.Extensions.JTActiveSafety.Formatters;
-using JT808.Protocol.Extensions.JTActiveSafety.Metadata;
-using System;
+using JT808.Protocol.Extensions.JTActiveSafety.Metadata;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
 using System.Collections.Generic;
-using System.Text;
 
 namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
 {
     /// <summary>
     /// 文件上传完成消息应答
     /// </summary>
-    [JT808Formatter(typeof(JT808_0x9212_Formatter))]
-    public class JT808_0x9212:JT808Bodies
+    public class JT808_0x9212:JT808Bodies, IJT808MessagePackFormatter<JT808_0x9212>
     {
         /// <summary>
         /// 文件名称长度
@@ -38,5 +35,51 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
         /// 补传数据包列表
         /// </summary>
         public List<DataPackageProperty> DataPackages { get; set; }
+
+        public override ushort MsgId => 0x9212;
+
+        public JT808_0x9212 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+        {
+            JT808_0x9212 jT808_0X9212 = new JT808_0x9212();
+            jT808_0X9212.FileNameLength = reader.ReadByte();
+            jT808_0X9212.FileName = reader.ReadString(jT808_0X9212.FileNameLength);
+            jT808_0X9212.FileType = reader.ReadByte();
+            jT808_0X9212.UploadResult = reader.ReadByte();
+            jT808_0X9212.DataPackageCount = reader.ReadByte();
+            if (jT808_0X9212.DataPackageCount > 0)
+            {
+                jT808_0X9212.DataPackages = new List<DataPackageProperty>();
+                for (int i = 0; i < jT808_0X9212.DataPackageCount; i++)
+                {
+                    DataPackageProperty dataPackageProperty = new DataPackageProperty();
+                    dataPackageProperty.Offset = reader.ReadUInt32();
+                    dataPackageProperty.Length = reader.ReadUInt32();
+                    jT808_0X9212.DataPackages.Add(dataPackageProperty);
+                }
+            }
+            return jT808_0X9212;
+        }
+
+        public void Serialize(ref JT808MessagePackWriter writer, JT808_0x9212 value, IJT808Config config)
+        {
+            writer.Skip(1, out int FileNameLengthPosition);
+            writer.WriteString(value.FileName);
+            writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - FileNameLengthPosition - 1), FileNameLengthPosition);
+            writer.WriteByte(value.FileType);
+            writer.WriteByte(value.UploadResult);
+            if (value.DataPackages != null && value.DataPackages.Count > 0)
+            {
+                writer.WriteByte((byte)value.DataPackages.Count);
+                foreach (var item in value.DataPackages)
+                {
+                    writer.WriteUInt32(item.Offset);
+                    writer.WriteUInt32(item.Length);
+                }
+            }
+            else
+            {
+                writer.WriteByte(0);
+            }
+        }
     }
 }

src/JT808.Protocol.Extensions.JTActiveSafety/MessageBody/JT808_JTActiveSafety_0x0900.cs

@@ -1,17 +1,14 @@
-using JT808.Protocol.Attributes;
-using JT808.Protocol.Extensions.JTActiveSafety.Formatters;
+using JT808.Protocol.Formatters;
 using JT808.Protocol.MessageBody;
-using System;
+using JT808.Protocol.MessagePack;
 using System.Collections.Generic;
-using System.Text;
 
 namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
 {
     /// <summary>
     /// 上传基本信息
     /// </summary>
-    [JT808Formatter(typeof(JT808_JTActiveSafety_0x0900_Formatter))]
-    public class JT808_JTActiveSafety_0x0900 : JT808_0x0900_BodyBase
+    public class JT808_JTActiveSafety_0x0900 : JT808_0x0900_BodyBase, IJT808MessagePackFormatter<JT808_JTActiveSafety_0x0900>
     {
         /// <summary>
         /// 消息列表总数
@@ -19,5 +16,48 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
         public byte USBMessageCount { get; set; }
 
         public List<JT808_JTActiveSafety_0x0900_USBMessage> USBMessages { get; set; }
+
+        public JT808_JTActiveSafety_0x0900 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+        {
+            JT808_JTActiveSafety_0x0900 jT808_JTActiveSafety_0X0900 = new JT808_JTActiveSafety_0x0900();
+            jT808_JTActiveSafety_0X0900.USBMessageCount = reader.ReadByte();
+            if (jT808_JTActiveSafety_0X0900.USBMessageCount > 0)
+            {
+                jT808_JTActiveSafety_0X0900.USBMessages = new List<JT808_JTActiveSafety_0x0900_USBMessage>();
+                for (int i = 0; i < jT808_JTActiveSafety_0X0900.USBMessageCount; i++)
+                {
+                    JT808_JTActiveSafety_0x0900_USBMessage jT808_JTActiveSafety_0X0900_USBMessage = new JT808_JTActiveSafety_0x0900_USBMessage();
+                    jT808_JTActiveSafety_0X0900_USBMessage.USBID = reader.ReadByte();
+                    jT808_JTActiveSafety_0X0900_USBMessage.MessageLength = reader.ReadByte();
+                    jT808_JTActiveSafety_0X0900_USBMessage.MessageContent = reader.ReadArray(jT808_JTActiveSafety_0X0900_USBMessage.MessageLength).ToArray();
+                    jT808_JTActiveSafety_0X0900.USBMessages.Add(jT808_JTActiveSafety_0X0900_USBMessage);
+                }
+            }
+            return jT808_JTActiveSafety_0X0900;
+        }
+
+        public void Serialize(ref JT808MessagePackWriter writer, JT808_JTActiveSafety_0x0900 value, IJT808Config config)
+        {
+            if (value.USBMessages != null && value.USBMessages.Count > 0)
+            {
+                writer.WriteByte((byte)value.USBMessages.Count);
+                foreach (var item in value.USBMessages)
+                {
+                    writer.WriteByte(item.USBID);
+                    if (item.MessageContent != null && item.MessageContent.Length > 0)
+                    {
+                        writer.WriteByte((byte)item.MessageContent.Length);
+                        writer.WriteArray(item.MessageContent);
+                    }
+                    else if (item.MessageContentObejct != null)
+                    {
+                        writer.Skip(1, out int MessageContentLengthPosition);
+                        object obj = config.GetMessagePackFormatterByType(item.MessageContentObejct.GetType());
+                        JT808MessagePackFormatterResolverExtensions.JT808DynamicSerialize(obj, ref writer, item.MessageContentObejct, config);
+                        writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - MessageContentLengthPosition - 1), MessageContentLengthPosition);
+                    }
+                }
+            }
+        }
     }
 }

src/JT808.Protocol.Extensions.JTActiveSafety/MessageBody/JT808_JTActiveSafety_0x0900_USB_0xF7.cs

@@ -1,14 +1,14 @@
-using JT808.Protocol.Attributes;
-using JT808.Protocol.Extensions.JTActiveSafety.Formatters;
-using System;
-using System.Collections.Generic;
-using System.Text;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
 
 namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
 {
-    [JT808Formatter(typeof(JT808_JTActiveSafety_0x0900_USB_0xF7_Formatter))]
-    public class JT808_JTActiveSafety_0x0900_USB_0xF7 : JT808_JTActiveSafety_0x0900_USB_Base
+    /// <summary>
+    ///  外设工作状态
+    /// </summary>
+    public class JT808_JTActiveSafety_0x0900_USB_0xF7 : JT808_JTActiveSafety_0x0900_USB_Base, IJT808MessagePackFormatter<JT808_JTActiveSafety_0x0900_USB_0xF7>
     {
+        public static JT808_JTActiveSafety_0x0900_USB_0xF7 Instance = new JT808_JTActiveSafety_0x0900_USB_0xF7();
         /// <summary>
         /// 工作状态
         /// </summary>
@@ -17,5 +17,19 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
         /// 报警状态
         /// </summary>
         public uint AlarmStatus { get; set; }
+
+        public JT808_JTActiveSafety_0x0900_USB_0xF7 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+        {
+            JT808_JTActiveSafety_0x0900_USB_0xF7 jT808_JTActiveSafety_0X0900_USB_0XF7 = new JT808_JTActiveSafety_0x0900_USB_0xF7();
+            jT808_JTActiveSafety_0X0900_USB_0XF7.WorkingCondition = reader.ReadByte();
+            jT808_JTActiveSafety_0X0900_USB_0XF7.AlarmStatus = reader.ReadUInt32();
+            return jT808_JTActiveSafety_0X0900_USB_0XF7;
+        }
+
+        public void Serialize(ref JT808MessagePackWriter writer, JT808_JTActiveSafety_0x0900_USB_0xF7 value, IJT808Config config)
+        {
+            writer.WriteByte(value.WorkingCondition);
+            writer.WriteUInt32(value.AlarmStatus);
+        }
     }
 }

src/JT808.Protocol.Extensions.JTActiveSafety/MessageBody/JT808_JTActiveSafety_0x0900_USB_0xF8.cs

@@ -1,13 +1,12 @@
-using JT808.Protocol.Attributes;
-using JT808.Protocol.Extensions.JTActiveSafety.Formatters;
-using System;
-using System.Collections.Generic;
-using System.Text;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
 
 namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
 {
-    [JT808Formatter(typeof(JT808_JTActiveSafety_0x0900_USB_0xF8_Formatter))]
-    public class JT808_JTActiveSafety_0x0900_USB_0xF8 : JT808_JTActiveSafety_0x0900_USB_Base
+    /// <summary>
+    ///  外设系统信息
+    /// </summary>
+    public class JT808_JTActiveSafety_0x0900_USB_0xF8 : JT808_JTActiveSafety_0x0900_USB_Base, IJT808MessagePackFormatter<JT808_JTActiveSafety_0x0900_USB_0xF8>
     {
         /// <summary>
         /// 公司名称长度
@@ -59,5 +58,50 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
         /// 客户代码
         /// </summary>
         public string CustomerCode { get; set; }
+
+        public JT808_JTActiveSafety_0x0900_USB_0xF8 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+        {
+            JT808_JTActiveSafety_0x0900_USB_0xF8 jT808_JTActiveSafety_0X0900_USB_0XF8 = new JT808_JTActiveSafety_0x0900_USB_0xF8();
+            jT808_JTActiveSafety_0X0900_USB_0XF8.CompantNameLength = reader.ReadByte();
+            jT808_JTActiveSafety_0X0900_USB_0XF8.CompantName = reader.ReadString(jT808_JTActiveSafety_0X0900_USB_0XF8.CompantNameLength);
+            jT808_JTActiveSafety_0X0900_USB_0XF8.ProductModelLength = reader.ReadByte();
+            jT808_JTActiveSafety_0X0900_USB_0XF8.ProductModel = reader.ReadString(jT808_JTActiveSafety_0X0900_USB_0XF8.ProductModelLength);
+            jT808_JTActiveSafety_0X0900_USB_0XF8.HardwareVersionNumberLength = reader.ReadByte();
+            jT808_JTActiveSafety_0X0900_USB_0XF8.HardwareVersionNumber = reader.ReadString(jT808_JTActiveSafety_0X0900_USB_0XF8.HardwareVersionNumberLength);
+            jT808_JTActiveSafety_0X0900_USB_0XF8.SoftwareVersionNumberLength = reader.ReadByte();
+            jT808_JTActiveSafety_0X0900_USB_0XF8.SoftwareVersionNumber = reader.ReadString(jT808_JTActiveSafety_0X0900_USB_0XF8.SoftwareVersionNumberLength);
+            jT808_JTActiveSafety_0X0900_USB_0XF8.DevicesIDLength = reader.ReadByte();
+            jT808_JTActiveSafety_0X0900_USB_0XF8.DevicesID = reader.ReadString(jT808_JTActiveSafety_0X0900_USB_0XF8.DevicesIDLength);
+            jT808_JTActiveSafety_0X0900_USB_0XF8.CustomerCodeLength = reader.ReadByte();
+            jT808_JTActiveSafety_0X0900_USB_0XF8.CustomerCode = reader.ReadString(jT808_JTActiveSafety_0X0900_USB_0XF8.CustomerCodeLength);
+            return jT808_JTActiveSafety_0X0900_USB_0XF8;
+        }
+
+        public void Serialize(ref JT808MessagePackWriter writer, JT808_JTActiveSafety_0x0900_USB_0xF8 value, IJT808Config config)
+        {
+            writer.Skip(1, out int CompantNameLengthPosition);
+            writer.WriteString(value.CompantName);
+            writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - CompantNameLengthPosition - 1), CompantNameLengthPosition);
+
+            writer.Skip(1, out int ProductModelLengthPosition);
+            writer.WriteString(value.ProductModel);
+            writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - ProductModelLengthPosition - 1), ProductModelLengthPosition);
+
+            writer.Skip(1, out int HardwareVersionNumberLengthPosition);
+            writer.WriteString(value.HardwareVersionNumber);
+            writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - HardwareVersionNumberLengthPosition - 1), HardwareVersionNumberLengthPosition);
+
+            writer.Skip(1, out int SoftwareVersionNumberLengthPosition);
+            writer.WriteString(value.SoftwareVersionNumber);
+            writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - SoftwareVersionNumberLengthPosition - 1), SoftwareVersionNumberLengthPosition);
+
+            writer.Skip(1, out int DevicesIDLengthPosition);
+            writer.WriteString(value.DevicesID);
+            writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - DevicesIDLengthPosition - 1), DevicesIDLengthPosition);
+
+            writer.Skip(1, out int CustomerCodeLengthPosition);
+            writer.WriteString(value.CustomerCode);
+            writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - CustomerCodeLengthPosition - 1), CustomerCodeLengthPosition);
+        }
     }
 }

src/JT808.Protocol.Extensions.JTActiveSafety/MessageBody/JT808_JTActiveSafety_0x8900.cs

@@ -1,17 +1,14 @@
-using JT808.Protocol.Attributes;
-using JT808.Protocol.Extensions.JTActiveSafety.Formatters;
+using JT808.Protocol.Formatters;
 using JT808.Protocol.MessageBody;
-using System;
+using JT808.Protocol.MessagePack;
 using System.Collections.Generic;
-using System.Text;
 
 namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
 {
     /// <summary>
     /// 查询基本信息
     /// </summary>
-    [JT808Formatter(typeof(JT808_JTActiveSafety_0x8900_Formatter))]
-    public class JT808_JTActiveSafety_0x8900: JT808_0x8900_BodyBase
+    public class JT808_JTActiveSafety_0x8900: JT808_0x8900_BodyBase, IJT808MessagePackFormatter<JT808_JTActiveSafety_0x8900>
     {
         /// <summary>
         /// 外设ID列表总数
@@ -21,5 +18,32 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody
         /// 外设ID
         /// </summary>
         public List<byte> MultipleUSB { get; set; }
+
+        public JT808_JTActiveSafety_0x8900 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+        {
+            JT808_JTActiveSafety_0x8900 jT808_JTActiveSafety_0X8900 = new JT808_JTActiveSafety_0x8900();
+            jT808_JTActiveSafety_0X8900.USBCount = reader.ReadByte();
+            if (jT808_JTActiveSafety_0X8900.USBCount > 0)
+            {
+                jT808_JTActiveSafety_0X8900.MultipleUSB = new List<byte>();
+                for (int i = 0; i < jT808_JTActiveSafety_0X8900.USBCount; i++)
+                {
+                    jT808_JTActiveSafety_0X8900.MultipleUSB.Add(reader.ReadByte());
+                }
+            }
+            return jT808_JTActiveSafety_0X8900;
+        }
+
+        public void Serialize(ref JT808MessagePackWriter writer, JT808_JTActiveSafety_0x8900 value, IJT808Config config)
+        {
+            if (value.MultipleUSB != null && value.MultipleUSB.Count > 0)
+            {
+                writer.WriteByte((byte)value.MultipleUSB.Count);
+                foreach (var item in value.MultipleUSB)
+                {
+                    writer.WriteByte(item);
+                }
+            }
+        }
     }
 }

src/JTActiveSafety.sln

@@ -7,9 +7,9 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "JT808.Protocol.Extensions.J
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "JTActiveSafety.Protocol", "JTActiveSafety.Protocol\JTActiveSafety.Protocol.csproj", "{FF716FAA-0C89-4DB9-A559-C50E502B996D}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "JT808.Protocol.Extensions.JTActiveSafety.Test", "JT808.Protocol.Extensions.JTActiveSafety.Test\JT808.Protocol.Extensions.JTActiveSafety.Test.csproj", "{5A5B068D-4276-4E9D-84A4-C659A86A4A6B}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "JT808.Protocol.Extensions.JTActiveSafety.Test", "JT808.Protocol.Extensions.JTActiveSafety.Test\JT808.Protocol.Extensions.JTActiveSafety.Test.csproj", "{5A5B068D-4276-4E9D-84A4-C659A86A4A6B}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "JTActiveSafety.Protocol.Test", "JTActiveSafety.Protocol.Test\JTActiveSafety.Protocol.Test.csproj", "{148DB5C2-A8ED-4430-8AB8-44839FC45C7F}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "JTActiveSafety.Protocol.Test", "JTActiveSafety.Protocol.Test\JTActiveSafety.Protocol.Test.csproj", "{148DB5C2-A8ED-4430-8AB8-44839FC45C7F}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution