langjie-m-play 0.0.26 → 0.0.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langjie-m-play",
-  "version": "0.0.26",
+  "version": "0.0.28",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",

package/service/GtcServiceWebSocketImpl.d.ts

@@ -20,6 +20,7 @@ declare class GtcServiceWebSocketImpl implements IGtcService {
     private m_isNormalClose;
     constructor();
     buffer2GramJson(buffer: Uint8Array): void;
+    buffer2EventJson(buffer: Uint8Array): void;
     init(url: string, connectCallback: () => void, disconnectCallback: () => void): Promise<boolean>;
     _initWebSocket(): Promise<boolean>;
     _reconnect(): void;

package/service/GtcServiceWebSocketImpl.js

@@ -14,8 +14,8 @@ import { PubSubUtil } from "../utils/PubSubUtil";
 import { SubKeyEnum } from "../utils/enums/SubKeyEnum";
 // @ts-ignore
 import { MsgEventTypeEnum } from "../domain/enums/MsgEventTypeEnum";
-import Dvb from "../utils/Dvb";
-import { DataGramUtil } from "../utils/DataGramUtil";
+import { RemoteDataGramList, RemoteEventPack, RemoteBinDataTypeEnum, RemoteBinDataType } from "../utils/RemoteBinData";
+import { MixGramTypeEnum } from "../domain/enums/MixGramTypeEnum";
 /**
  * 远程gtc服务WebSocket实现
  */
@@ -36,51 +36,26 @@ class GtcServiceWebSocketImpl {
         this.m_isNormalClose = false;
     }
     buffer2GramJson(buffer) {
-        const retGramJson = {
-            "error": null,
-            "event": "R_GRAM_LIST",
-            "id": null,
-            "method": null,
-            "result": {
-                "ctrlIndex": 0,
-                "data": {
-                    "DataGramList": []
-                },
-                "msgEventType": 1,
-                "serviceType": 2
-            },
-            "slaveInstId": null,
-            "timestamp": 0
-        };
-        const tagLength = DataGramUtil.tagLength();
-        if (buffer.length % (tagLength * 4) != 0) {
-            console.error("length is err", tagLength, buffer.length);
+        const remoteDataGramList = RemoteDataGramList.Build(buffer);
+        const mixGramTypeEnum = remoteDataGramList.MixGramTypeType();
+        const retGramJson = remoteDataGramList.ToJson();
+        if (retGramJson == null) {
             return;
         }
-        const dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-        const dataGramList = [];
-        // 单行长度 = 标签个数 × 4字节（uint32_t占4字节）
-        const singleLineLength = tagLength * 4;
-        for (let lineOffset = 0; lineOffset < buffer.length; lineOffset += singleLineLength) {
-            // 单个数据项的uint32数组（对应原line）
-            const singleLineItemList = [];
-            // 遍历当前数据项的所有标签，拼接4字节为uint32
-            for (let tagIdx = 0; tagIdx < tagLength; tagIdx++) {
-                // 计算当前标签在DataView中的字节偏移（行偏移 + 标签偏移×4字节）
-                const byteOffset = lineOffset + (tagIdx * 4);
-                const uint32Value = dataView.getUint32(byteOffset, true);
-                if (DataGramUtil.isDVB(tagIdx)) {
-                    const strValue = Dvb.Dvb2String(uint32Value);
-                    singleLineItemList.push(strValue);
-                }
-                else {
-                    singleLineItemList.push(uint32Value.toString(10));
-                }
-            }
-            dataGramList.push(singleLineItemList);
+        if (mixGramTypeEnum == MixGramTypeEnum.GRAM) {
+            this.dataGram(retGramJson);
+        }
+        else {
+            PubSubUtil.publish(JsonRpcEventEnum.MIX_DATAGRAM, retGramJson);
         }
-        retGramJson.result.data.DataGramList = dataGramList;
-        this.dataGram(retGramJson);
+    }
+    buffer2EventJson(buffer) {
+        const remoteEventPack = RemoteEventPack.Build(buffer);
+        const remoteEventJson = remoteEventPack.ToJson();
+        if (remoteEventJson == null) {
+            return;
+        }
+        PubSubUtil.publish(JsonRpcEventEnum.MIX_DATAGRAM, remoteEventJson);
     }
     init(url, connectCallback, disconnectCallback) {
         this.m_connectCallback = connectCallback;
@@ -118,8 +93,14 @@ class GtcServiceWebSocketImpl {
                     reader.onload = function (e) {
                         let arrayBuffer = e.target.result;
                         // @ts-ignore
-                        let bs = new Uint8Array(arrayBuffer);
-                        that.buffer2GramJson(bs);
+                        let uint8Array = new Uint8Array(arrayBuffer);
+                        const remoteBinDataTypeEnum = RemoteBinDataType(uint8Array);
+                        if (remoteBinDataTypeEnum === RemoteBinDataTypeEnum.R_DATAGRAM_LIST) {
+                            that.buffer2GramJson(uint8Array);
+                        }
+                        else if (remoteBinDataTypeEnum === RemoteBinDataTypeEnum.R_EVENT_PACK) {
+                            that.buffer2EventJson(uint8Array);
+                        }
                     };
                     reader.readAsArrayBuffer(blob);
                     return;

package/service/MPlay.js

@@ -482,7 +482,9 @@ export class MPlay {
     subscribeActionGoGram(fn) {
         return __awaiter(this, void 0, void 0, function* () {
             this.actionGoGramCallBack = fn;
-            return yield GtcClient.subscribeActionGoGram(this.instId, this.serviceType, this.ctrlIndex);
+            const result = yield GtcClient.subscribeActionGoGram(this.instId, this.serviceType, this.ctrlIndex);
+            DataGramUtil.registerMixGramTagMap(result);
+            return result;
         });
     }
 }

package/utils/DataGramUtil.d.ts

@@ -1,12 +1,15 @@
+import { MixGramTypeEnum } from "../domain/enums/MixGramTypeEnum";
 export declare class DataGramUtil {
     private static TAG_LIST;
     private static FLAG_TAG_LIST;
+    private static FLAG_MIX_GRAM_TAG_MAP;
     /**
      * 注册订阅串
      *
      * @param tags 订阅串
      */
     static registerTag(tags: string): void;
+    static registerMixGramTagMap(tagMap: Record<MixGramTypeEnum, Array<string>>): void;
     /**
      * 根据索引判断是否DVB码
      *
@@ -14,4 +17,5 @@ export declare class DataGramUtil {
      */
     static isDVB(index: number): boolean;
     static tagLength(): number;
+    static mixGramTagMap(): Record<MixGramTypeEnum, Array<string>>;
 }

package/utils/DataGramUtil.js

@@ -7,6 +7,9 @@ export class DataGramUtil {
     static registerTag(tags) {
         DataGramUtil.TAG_LIST = tags.split(',');
     }
+    static registerMixGramTagMap(tagMap) {
+        DataGramUtil.FLAG_MIX_GRAM_TAG_MAP = tagMap;
+    }
     /**
      * 根据索引判断是否DVB码
      *
@@ -15,6 +18,7 @@ export class DataGramUtil {
     static isDVB(index) {
         const tag = DataGramUtil.TAG_LIST[index];
         for (let i = 0; i < DataGramUtil.FLAG_TAG_LIST.length; i++) {
+            // @ts-ignore
             if (tag.endsWith(DataGramUtil.FLAG_TAG_LIST[i])) {
                 return false;
             }
@@ -24,6 +28,10 @@ export class DataGramUtil {
     static tagLength() {
         return DataGramUtil.TAG_LIST.length;
     }
+    static mixGramTagMap() {
+        return DataGramUtil.FLAG_MIX_GRAM_TAG_MAP;
+    }
 }
 DataGramUtil.TAG_LIST = [];
 DataGramUtil.FLAG_TAG_LIST = ['Time', 'Event', 'Intent'];
+DataGramUtil.FLAG_MIX_GRAM_TAG_MAP = null;

package/utils/NPack.d.ts

@@ -0,0 +1,53 @@
+export declare enum NpackTypeEnum {
+    NULL_TYPE = 0,
+    W_TYPE = 1,
+    DVB_TYPE = 2,
+    DW_TYPE = 3,
+    INT64_TYPE = 4,
+    STR_TYPE = 16,
+    WA_TYPE = 17,
+    DVBA_TYPE = 18,
+    DWA_TYPE = 19,
+    KEY_TYPE = 20,
+    STRUCT_TYPE = 32,
+    STRUCTA_TYPE = 48,
+    PACK_TYPE = 64,
+    NULL_NID = 1536,
+    W_NID = 1537,
+    DVB_NID = 1538,
+    DW_NID = 1539,
+    INT64_NID = 1540,
+    STR_NID = 1552,
+    WA_NID = 1553,
+    DVBA_NID = 1554,
+    DWA_NID = 1555,
+    STRUCT_NID = 1568,
+    STRUCTA_NID = 1584,
+    PACK_NID = 1600,
+    OBJ_PACK = 1601,
+    UNIT_LIST = 2176
+}
+export declare class NPack {
+    m_buffer: Uint8Array;
+    m_dataview: DataView;
+    m_byteOffset: number;
+    constructor(buffer: Uint8Array, byteOffset: number);
+    HeadSize(): number;
+    Length(): number;
+    Type(): number;
+    NLENGTH(iterPtr: number): number;
+    static IS_NULL(t: number): boolean;
+    static IS_NUMBER(t: number): boolean;
+    static IS_ARRAY(t: number): boolean;
+    static IS_STRUCT(t: number): boolean;
+    static IS_BLOCK(t: number): boolean;
+    static IS_PACK(t: number): boolean;
+    static IS_LIST(t: number): boolean;
+    Count(): number;
+    GetMember(index: number): NPack | null;
+    private _parseNumber;
+    private _parseString;
+    ToRawJson(maxDepth?: number, visited?: WeakSet<NPack>): any;
+    ToJson(maxDepth?: number, visited?: WeakSet<NPack>): any;
+    static Build(buffer: Uint8Array, byteOffset: number): NPack;
+}

package/utils/NPack.js

@@ -0,0 +1,261 @@
+import Dvb from "./Dvb";
+// 枚举保持不变
+export var NpackTypeEnum;
+(function (NpackTypeEnum) {
+    NpackTypeEnum[NpackTypeEnum["NULL_TYPE"] = 0] = "NULL_TYPE";
+    NpackTypeEnum[NpackTypeEnum["W_TYPE"] = 1] = "W_TYPE";
+    NpackTypeEnum[NpackTypeEnum["DVB_TYPE"] = 2] = "DVB_TYPE";
+    NpackTypeEnum[NpackTypeEnum["DW_TYPE"] = 3] = "DW_TYPE";
+    NpackTypeEnum[NpackTypeEnum["INT64_TYPE"] = 4] = "INT64_TYPE";
+    NpackTypeEnum[NpackTypeEnum["STR_TYPE"] = 16] = "STR_TYPE";
+    NpackTypeEnum[NpackTypeEnum["WA_TYPE"] = 17] = "WA_TYPE";
+    NpackTypeEnum[NpackTypeEnum["DVBA_TYPE"] = 18] = "DVBA_TYPE";
+    NpackTypeEnum[NpackTypeEnum["DWA_TYPE"] = 19] = "DWA_TYPE";
+    NpackTypeEnum[NpackTypeEnum["KEY_TYPE"] = 20] = "KEY_TYPE";
+    NpackTypeEnum[NpackTypeEnum["STRUCT_TYPE"] = 32] = "STRUCT_TYPE";
+    NpackTypeEnum[NpackTypeEnum["STRUCTA_TYPE"] = 48] = "STRUCTA_TYPE";
+    NpackTypeEnum[NpackTypeEnum["PACK_TYPE"] = 64] = "PACK_TYPE";
+    NpackTypeEnum[NpackTypeEnum["NULL_NID"] = 1536] = "NULL_NID";
+    NpackTypeEnum[NpackTypeEnum["W_NID"] = 1537] = "W_NID";
+    NpackTypeEnum[NpackTypeEnum["DVB_NID"] = 1538] = "DVB_NID";
+    NpackTypeEnum[NpackTypeEnum["DW_NID"] = 1539] = "DW_NID";
+    NpackTypeEnum[NpackTypeEnum["INT64_NID"] = 1540] = "INT64_NID";
+    NpackTypeEnum[NpackTypeEnum["STR_NID"] = 1552] = "STR_NID";
+    NpackTypeEnum[NpackTypeEnum["WA_NID"] = 1553] = "WA_NID";
+    NpackTypeEnum[NpackTypeEnum["DVBA_NID"] = 1554] = "DVBA_NID";
+    NpackTypeEnum[NpackTypeEnum["DWA_NID"] = 1555] = "DWA_NID";
+    NpackTypeEnum[NpackTypeEnum["STRUCT_NID"] = 1568] = "STRUCT_NID";
+    NpackTypeEnum[NpackTypeEnum["STRUCTA_NID"] = 1584] = "STRUCTA_NID";
+    NpackTypeEnum[NpackTypeEnum["PACK_NID"] = 1600] = "PACK_NID";
+    NpackTypeEnum[NpackTypeEnum["OBJ_PACK"] = 1601] = "OBJ_PACK";
+    NpackTypeEnum[NpackTypeEnum["UNIT_LIST"] = 2176] = "UNIT_LIST";
+})(NpackTypeEnum || (NpackTypeEnum = {}));
+export class NPack {
+    constructor(buffer, byteOffset) {
+        if (!buffer || buffer.byteLength === 0) {
+            throw new Error("NPack buffer is empty or null");
+        }
+        if (byteOffset < 0 || byteOffset > buffer.byteLength) {
+            throw new RangeError(`byteOffset ${byteOffset} out of range [0, ${buffer.byteLength}]`);
+        }
+        this.m_buffer = buffer;
+        this.m_byteOffset = byteOffset;
+        const realOffset = buffer.byteOffset + byteOffset;
+        const realLength = Math.max(0, buffer.byteLength - byteOffset);
+        this.m_dataview = new DataView(buffer.buffer, realOffset, realLength);
+    }
+    HeadSize() {
+        if (this.m_dataview.byteLength <= 4) {
+            return 4;
+        }
+        const ntype = this.Type();
+        const headSize = (ntype >> 8);
+        return headSize === 0 ? 4 : headSize;
+    }
+    Length() {
+        if (this.m_dataview.byteLength < 2) {
+            return 0;
+        }
+        return this.m_dataview.getUint16(0, true);
+    }
+    Type() {
+        if (this.m_dataview.byteLength < 4) {
+            return NpackTypeEnum.NULL_TYPE;
+        }
+        return this.m_dataview.getUint16(2, true);
+    }
+    NLENGTH(iterPtr) {
+        if (iterPtr < 0 || iterPtr + 2 > this.m_dataview.byteLength) {
+            return 0;
+        }
+        return this.m_dataview.getUint16(iterPtr, true);
+    }
+    static IS_NULL(t) {
+        return (t & 0x00FF) === NpackTypeEnum.NULL_TYPE;
+    }
+    static IS_NUMBER(t) {
+        return (t & 0x00F0) === 0 && !this.IS_NULL(t);
+    }
+    static IS_ARRAY(t) {
+        return (t & 0x0010) > 0;
+    }
+    static IS_STRUCT(t) {
+        return (t & 0x0020) > 0;
+    }
+    static IS_BLOCK(t) {
+        return (t & 0x0030) > 0;
+    }
+    static IS_PACK(t) {
+        return (t & 0x0040) > 0;
+    }
+    static IS_LIST(t) {
+        return (t & 0x0080) > 0;
+    }
+    Count() {
+        const totalLength = this.Length();
+        const headSize = this.HeadSize();
+        if (totalLength <= headSize || this.m_dataview.byteLength < totalLength) {
+            return 0;
+        }
+        let sumLength = headSize;
+        let count = 0;
+        let iterPtr = headSize;
+        let iterLen = this.NLENGTH(iterPtr);
+        while (sumLength < totalLength) {
+            if (iterLen <= 0 || iterPtr + iterLen > totalLength) {
+                break;
+            }
+            count++;
+            sumLength += iterLen;
+            iterPtr += iterLen;
+            iterLen = this.NLENGTH(iterPtr);
+        }
+        return count;
+    }
+    GetMember(index) {
+        if (index < 0)
+            return null;
+        const totalLength = this.Length();
+        const headSize = this.HeadSize();
+        if (totalLength <= headSize || this.m_dataview.byteLength < totalLength) {
+            return null;
+        }
+        let sumLength = headSize;
+        let count = 0;
+        let iterPtr = headSize;
+        let iterLen = this.NLENGTH(iterPtr);
+        while (count < index) {
+            if (iterLen <= 0 || iterPtr + iterLen > totalLength) {
+                return null;
+            }
+            count++;
+            sumLength += iterLen;
+            if (sumLength >= totalLength) {
+                return null;
+            }
+            iterPtr += iterLen;
+            iterLen = this.NLENGTH(iterPtr);
+        }
+        const newOffset = this.m_byteOffset + iterPtr;
+        if (newOffset >= this.m_buffer.byteLength) {
+            return null;
+        }
+        return NPack.Build(this.m_buffer, newOffset);
+    }
+    _parseNumber(type) {
+        switch (type) {
+            case NpackTypeEnum.W_TYPE:
+                return this.m_dataview.byteLength >= 4 ? this.m_dataview.getUint16(4, true) : null;
+            case NpackTypeEnum.DVB_TYPE:
+                return Dvb.Dvb2String(this.m_dataview.getUint32(4, true));
+            case NpackTypeEnum.DW_TYPE:
+                return this.m_dataview.byteLength >= 8 ? this.m_dataview.getUint32(4, true) : null;
+            case NpackTypeEnum.INT64_TYPE:
+                return this.m_dataview.byteLength >= 12 ? this.m_dataview.getUint32(4, true) : null;
+            default:
+                return null;
+        }
+    }
+    _parseString() {
+        const strLen = this.Length() - 4; // 假设字符串长度在偏移4处
+        if (strLen <= 0 || 4 + strLen > this.m_dataview.byteLength) {
+            return null;
+        }
+        const uint8Arr = new Uint8Array(this.m_dataview.buffer, this.m_dataview.byteOffset + 4, strLen);
+        let nullIndex = uint8Arr.findIndex(byte => byte === 0);
+        // 若未找到空字符，取完整长度；否则取空字符前的有效长度
+        const validLength = nullIndex === -1 ? strLen : nullIndex;
+        // 截取有效字节（避免空字符），解码为字符串
+        const validUint8Arr = uint8Arr.subarray(0, validLength);
+        return new TextDecoder('utf-8').decode(validUint8Arr);
+    }
+    // @ts-ignore
+    ToRawJson(maxDepth = 4, visited = new WeakSet()) {
+        // 防护1：循环引用检测
+        if (visited.has(this)) {
+            return { "error": "circular reference" };
+        }
+        // 防护2：递归深度限制
+        if (maxDepth <= 0) {
+            return { "error": "exceed max recursion depth" };
+        }
+        visited.add(this);
+        const type = this.Type();
+        const count = this.Count();
+        try {
+            // 1. 空类型
+            if (NPack.IS_NULL(type)) {
+                return null;
+            }
+            // 2. 数字类型（非递归，直接返回值）
+            if (NPack.IS_NUMBER(type)) {
+                return this._parseNumber(type);
+            }
+            // 3. 字符串类型（非递归，直接返回值）
+            if (NPack.IS_BLOCK(type)) {
+                return this._parseString();
+            }
+            // 4. 数组类型（递归但有深度限制）
+            if (NPack.IS_ARRAY(type)) {
+                const arr = [];
+                for (let i = 0; i < count; i++) {
+                    const member = this.GetMember(i);
+                    arr.push(member ? member.ToRawJson(maxDepth - 1, visited) : null);
+                }
+                return arr;
+            }
+            // 5. 其他容器类型（结构/列表等，递归解析）
+            const retObjArray = [];
+            for (let i = 0; i < count; i++) {
+                const npackItem = this.GetMember(i);
+                retObjArray.push(npackItem ? npackItem.ToRawJson(maxDepth - 1, visited) : null);
+            }
+            return retObjArray;
+        }
+        finally {
+            // 释放引用（避免内存泄漏）
+            visited.delete(this);
+        }
+    }
+    // @ts-ignore
+    ToJson(maxDepth = 4, visited = new WeakSet()) {
+        // 1. 直接调用 ToRawJson 拿到扁平键值对数组
+        const rawResult = this.ToRawJson(maxDepth, visited);
+        // 2. 处理错误场景（保持错误格式统一）
+        if (Array.isArray(rawResult) && rawResult[0] === "error") {
+            return { error: rawResult };
+        }
+        if (rawResult === null || typeof rawResult !== "object") {
+            return rawResult; // 基础类型（数字/字符串/null）直接返回
+        }
+        // 3. 工具函数：将单个 [k1,v1,k2,v2,...] 数组转为对象
+        const rawArrToObj = (rawArr) => {
+            const obj = {};
+            // 两两遍历数组：i 取 key，i+1 取 val，步长为2
+            for (let i = 0; i < rawArr.length; i += 2) {
+                const key = rawArr[i];
+                const val = rawArr[i + 1]; // 没有对应 val 时为 undefined
+                // 过滤无效 key（非字符串类型的 key 不存入对象）
+                if (typeof key === "string") {
+                    // 递归处理 val：如果 val 是数组（子键值对），转为子对象
+                    obj[key] = Array.isArray(val) && val[0] !== "error" ? rawArrToObj(val) : val;
+                }
+            }
+            return obj;
+        };
+        // 4. 区分外层是「二维数组」还是「单个键值对数组」
+        if (Array.isArray(rawResult)) {
+            // 情况1：外层是数组（如 [[k1,v1], [k2,v2]]）→ 转为对象数组
+            if (rawResult.length > 0 && Array.isArray(rawResult[0])) {
+                return rawResult.map(item => Array.isArray(item) && item[0] !== "error" ? rawArrToObj(item) : item);
+            }
+            // 情况2：外层是单个键值对数组（如 [k1,v1,k2,v2]）→ 转为单个对象
+            return rawArrToObj(rawResult);
+        }
+        // 5. 其他情况（如 PACK 类型返回的 ["k",3]）→ 转为对象
+        return rawArrToObj(Array.isArray(rawResult) ? rawResult : []);
+    }
+    static Build(buffer, byteOffset) {
+        return new NPack(buffer, byteOffset);
+    }
+}

package/utils/RemoteBinData.d.ts

@@ -0,0 +1,45 @@
+import { MixGramTypeEnum } from "../domain/enums/MixGramTypeEnum";
+import { NPack } from "./NPack";
+export declare enum RemoteBinDataTypeEnum {
+    R_EVENT_PACK = 4166,
+    R_DATAGRAM_LIST = 4224,
+    R_NULL = 0
+}
+export declare function RemoteBinDataType(buffer: Uint8Array): RemoteBinDataTypeEnum;
+export declare enum RemoteDataGramListEnum {
+    R_DATAGRAM_FOR_VIN = 11954,
+    R_DATAGRAM_FOR_DIGITAL = 54467,
+    R_DATAGRAM_FOR_SWITCH = 9047,
+    R_DATAGRAM_FOR_CONTROLLER = 41961,
+    R_DATAGRAM_FOR_WATCH = 32604,
+    R_DATAGRAM_FOR_DATAGRAM = 63910
+}
+export declare enum RemoteEventPackTypeEnum {
+    R_EVENT_FOR_VIN_ATTR = 29005,
+    R_EVENT_FOR_ATS_EVENT = 50895
+}
+export declare class RemoteDataGramList {
+    m_buffer: Uint8Array;
+    m_dataview: DataView;
+    constructor(buffer: Uint8Array);
+    HeadSize(): number;
+    UnitSize(): number;
+    Type(): number;
+    MixGramTypeType(): MixGramTypeEnum;
+    HashId(): number;
+    InsId(): number;
+    ToJson(): object;
+    ToMixGramJson(type: MixGramTypeEnum): any;
+    DataGramList(): string[][];
+    ToDataGramJson(): any;
+    static Build(buffer: Uint8Array): RemoteDataGramList;
+}
+export declare class RemoteEventPack {
+    m_buffer: Uint8Array;
+    m_dataview: DataView;
+    m_pack: NPack;
+    constructor(buffer: Uint8Array);
+    HashId(): number;
+    static Build(buffer: Uint8Array): RemoteEventPack;
+    ToJson(): any;
+}

package/utils/RemoteBinData.js

@@ -0,0 +1,180 @@
+import { DataGramUtil } from "./DataGramUtil";
+import { MixGramTypeEnum } from "../domain/enums/MixGramTypeEnum";
+import Dvb from "./Dvb";
+import { NPack } from "./NPack";
+export var RemoteBinDataTypeEnum;
+(function (RemoteBinDataTypeEnum) {
+    RemoteBinDataTypeEnum[RemoteBinDataTypeEnum["R_EVENT_PACK"] = 4166] = "R_EVENT_PACK";
+    RemoteBinDataTypeEnum[RemoteBinDataTypeEnum["R_DATAGRAM_LIST"] = 4224] = "R_DATAGRAM_LIST";
+    RemoteBinDataTypeEnum[RemoteBinDataTypeEnum["R_NULL"] = 0] = "R_NULL";
+})(RemoteBinDataTypeEnum || (RemoteBinDataTypeEnum = {}));
+export function RemoteBinDataType(buffer) {
+    if (buffer[2] == 0x46) {
+        return RemoteBinDataTypeEnum.R_EVENT_PACK;
+    }
+    else if (buffer[2] == 0x80) {
+        return RemoteBinDataTypeEnum.R_DATAGRAM_LIST;
+    }
+    else {
+        return RemoteBinDataTypeEnum.R_NULL;
+    }
+}
+export var RemoteDataGramListEnum;
+(function (RemoteDataGramListEnum) {
+    RemoteDataGramListEnum[RemoteDataGramListEnum["R_DATAGRAM_FOR_VIN"] = 11954] = "R_DATAGRAM_FOR_VIN";
+    RemoteDataGramListEnum[RemoteDataGramListEnum["R_DATAGRAM_FOR_DIGITAL"] = 54467] = "R_DATAGRAM_FOR_DIGITAL";
+    RemoteDataGramListEnum[RemoteDataGramListEnum["R_DATAGRAM_FOR_SWITCH"] = 9047] = "R_DATAGRAM_FOR_SWITCH";
+    RemoteDataGramListEnum[RemoteDataGramListEnum["R_DATAGRAM_FOR_CONTROLLER"] = 41961] = "R_DATAGRAM_FOR_CONTROLLER";
+    RemoteDataGramListEnum[RemoteDataGramListEnum["R_DATAGRAM_FOR_WATCH"] = 32604] = "R_DATAGRAM_FOR_WATCH";
+    RemoteDataGramListEnum[RemoteDataGramListEnum["R_DATAGRAM_FOR_DATAGRAM"] = 63910] = "R_DATAGRAM_FOR_DATAGRAM";
+})(RemoteDataGramListEnum || (RemoteDataGramListEnum = {}));
+export var RemoteEventPackTypeEnum;
+(function (RemoteEventPackTypeEnum) {
+    RemoteEventPackTypeEnum[RemoteEventPackTypeEnum["R_EVENT_FOR_VIN_ATTR"] = 29005] = "R_EVENT_FOR_VIN_ATTR";
+    RemoteEventPackTypeEnum[RemoteEventPackTypeEnum["R_EVENT_FOR_ATS_EVENT"] = 50895] = "R_EVENT_FOR_ATS_EVENT";
+})(RemoteEventPackTypeEnum || (RemoteEventPackTypeEnum = {}));
+export class RemoteDataGramList {
+    constructor(buffer) {
+        this.m_buffer = buffer;
+        this.m_dataview = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    }
+    HeadSize() {
+        return 16;
+    }
+    UnitSize() {
+        return this.m_dataview.getUint16(6, true);
+    }
+    Type() {
+        return this.m_dataview.getUint16(2, true);
+    }
+    MixGramTypeType() {
+        const hashId = this.HashId();
+        switch (hashId) {
+            case RemoteDataGramListEnum.R_DATAGRAM_FOR_WATCH: return MixGramTypeEnum.WATCH;
+            case RemoteDataGramListEnum.R_DATAGRAM_FOR_DIGITAL: return MixGramTypeEnum.DI;
+            case RemoteDataGramListEnum.R_DATAGRAM_FOR_SWITCH: return MixGramTypeEnum.DO;
+            case RemoteDataGramListEnum.R_DATAGRAM_FOR_CONTROLLER: return MixGramTypeEnum.CTRL;
+            case RemoteDataGramListEnum.R_DATAGRAM_FOR_VIN: return MixGramTypeEnum.VIN;
+            case RemoteDataGramListEnum.R_DATAGRAM_FOR_DATAGRAM: return MixGramTypeEnum.GRAM;
+        }
+        return MixGramTypeEnum.OTHER;
+    }
+    HashId() {
+        return this.m_dataview.getUint16(4, true);
+    }
+    ;
+    InsId() {
+        return this.m_dataview.getUint16(14, true);
+    }
+    ToJson() {
+        const mixGramTypeType = this.MixGramTypeType();
+        if (mixGramTypeType === MixGramTypeEnum.GRAM) {
+            return this.ToDataGramJson();
+        }
+        else {
+            return this.ToMixGramJson(mixGramTypeType);
+        }
+    }
+    ToMixGramJson(type) {
+        const dataGramList = this.DataGramList();
+        return {
+            "type": type,
+            "data": dataGramList[0],
+        };
+    }
+    DataGramList() {
+        const hashId = this.HashId();
+        const tagLength = hashId == RemoteDataGramListEnum.R_DATAGRAM_FOR_DATAGRAM ? DataGramUtil.tagLength() : this.UnitSize() / 4;
+        if ((this.m_buffer.length - 16) % (tagLength * 4) != 0) {
+            console.error("length is err", tagLength, this.m_buffer.length);
+            return [[]];
+        }
+        const dataGramList = [];
+        // 单行长度 = 标签个数 × 4字节（uint32_t占4字节）
+        const singleLineLength = tagLength * 4;
+        const bodyDataSize = this.m_buffer.length - this.HeadSize();
+        for (let lineOffset = 0; lineOffset < bodyDataSize; lineOffset += singleLineLength) {
+            // 单个数据项的uint32数组（对应原line）
+            const singleLineItemList = [];
+            // 遍历当前数据项的所有标签，拼接4字节为uint32
+            for (let tagIdx = 0; tagIdx < tagLength; tagIdx++) {
+                // 计算当前标签在DataView中的字节偏移（行偏移 + 标签偏移×4字节）
+                const byteOffset = lineOffset + (tagIdx * 4) + 16;
+                const uint32Value = this.m_dataview.getUint32(byteOffset, true);
+                if (hashId != RemoteDataGramListEnum.R_DATAGRAM_FOR_DATAGRAM || DataGramUtil.isDVB(tagIdx)) {
+                    const strValue = Dvb.Dvb2String(uint32Value);
+                    singleLineItemList.push(strValue);
+                }
+                else {
+                    singleLineItemList.push(uint32Value.toString(10));
+                }
+            }
+            dataGramList.push(singleLineItemList);
+        }
+        return dataGramList;
+    }
+    ToDataGramJson() {
+        const retGramJson = {
+            "id": null,
+            "type": 1,
+            "result": {
+                "ctrlIndex": 0,
+                "data": {
+                    "DataGramList": []
+                },
+                "msgEventType": 1,
+                "serviceType": 2
+            },
+            "slaveInstId": null,
+            "timestamp": 0
+        };
+        retGramJson.result.data.DataGramList = this.DataGramList();
+        return retGramJson;
+    }
+    static Build(buffer) {
+        return new RemoteDataGramList(buffer);
+    }
+}
+export class RemoteEventPack {
+    constructor(buffer) {
+        this.m_buffer = buffer;
+        this.m_dataview = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        this.m_pack = NPack.Build(buffer, 16);
+    }
+    HashId() {
+        return this.m_dataview.getUint16(4, true);
+    }
+    ;
+    static Build(buffer) {
+        return new RemoteEventPack(buffer);
+    }
+    ToJson() {
+        const mixGramTagMap = DataGramUtil.mixGramTagMap();
+        if (mixGramTagMap === null) {
+            return null;
+        }
+        const hashId = this.HashId();
+        switch (hashId) {
+            case RemoteEventPackTypeEnum.R_EVENT_FOR_VIN_ATTR:
+                {
+                    const vinTagList = mixGramTagMap[MixGramTypeEnum.VIN];
+                    const vinAttrList = this.m_pack.ToJson();
+                    const retJson = {};
+                    for (let i = 0; i < vinAttrList.length; i++) {
+                        retJson[vinTagList[i]] = vinAttrList[i];
+                    }
+                    return {
+                        "type": MixGramTypeEnum.VIN_ATTR,
+                        "data": retJson
+                    };
+                }
+            case RemoteEventPackTypeEnum.R_EVENT_FOR_ATS_EVENT: {
+                return {
+                    "type": MixGramTypeEnum.OTHER,
+                    "data": this.m_pack.ToJson()
+                };
+            }
+        }
+        return null;
+    }
+}