2678 lines
194 KiB
JavaScript
2678 lines
194 KiB
JavaScript
"use strict";
|
|
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.P2PClientProtocol = void 0;
|
|
const dgram_1 = require("dgram");
|
|
const tiny_typed_emitter_1 = require("tiny-typed-emitter");
|
|
const stream_1 = require("stream");
|
|
const sweet_collections_1 = require("sweet-collections");
|
|
const date_and_time_1 = __importDefault(require("date-and-time"));
|
|
const utils_1 = require("./utils");
|
|
const types_1 = require("./types");
|
|
const types_2 = require("../http/types");
|
|
const device_1 = require("../http/device");
|
|
const utils_2 = require("../http/utils");
|
|
const talkback_1 = require("./talkback");
|
|
const error_1 = require("../error");
|
|
const types_3 = require("../push/types");
|
|
const ble_1 = require("./ble");
|
|
const http_1 = require("../http");
|
|
const utils_3 = require("../utils");
|
|
const logging_1 = require("../logging");
|
|
class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
|
|
MAX_RETRIES = 10;
|
|
MAX_COMMAND_RESULT_WAIT = 30 * 1000;
|
|
MAX_GATEWAY_COMMAND_RESULT_WAIT = 5 * 1000;
|
|
MAX_CONNECTION_TIMEOUT = 25 * 1000;
|
|
MAX_AKNOWLEDGE_TIMEOUT = 5 * 1000;
|
|
MAX_LOOKUP_TIMEOUT = 20 * 1000;
|
|
LOCAL_LOOKUP_RETRY_TIMEOUT = 1 * 1000;
|
|
LOOKUP_RETRY_TIMEOUT = 1 * 1000;
|
|
LOOKUP2_TIMEOUT = 3 * 1000;
|
|
LOOKUP2_RETRY_TIMEOUT = 1 * 1000;
|
|
MAX_EXPECTED_SEQNO_WAIT = 20 * 1000;
|
|
HEARTBEAT_INTERVAL = 5 * 1000;
|
|
MAX_COMMAND_QUEUE_TIMEOUT = 120 * 1000;
|
|
AUDIO_CODEC_ANALYZE_TIMEOUT = 650;
|
|
KEEPALIVE_INTERVAL = 2 * 1000;
|
|
ESD_DISCONNECT_TIMEOUT = 30 * 1000;
|
|
MAX_STREAM_DATA_WAIT = 5 * 1000;
|
|
RESEND_NOT_ACKNOWLEDGED_COMMAND = 100;
|
|
UDP_RECVBUFFERSIZE_BYTES = 1048576;
|
|
MAX_PAYLOAD_BYTES = 1028;
|
|
MAX_PACKET_BYTES = 1024;
|
|
MAX_VIDEO_PACKET_BYTES = 655360;
|
|
P2P_DATA_HEADER_BYTES = 16;
|
|
MAX_SEQUENCE_NUMBER = 65535;
|
|
LOOP_RUNAWAY_LIMIT = 1000;
|
|
/*
|
|
* SEQUENCE_PROCESSING_BOUNDARY is used to determine if an incoming sequence number
|
|
* that is lower than the expected one was already processed.
|
|
* If it is within the boundary, it is determined as 'already processed',
|
|
* If it is even lower, it is assumed that the sequence count has reached
|
|
* MAX_SEQUENCE_NUMBER and restarted at 0.
|
|
* */
|
|
SEQUENCE_PROCESSING_BOUNDARY = 20000; // worth of approx. 90 seconds of continous streaming
|
|
socket;
|
|
binded = false;
|
|
connected = false;
|
|
connecting = false;
|
|
terminating = false;
|
|
p2pTurnHandshaking = {};
|
|
p2pTurnConfirmed = false;
|
|
seqNumber = 0;
|
|
offsetDataSeqNumber = 0;
|
|
videoSeqNumber = 0;
|
|
lockSeqNumber = -1;
|
|
expectedSeqNo = {};
|
|
currentMessageBuilder = {};
|
|
currentMessageState = {};
|
|
talkbackStream;
|
|
downloadTotalBytes = 0;
|
|
downloadReceivedBytes = 0;
|
|
cloudAddresses;
|
|
messageStates = new sweet_collections_1.SortedMap((a, b) => a - b);
|
|
messageVideoStates = new sweet_collections_1.SortedMap((a, b) => a - b);
|
|
sendQueue = new Array();
|
|
connectTimeout;
|
|
lookupTimeout;
|
|
localLookupRetryTimeout;
|
|
lookupRetryTimeout;
|
|
lookup2Timeout;
|
|
lookup2RetryTimeout;
|
|
heartbeatTimeout;
|
|
keepaliveTimeout;
|
|
esdDisconnectTimeout;
|
|
secondaryCommandTimeout;
|
|
connectTime = null;
|
|
lastPong = null;
|
|
lastPongData = undefined;
|
|
connectionType = types_1.P2PConnectionType.QUICKEST;
|
|
energySavingDevice = false;
|
|
p2pSeqMapping = new Map();
|
|
p2pDataSeqNumber = 0;
|
|
connectAddress = undefined;
|
|
localIPAddress = undefined;
|
|
preferredIPAddress = undefined;
|
|
listeningPort = 0;
|
|
dskKey = "";
|
|
dskExpiration = null;
|
|
deviceSNs = {};
|
|
api;
|
|
rawStation;
|
|
customDataStaging = {};
|
|
lockPublicKey;
|
|
lockAESKeys = new Map();
|
|
channel = http_1.Station.CHANNEL;
|
|
encryption = types_1.EncryptionType.NONE;
|
|
p2pKey;
|
|
enableEmbeddedPKCS1Support = false;
|
|
constructor(rawStation, api, ipAddress, listeningPort = 0, publicKey = "", enableEmbeddedPKCS1Support = false) {
|
|
super();
|
|
this.api = api;
|
|
this.lockPublicKey = publicKey;
|
|
this.preferredIPAddress = ipAddress;
|
|
if (listeningPort >= 0)
|
|
this.listeningPort = listeningPort;
|
|
this.enableEmbeddedPKCS1Support = enableEmbeddedPKCS1Support;
|
|
this.cloudAddresses = (0, utils_1.decodeP2PCloudIPs)(rawStation.app_conn);
|
|
logging_1.rootP2PLogger.debug("Loaded P2P cloud ip addresses", { stationSN: rawStation.station_sn, ipAddress: ipAddress, cloudAddresses: this.cloudAddresses });
|
|
this.updateRawStation(rawStation);
|
|
this.socket = (0, dgram_1.createSocket)("udp4");
|
|
this.socket.on("message", (msg, rinfo) => this.handleMsg(msg, rinfo));
|
|
this.socket.on("error", (error) => this.onError(error));
|
|
this.socket.on("close", () => this.onClose());
|
|
this._initialize();
|
|
}
|
|
_incrementSequence(sequence) {
|
|
if (sequence < this.MAX_SEQUENCE_NUMBER)
|
|
return sequence + 1;
|
|
return 0;
|
|
}
|
|
_isBetween(n, lowBoundary, highBoundary) {
|
|
if (n < lowBoundary)
|
|
return false;
|
|
if (n >= highBoundary)
|
|
return false;
|
|
return true;
|
|
}
|
|
_wasSequenceNumberAlreadyProcessed(expectedSequence, receivedSequence) {
|
|
if ((expectedSequence - this.SEQUENCE_PROCESSING_BOUNDARY) > 0) { // complete boundary without squence number reset
|
|
return this._isBetween(receivedSequence, expectedSequence - this.SEQUENCE_PROCESSING_BOUNDARY, expectedSequence);
|
|
}
|
|
else { // there was a sequence number reset recently
|
|
const isInRangeAfterReset = this._isBetween(receivedSequence, 0, expectedSequence);
|
|
const isInRangeBeforeReset = this._isBetween(receivedSequence, this.MAX_SEQUENCE_NUMBER + (expectedSequence - this.SEQUENCE_PROCESSING_BOUNDARY), this.MAX_SEQUENCE_NUMBER);
|
|
return (isInRangeBeforeReset || isInRangeAfterReset);
|
|
}
|
|
}
|
|
_initialize() {
|
|
let rsaKey;
|
|
this.connected = false;
|
|
this.p2pTurnHandshaking = {};
|
|
this.p2pTurnConfirmed = false;
|
|
this.connecting = false;
|
|
this.lastPong = null;
|
|
this.lastPongData = undefined;
|
|
this.connectTime = null;
|
|
this.seqNumber = 0;
|
|
this.offsetDataSeqNumber = 0;
|
|
this.videoSeqNumber = 0;
|
|
this.p2pDataSeqNumber = 0;
|
|
this.connectAddress = undefined;
|
|
this.customDataStaging = {};
|
|
this.encryption = types_1.EncryptionType.NONE;
|
|
this.p2pKey = undefined;
|
|
this.lockAESKeys.clear();
|
|
this._clearMessageStateTimeouts();
|
|
this._clearMessageVideoStateTimeouts();
|
|
this.messageStates.clear();
|
|
this.messageVideoStates.clear();
|
|
this.p2pSeqMapping.clear();
|
|
for (let datatype = 0; datatype < 4; datatype++) {
|
|
this.expectedSeqNo[datatype] = 0;
|
|
if (datatype === types_1.P2PDataType.VIDEO)
|
|
rsaKey = (0, utils_1.getNewRSAPrivateKey)(this.enableEmbeddedPKCS1Support);
|
|
else
|
|
rsaKey = null;
|
|
this.initializeMessageBuilder(datatype);
|
|
this.initializeMessageState(datatype, rsaKey);
|
|
this.initializeStream(datatype);
|
|
}
|
|
}
|
|
initializeMessageBuilder(datatype) {
|
|
this.currentMessageBuilder[datatype] = {
|
|
header: {
|
|
commandId: 0,
|
|
bytesToRead: 0,
|
|
channel: 0,
|
|
signCode: 0,
|
|
type: 0
|
|
},
|
|
bytesRead: 0,
|
|
messages: {}
|
|
};
|
|
}
|
|
initializeMessageState(datatype, rsaKey = null) {
|
|
this.currentMessageState[datatype] = {
|
|
leftoverData: Buffer.from([]),
|
|
queuedData: new sweet_collections_1.SortedMap((a, b) => a - b),
|
|
rsaKey: rsaKey,
|
|
videoStream: null,
|
|
audioStream: null,
|
|
invalidStream: false,
|
|
p2pStreaming: false,
|
|
p2pStreamNotStarted: true,
|
|
p2pStreamChannel: -1,
|
|
p2pStreamFirstAudioDataReceived: false,
|
|
p2pStreamFirstVideoDataReceived: false,
|
|
p2pStreamMetadata: {
|
|
videoCodec: types_1.VideoCodec.H264,
|
|
videoFPS: 15,
|
|
videoHeight: 1080,
|
|
videoWidth: 1920,
|
|
audioCodec: types_1.AudioCodec.NONE
|
|
},
|
|
rtspStream: {},
|
|
rtspStreaming: {},
|
|
receivedFirstIFrame: false,
|
|
preFrameVideoData: Buffer.from([]),
|
|
p2pTalkback: false,
|
|
p2pTalkbackChannel: -1
|
|
};
|
|
}
|
|
_clearTimeout(timeout) {
|
|
if (!!timeout) {
|
|
clearTimeout(timeout);
|
|
}
|
|
}
|
|
_clearMessageStateTimeouts() {
|
|
for (const message of this.messageStates.values()) {
|
|
this._clearTimeout(message.timeout);
|
|
}
|
|
}
|
|
_clearMessageVideoStateTimeouts() {
|
|
for (const message of this.messageVideoStates.values()) {
|
|
this._clearTimeout(message.timeout);
|
|
}
|
|
}
|
|
_clearHeartbeatTimeout() {
|
|
this._clearTimeout(this.heartbeatTimeout);
|
|
this.heartbeatTimeout = undefined;
|
|
}
|
|
_clearKeepaliveTimeout() {
|
|
this._clearTimeout(this.keepaliveTimeout);
|
|
this.keepaliveTimeout = undefined;
|
|
}
|
|
_clearConnectTimeout() {
|
|
this._clearTimeout(this.connectTimeout);
|
|
this.connectTimeout = undefined;
|
|
}
|
|
_clearLookupTimeout() {
|
|
this._clearTimeout(this.lookupTimeout);
|
|
this.lookupTimeout = undefined;
|
|
}
|
|
_clearLocalLookupRetryTimeout() {
|
|
this._clearTimeout(this.localLookupRetryTimeout);
|
|
this.localLookupRetryTimeout = undefined;
|
|
}
|
|
_clearLookupRetryTimeout() {
|
|
this._clearTimeout(this.lookupRetryTimeout);
|
|
this.lookupRetryTimeout = undefined;
|
|
}
|
|
_clearLookup2RetryTimeout() {
|
|
this._clearTimeout(this.lookup2RetryTimeout);
|
|
this.lookup2RetryTimeout = undefined;
|
|
}
|
|
_clearLookup2Timeout() {
|
|
this._clearTimeout(this.lookup2Timeout);
|
|
this.lookup2Timeout = undefined;
|
|
}
|
|
_clearESDDisconnectTimeout() {
|
|
this._clearTimeout(this.esdDisconnectTimeout);
|
|
this.esdDisconnectTimeout = undefined;
|
|
}
|
|
_clearSecondaryCommandTimeout() {
|
|
this._clearTimeout(this.secondaryCommandTimeout);
|
|
this.secondaryCommandTimeout = undefined;
|
|
}
|
|
async sendMessage(errorSubject, address, msgID, payload) {
|
|
await (0, utils_1.sendMessage)(this.socket, address, msgID, payload).catch((err) => {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`${errorSubject} - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, address: address, msgID: msgID.toString("hex"), payload: payload?.toString("hex") });
|
|
});
|
|
}
|
|
_disconnected() {
|
|
this._clearHeartbeatTimeout();
|
|
this._clearKeepaliveTimeout();
|
|
this._clearLocalLookupRetryTimeout();
|
|
this._clearLookupRetryTimeout();
|
|
this._clearLookup2Timeout();
|
|
this._clearLookupTimeout();
|
|
this._clearConnectTimeout();
|
|
this._clearESDDisconnectTimeout();
|
|
this._clearSecondaryCommandTimeout();
|
|
this._clearMessageStateTimeouts();
|
|
this._clearMessageVideoStateTimeouts();
|
|
if (this.currentMessageState[types_1.P2PDataType.VIDEO].p2pStreaming) {
|
|
this.endStream(types_1.P2PDataType.VIDEO);
|
|
}
|
|
if (this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreaming) {
|
|
this.endStream(types_1.P2PDataType.BINARY);
|
|
}
|
|
for (const channel in this.currentMessageState[types_1.P2PDataType.DATA].rtspStreaming) {
|
|
this.endRTSPStream(Number.parseInt(channel));
|
|
}
|
|
this.sendQueue = this.sendQueue.filter((queue) => queue.p2pCommand.commandType !== types_1.CommandType.CMD_PING && queue.p2pCommand.commandType !== types_1.CommandType.CMD_GET_DEVICE_PING);
|
|
if (this.connected) {
|
|
this.emit("close");
|
|
}
|
|
else if (!this.terminating) {
|
|
this.emit("timeout");
|
|
}
|
|
this._initialize();
|
|
}
|
|
closeEnergySavingDevice() {
|
|
if (this.sendQueue.filter((queue) => queue.p2pCommand.commandType !== types_1.CommandType.CMD_PING && queue.p2pCommand.commandType !== types_1.CommandType.CMD_GET_DEVICE_PING).length === 0 &&
|
|
this.energySavingDevice &&
|
|
!this.isCurrentlyStreaming() &&
|
|
Array.from(this.messageStates.values()).filter((msgState) => msgState.acknowledged === false).length === 0) {
|
|
if (this.esdDisconnectTimeout === undefined) {
|
|
logging_1.rootP2PLogger.debug(`Energy saving device - No more p2p commands to execute or running streams, initiate disconnect timeout in ${this.ESD_DISCONNECT_TIMEOUT} milliseconds...`, { stationSN: this.rawStation.station_sn });
|
|
this.esdDisconnectTimeout = setTimeout(() => {
|
|
this.esdDisconnectTimeout = undefined;
|
|
this.sendMessage(`Closing of connection for battery saving`, this.connectAddress, types_1.RequestMessageType.END);
|
|
logging_1.rootP2PLogger.info(`Initiated closing of connection to station ${this.rawStation.station_sn} for saving battery.`);
|
|
this.terminating = true;
|
|
this._disconnected();
|
|
}, this.ESD_DISCONNECT_TIMEOUT);
|
|
}
|
|
}
|
|
}
|
|
async renewDSKKey() {
|
|
if (this.dskKey === "" || (this.dskExpiration && (new Date()).getTime() >= this.dskExpiration.getTime())) {
|
|
logging_1.rootP2PLogger.debug(`DSK keys not present or expired, get/renew it`, { stationSN: this.rawStation.station_sn, dskKey: this.dskKey, dskExpiration: this.dskExpiration });
|
|
await this.getDSKKeys();
|
|
}
|
|
}
|
|
localLookup(host) {
|
|
logging_1.rootP2PLogger.debug(`Trying to local lookup address for station ${this.rawStation.station_sn} with host ${host}`);
|
|
this.localLookupByAddress({ host: host, port: 32108 });
|
|
this._clearLocalLookupRetryTimeout();
|
|
this.lookupRetryTimeout = setTimeout(() => {
|
|
this.localLookup(host);
|
|
}, this.LOCAL_LOOKUP_RETRY_TIMEOUT);
|
|
}
|
|
cloudLookup() {
|
|
this.cloudAddresses.map((address) => this.cloudLookupByAddress(address));
|
|
this._clearLookupRetryTimeout();
|
|
this.lookupRetryTimeout = setTimeout(() => {
|
|
this.cloudLookup();
|
|
}, this.LOOKUP_RETRY_TIMEOUT);
|
|
}
|
|
cloudLookup2() {
|
|
this.cloudAddresses.map((address) => this.cloudLookupByAddress2(address));
|
|
this._clearLookup2RetryTimeout();
|
|
this.lookup2RetryTimeout = setTimeout(() => {
|
|
this.cloudLookup2();
|
|
}, this.LOOKUP2_RETRY_TIMEOUT);
|
|
}
|
|
cloudLookupWithTurnServer(origAddress, data) {
|
|
this.cloudAddresses.map((address) => this.cloudLookupByAddressWithTurnServer(address, origAddress, data));
|
|
}
|
|
async localLookupByAddress(address) {
|
|
// Send lookup message
|
|
const msgId = types_1.RequestMessageType.LOCAL_LOOKUP;
|
|
const payload = Buffer.from([0, 0]);
|
|
await this.sendMessage(`Local lookup address`, address, msgId, payload);
|
|
}
|
|
async cloudLookupByAddress(address) {
|
|
// Send lookup message
|
|
const msgId = types_1.RequestMessageType.LOOKUP_WITH_KEY;
|
|
const payload = (0, utils_1.buildLookupWithKeyPayload)(this.socket, this.rawStation.p2p_did, this.dskKey);
|
|
await this.sendMessage(`Cloud lookup addresses`, address, msgId, payload);
|
|
}
|
|
async cloudLookupByAddress2(address) {
|
|
// Send lookup message2
|
|
const msgId = types_1.RequestMessageType.LOOKUP_WITH_KEY2;
|
|
const payload = (0, utils_1.buildLookupWithKeyPayload2)(this.rawStation.p2p_did, this.dskKey);
|
|
await this.sendMessage(`Cloud lookup addresses (2)`, address, msgId, payload);
|
|
}
|
|
async cloudLookupByAddressWithTurnServer(address, origAddress, data) {
|
|
// Send lookup message3
|
|
const msgId = types_1.RequestMessageType.TURN_LOOKUP_WITH_KEY;
|
|
const payload = (0, utils_1.buildLookupWithKeyPayload3)(this.rawStation.p2p_did, origAddress, data);
|
|
await this.sendMessage(`Cloud lookup addresses with turn server`, address, msgId, payload);
|
|
}
|
|
isConnected() {
|
|
return this.connected;
|
|
}
|
|
_startConnectTimeout() {
|
|
if (this.connectTimeout === undefined)
|
|
this.connectTimeout = setTimeout(() => {
|
|
logging_1.rootP2PLogger.warn(`Tried all hosts, no connection could be established to station ${this.rawStation.station_sn}.`);
|
|
this._disconnected();
|
|
}, this.MAX_CONNECTION_TIMEOUT);
|
|
}
|
|
_connect(address, p2p_did) {
|
|
logging_1.rootP2PLogger.debug(`Connecting to host ${address.host} on port ${address.port} (CHECK_CAM)`, { stationSN: this.rawStation.station_sn, address: address, p2pDid: p2p_did });
|
|
this.sendCamCheck(address, p2p_did);
|
|
for (let i = address.port - 3; i < address.port; i++)
|
|
this.sendCamCheck({ host: address.host, port: i }, p2p_did);
|
|
for (let i = address.port + 1; i <= address.port + 3; i++)
|
|
this.sendCamCheck({ host: address.host, port: i }, p2p_did);
|
|
this._startConnectTimeout();
|
|
}
|
|
lookup(host) {
|
|
if (host === undefined) {
|
|
if (this.preferredIPAddress !== undefined) {
|
|
host = this.preferredIPAddress;
|
|
}
|
|
else if (this.localIPAddress !== undefined) {
|
|
host = this.localIPAddress;
|
|
}
|
|
else {
|
|
const localIP = (0, utils_1.getLocalIpAddress)();
|
|
host = localIP.substring(0, localIP.lastIndexOf(".") + 1).concat("255");
|
|
}
|
|
}
|
|
this.localLookup(host);
|
|
this.cloudLookup();
|
|
this._clearLookup2Timeout();
|
|
this.lookup2Timeout = setTimeout(() => {
|
|
this.cloudLookup2();
|
|
}, this.LOOKUP2_TIMEOUT);
|
|
this._clearLookupTimeout();
|
|
this.lookupTimeout = setTimeout(() => {
|
|
this.lookupTimeout = undefined;
|
|
logging_1.rootP2PLogger.error(`All address lookup tentatives failed.`, { stationSN: this.rawStation.station_sn });
|
|
if (this.localIPAddress !== undefined)
|
|
this.localIPAddress = undefined;
|
|
this._disconnected();
|
|
}, this.MAX_LOOKUP_TIMEOUT);
|
|
}
|
|
async connect(host) {
|
|
if (!this.connected && !this.connecting && this.rawStation.p2p_did !== undefined) {
|
|
this.connecting = true;
|
|
this.terminating = false;
|
|
await this.renewDSKKey();
|
|
if (!this.binded)
|
|
this.socket.bind(this.listeningPort, () => {
|
|
this.binded = true;
|
|
try {
|
|
this.socket.setRecvBufferSize(this.UDP_RECVBUFFERSIZE_BYTES);
|
|
this.socket.setBroadcast(true);
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`connect - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, host: host, currentRecBufferSize: this.socket.getRecvBufferSize(), recBufferRequestedSize: this.UDP_RECVBUFFERSIZE_BYTES });
|
|
}
|
|
this.lookup(host);
|
|
});
|
|
else {
|
|
this.lookup(host);
|
|
}
|
|
}
|
|
}
|
|
async sendCamCheck(address, p2p_did) {
|
|
const payload = (0, utils_1.buildCheckCamPayload)(p2p_did);
|
|
await this.sendMessage(`Send cam check`, address, types_1.RequestMessageType.CHECK_CAM, payload);
|
|
}
|
|
async sendCamCheck2(address, data) {
|
|
const payload = (0, utils_1.buildCheckCamPayload2)(this.rawStation.p2p_did, data);
|
|
await this.sendMessage(`Send cam check (2)`, address, types_1.RequestMessageType.CHECK_CAM2, payload);
|
|
}
|
|
async sendPing(address) {
|
|
if ((this.lastPong && ((new Date().getTime() - this.lastPong) / this.getHeartbeatInterval() >= this.MAX_RETRIES)) ||
|
|
(this.connectTime && !this.lastPong && ((new Date().getTime() - this.connectTime) / this.getHeartbeatInterval() >= this.MAX_RETRIES))) {
|
|
if (!this.energySavingDevice)
|
|
logging_1.rootP2PLogger.warn(`Heartbeat check failed for station ${this.rawStation.station_sn}. Connection seems lost. Try to reconnect...`);
|
|
this._disconnected();
|
|
}
|
|
await this.sendMessage(`Send ping`, address, types_1.RequestMessageType.PING, this.lastPongData);
|
|
}
|
|
sendCommandWithIntString(p2pcommand, customData) {
|
|
if (p2pcommand.channel === undefined)
|
|
p2pcommand.channel = 0;
|
|
if (p2pcommand.value === undefined || typeof p2pcommand.value !== "number")
|
|
throw new TypeError("value must be a number");
|
|
this.sendCommand(p2pcommand, types_1.InternalP2PCommandType.WithIntString, undefined, customData);
|
|
}
|
|
sendCommandWithInt(p2pcommand, customData) {
|
|
if (p2pcommand.channel === undefined)
|
|
p2pcommand.channel = this.channel;
|
|
if (p2pcommand.value === undefined || typeof p2pcommand.value !== "number")
|
|
throw new TypeError("value must be a number");
|
|
this.sendCommand(p2pcommand, types_1.InternalP2PCommandType.WithInt, undefined, customData);
|
|
}
|
|
sendCommandWithStringPayload(p2pcommand, customData) {
|
|
if (p2pcommand.channel === undefined)
|
|
p2pcommand.channel = 0;
|
|
if (p2pcommand.value === undefined || typeof p2pcommand.value !== "string")
|
|
throw new TypeError("value must be a string");
|
|
let nested_commandType = undefined;
|
|
let nested_commandType2 = undefined;
|
|
logging_1.rootP2PLogger.debug(`sendCommandWithStringPayload:`, { p2pcommand: p2pcommand, customData: customData });
|
|
if (p2pcommand.commandType == types_1.CommandType.CMD_SET_PAYLOAD) {
|
|
try {
|
|
const json = JSON.parse(p2pcommand.value);
|
|
nested_commandType = json.cmd;
|
|
if (json.payload && json.payload.apiCommand !== undefined) {
|
|
nested_commandType2 = json.payload.apiCommand;
|
|
}
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`sendCommandWithStringPayload CMD_SET_PAYLOAD - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, p2pcommand: p2pcommand, customData: customData });
|
|
}
|
|
}
|
|
else if (p2pcommand.commandType == types_1.CommandType.CMD_DOORBELL_SET_PAYLOAD) {
|
|
try {
|
|
const json = JSON.parse(p2pcommand.value);
|
|
nested_commandType = json.commandType;
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`sendCommandWithStringPayload CMD_DOORBELL_SET_PAYLOAD - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, p2pcommand: p2pcommand, customData: customData });
|
|
}
|
|
}
|
|
this.sendCommand(p2pcommand, types_1.InternalP2PCommandType.WithStringPayload, nested_commandType, customData, nested_commandType2);
|
|
}
|
|
sendCommandWithString(p2pcommand, customData) {
|
|
if (p2pcommand.channel === undefined)
|
|
p2pcommand.channel = this.channel;
|
|
if (p2pcommand.strValue === undefined)
|
|
throw new TypeError("strValue must be defined");
|
|
if (p2pcommand.strValueSub === undefined)
|
|
throw new TypeError("strValueSub must be defined");
|
|
this.sendCommand(p2pcommand, types_1.InternalP2PCommandType.WithString, p2pcommand.commandType, customData);
|
|
}
|
|
sendCommandPing(channel = this.channel) {
|
|
this.sendCommand({
|
|
commandType: types_1.CommandType.CMD_PING,
|
|
channel: channel
|
|
}, types_1.InternalP2PCommandType.WithoutData);
|
|
}
|
|
sendCommandDevicePing(channel = this.channel) {
|
|
this.sendCommand({
|
|
commandType: types_1.CommandType.CMD_GET_DEVICE_PING,
|
|
channel: channel
|
|
}, types_1.InternalP2PCommandType.WithoutData);
|
|
}
|
|
sendCommandWithoutData(commandType, channel = this.channel) {
|
|
this.sendCommand({
|
|
commandType: commandType,
|
|
channel: channel
|
|
}, types_1.InternalP2PCommandType.WithoutData);
|
|
}
|
|
sendQueuedMessage() {
|
|
if (this.sendQueue.length > 0) {
|
|
if (this.connected) {
|
|
let queuedMessage;
|
|
while ((queuedMessage = this.sendQueue.shift()) !== undefined) {
|
|
let exists = false;
|
|
let waitingAcknowledge = false;
|
|
this.messageStates.forEach(stateMessage => {
|
|
if (stateMessage.commandType === queuedMessage.p2pCommand.commandType && stateMessage.nestedCommandType === queuedMessage.nestedCommandType && !stateMessage.acknowledged) {
|
|
exists = true;
|
|
}
|
|
if (!stateMessage.acknowledged || stateMessage.commandType === types_1.CommandType.CMD_GATEWAYINFO) {
|
|
waitingAcknowledge = true;
|
|
}
|
|
});
|
|
if (!exists && !waitingAcknowledge) {
|
|
this._sendCommand(queuedMessage);
|
|
break;
|
|
}
|
|
else {
|
|
this.sendQueue.unshift(queuedMessage);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (!this.connected && this.sendQueue.filter((queue) => queue.p2pCommand.commandType !== types_1.CommandType.CMD_PING && queue.p2pCommand.commandType !== types_1.CommandType.CMD_GET_DEVICE_PING).length > 0) {
|
|
logging_1.rootP2PLogger.debug(`Initiate station p2p connection to send queued data`, { stationSN: this.rawStation.station_sn, queuedDataCount: this.sendQueue.filter((queue) => queue.p2pCommand.commandType !== types_1.CommandType.CMD_PING && queue.p2pCommand.commandType !== types_1.CommandType.CMD_GET_DEVICE_PING).length });
|
|
this.connect();
|
|
}
|
|
}
|
|
this.closeEnergySavingDevice();
|
|
}
|
|
sendCommand(p2pcommand, p2pcommandType, nestedCommandType, customData, nested_commandType2) {
|
|
const message = {
|
|
p2pCommand: p2pcommand,
|
|
nestedCommandType: nestedCommandType,
|
|
nestedCommandType2: nested_commandType2,
|
|
timestamp: +new Date,
|
|
customData: customData,
|
|
p2pCommandType: p2pcommandType
|
|
};
|
|
this.sendQueue.push(message);
|
|
if (p2pcommand.commandType !== types_1.CommandType.CMD_PING && p2pcommand.commandType !== types_1.CommandType.CMD_GET_DEVICE_PING)
|
|
this._clearESDDisconnectTimeout();
|
|
this.sendQueuedMessage();
|
|
}
|
|
resendNotAcknowledgedCommand(sequence) {
|
|
const messageState = this.messageStates.get(sequence);
|
|
if (messageState) {
|
|
this._clearTimeout(messageState.retryTimeout);
|
|
messageState.retryTimeout = setTimeout(() => {
|
|
if (this.connectAddress) {
|
|
(0, utils_1.sendMessage)(this.socket, this.connectAddress, types_1.RequestMessageType.DATA, messageState.data).catch((err) => {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`resendNotAcknowledgedCommand - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, sequence: sequence });
|
|
});
|
|
this.resendNotAcknowledgedCommand(sequence);
|
|
}
|
|
}, this.RESEND_NOT_ACKNOWLEDGED_COMMAND);
|
|
}
|
|
}
|
|
async _sendCommand(message) {
|
|
if ((0, utils_1.isP2PQueueMessage)(message)) {
|
|
const ageing = +new Date - message.timestamp;
|
|
if (ageing <= this.MAX_COMMAND_QUEUE_TIMEOUT) {
|
|
const commandHeader = (0, utils_1.buildCommandHeader)(this.seqNumber, message.p2pCommand.commandType);
|
|
let payload;
|
|
const channel = message.p2pCommand.channel !== undefined ? message.p2pCommand.channel : 0;
|
|
switch (message.p2pCommandType) {
|
|
case types_1.InternalP2PCommandType.WithInt:
|
|
payload = (0, utils_1.buildIntCommandPayload)(this.encryption, this.p2pKey, this.rawStation.station_sn, this.rawStation.p2p_did, message.p2pCommand.commandType, message.p2pCommand.value, message.p2pCommand.strValue === undefined ? "" : message.p2pCommand.strValue, channel);
|
|
break;
|
|
case types_1.InternalP2PCommandType.WithIntString:
|
|
payload = (0, utils_1.buildIntStringCommandPayload)(this.encryption, this.p2pKey, this.rawStation.station_sn, this.rawStation.p2p_did, message.p2pCommand.commandType, message.p2pCommand.value, message.p2pCommand.valueSub === undefined ? 0 : message.p2pCommand.valueSub, message.p2pCommand.strValue === undefined ? "" : message.p2pCommand.strValue, message.p2pCommand.strValueSub === undefined ? "" : message.p2pCommand.strValueSub, channel);
|
|
//TODO: Check if this "if" can be moved elsewhere
|
|
if (message.p2pCommand.commandType === types_1.CommandType.CMD_NAS_TEST) {
|
|
this.currentMessageState[types_1.P2PDataType.DATA].rtspStream[channel] = message.p2pCommand.value === 1 ? true : false;
|
|
}
|
|
break;
|
|
case types_1.InternalP2PCommandType.WithString:
|
|
payload = (0, utils_1.buildStringTypeCommandPayload)(this.encryption, this.p2pKey, this.rawStation.station_sn, this.rawStation.p2p_did, message.p2pCommand.commandType, message.p2pCommand.strValue, message.p2pCommand.strValueSub, channel);
|
|
break;
|
|
case types_1.InternalP2PCommandType.WithStringPayload:
|
|
payload = (0, utils_1.buildCommandWithStringTypePayload)(this.encryption, this.p2pKey, this.rawStation.station_sn, this.rawStation.p2p_did, message.p2pCommand.commandType, message.p2pCommand.value, channel);
|
|
break;
|
|
default:
|
|
payload = (0, utils_1.buildVoidCommandPayload)(channel);
|
|
break;
|
|
}
|
|
const data = Buffer.concat([commandHeader, payload]);
|
|
const messageState = {
|
|
sequence: this.seqNumber,
|
|
commandType: message.p2pCommand.commandType,
|
|
nestedCommandType: message.nestedCommandType,
|
|
nestedCommandType2: message.nestedCommandType2,
|
|
channel: channel,
|
|
data: data,
|
|
retries: 0,
|
|
acknowledged: false,
|
|
customData: message.customData
|
|
};
|
|
message = messageState;
|
|
this.seqNumber = this._incrementSequence(this.seqNumber);
|
|
}
|
|
else if (message.p2pCommand.commandType === types_1.CommandType.CMD_PING || message.p2pCommand.commandType === types_1.CommandType.CMD_GET_DEVICE_PING) {
|
|
return;
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.warn(`Command aged out from send queue for station ${this.rawStation.station_sn}`, { commandType: message.p2pCommand.commandType, nestedCommandType: message.nestedCommandType, channel: message.p2pCommand.channel, ageing: ageing, maxAgeing: this.MAX_COMMAND_QUEUE_TIMEOUT });
|
|
this.emit("command", {
|
|
command_type: message.nestedCommandType !== undefined ? message.nestedCommandType : message.p2pCommand.commandType,
|
|
channel: message.p2pCommand.channel,
|
|
return_code: types_1.ErrorCode.ERROR_CONNECT_TIMEOUT,
|
|
customData: message.customData
|
|
});
|
|
return;
|
|
}
|
|
}
|
|
else {
|
|
if (message.retries < this.MAX_RETRIES && message.returnCode !== types_1.ErrorCode.ERROR_CONNECT_TIMEOUT) {
|
|
if (message.returnCode === types_1.ErrorCode.ERROR_FAILED_TO_REQUEST) {
|
|
this.messageStates.delete(message.sequence);
|
|
message.sequence = this.seqNumber;
|
|
message.data.writeUInt16BE(message.sequence, 2);
|
|
this.seqNumber = this._incrementSequence(this.seqNumber);
|
|
this.messageStates.set(message.sequence, message);
|
|
}
|
|
message.retries++;
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.error(`Max p2p command send retries reached.`, { stationSN: this.rawStation.station_sn, sequence: message.sequence, commandType: message.commandType, channel: message.channel, retries: message.retries, returnCode: message.returnCode });
|
|
this.emit("command", {
|
|
command_type: message.nestedCommandType !== undefined ? message.nestedCommandType : message.commandType,
|
|
channel: message.channel,
|
|
return_code: types_1.ErrorCode.ERROR_COMMAND_TIMEOUT,
|
|
customData: message.customData
|
|
});
|
|
if (message.commandType === types_1.CommandType.CMD_START_REALTIME_MEDIA ||
|
|
(message.nestedCommandType === types_1.CommandType.CMD_START_REALTIME_MEDIA && message.commandType === types_1.CommandType.CMD_SET_PAYLOAD) ||
|
|
message.commandType === types_1.CommandType.CMD_RECORD_VIEW ||
|
|
(message.nestedCommandType === http_1.ParamType.COMMAND_START_LIVESTREAM && message.commandType === types_1.CommandType.CMD_DOORBELL_SET_PAYLOAD)) {
|
|
if (this.currentMessageState[types_1.P2PDataType.VIDEO].p2pStreaming && message.channel === this.currentMessageState[types_1.P2PDataType.VIDEO].p2pStreamChannel) {
|
|
this.endStream(types_1.P2PDataType.VIDEO);
|
|
}
|
|
}
|
|
else if (message.commandType === types_1.CommandType.CMD_DOWNLOAD_VIDEO) {
|
|
if (this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreaming && message.channel === this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreamChannel) {
|
|
this.endStream(types_1.P2PDataType.BINARY);
|
|
}
|
|
}
|
|
this.messageStates.delete(message.sequence);
|
|
this.sendQueuedMessage();
|
|
return;
|
|
}
|
|
}
|
|
const messageState = message;
|
|
messageState.timeout = setTimeout(() => {
|
|
this._clearTimeout(messageState.retryTimeout);
|
|
this._sendCommand(messageState);
|
|
this._clearESDDisconnectTimeout();
|
|
this.closeEnergySavingDevice();
|
|
}, this.MAX_AKNOWLEDGE_TIMEOUT);
|
|
this.messageStates.set(messageState.sequence, messageState);
|
|
messageState.retryTimeout = setTimeout(() => {
|
|
this.resendNotAcknowledgedCommand(messageState.sequence);
|
|
}, this.RESEND_NOT_ACKNOWLEDGED_COMMAND);
|
|
if (messageState.commandType !== types_1.CommandType.CMD_PING) {
|
|
this.p2pSeqMapping.set(this.p2pDataSeqNumber, message.sequence);
|
|
logging_1.rootP2PLogger.trace(`Added sequence number mapping`, { stationSN: this.rawStation.station_sn, commandType: message.commandType, seqNumber: message.sequence, p2pDataSeqNumber: this.p2pDataSeqNumber, p2pSeqMappingCount: this.p2pSeqMapping.size });
|
|
this.p2pDataSeqNumber = this._incrementSequence(this.p2pDataSeqNumber);
|
|
}
|
|
logging_1.rootP2PLogger.debug("Sending p2p command...", { station: this.rawStation.station_sn, sequence: messageState.sequence, commandType: messageState.commandType, channel: messageState.channel, retries: messageState.retries, messageStatesSize: this.messageStates.size });
|
|
await this.sendMessage(`Send p2p command`, this.connectAddress, types_1.RequestMessageType.DATA, messageState.data);
|
|
if (messageState.retries === 0) {
|
|
if (messageState.commandType === types_1.CommandType.CMD_START_REALTIME_MEDIA ||
|
|
(messageState.nestedCommandType === types_1.CommandType.CMD_START_REALTIME_MEDIA && messageState.commandType === types_1.CommandType.CMD_SET_PAYLOAD) ||
|
|
messageState.commandType === types_1.CommandType.CMD_RECORD_VIEW ||
|
|
(messageState.nestedCommandType === http_1.ParamType.COMMAND_START_LIVESTREAM && messageState.commandType === types_1.CommandType.CMD_DOORBELL_SET_PAYLOAD)) {
|
|
if (this.currentMessageState[types_1.P2PDataType.VIDEO].p2pStreaming && messageState.channel !== this.currentMessageState[types_1.P2PDataType.VIDEO].p2pStreamChannel) {
|
|
this.endStream(types_1.P2PDataType.VIDEO);
|
|
}
|
|
this.currentMessageState[types_1.P2PDataType.VIDEO].p2pStreaming = true;
|
|
this.currentMessageState[types_1.P2PDataType.VIDEO].p2pStreamChannel = messageState.channel;
|
|
this.waitForStreamData(types_1.P2PDataType.VIDEO);
|
|
}
|
|
else if (messageState.commandType === types_1.CommandType.CMD_DOWNLOAD_VIDEO) {
|
|
if (this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreaming && messageState.channel !== this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreamChannel) {
|
|
this.endStream(types_1.P2PDataType.BINARY);
|
|
}
|
|
this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreaming = true;
|
|
this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreamChannel = message.channel;
|
|
this.waitForStreamData(types_1.P2PDataType.BINARY);
|
|
}
|
|
else if (messageState.commandType === types_1.CommandType.CMD_STOP_REALTIME_MEDIA) { //TODO: CommandType.CMD_RECORD_PLAY_CTRL only if stop
|
|
this.endStream(types_1.P2PDataType.VIDEO);
|
|
}
|
|
else if (messageState.commandType === types_1.CommandType.CMD_DOWNLOAD_CANCEL) {
|
|
this.endStream(types_1.P2PDataType.BINARY);
|
|
}
|
|
else if (messageState.commandType === types_1.CommandType.CMD_NAS_TEST) {
|
|
if (this.currentMessageState[types_1.P2PDataType.DATA].rtspStream[messageState.channel]) {
|
|
this.currentMessageState[types_1.P2PDataType.DATA].rtspStreaming[messageState.channel] = true;
|
|
this.emit("rtsp livestream started", messageState.channel);
|
|
}
|
|
else {
|
|
this.endRTSPStream(messageState.channel);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
handleMsg(msg, rinfo) {
|
|
if ((0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.LOCAL_LOOKUP_RESP)) {
|
|
if (!this.connected) {
|
|
this._clearLookupTimeout();
|
|
this._clearLocalLookupRetryTimeout();
|
|
const p2pDid = `${msg.subarray(4, 12).toString("utf8").replace(/[\0]+$/g, "")}-${msg.subarray(12, 16).readUInt32BE().toString().padStart(6, "0")}-${msg.subarray(16, 24).toString("utf8").replace(/[\0]+$/g, "")}`;
|
|
logging_1.rootP2PLogger.trace(`Received message - LOCAL_LOOKUP_RESP - Got response`, { stationSN: this.rawStation.station_sn, ip: rinfo.address, port: rinfo.port, p2pDid: p2pDid });
|
|
if (p2pDid === this.rawStation.p2p_did) {
|
|
logging_1.rootP2PLogger.debug(`Received message - LOCAL_LOOKUP_RESP - Wanted device was found, connect to it`, { stationSN: this.rawStation.station_sn, ip: rinfo.address, port: rinfo.port, p2pDid: p2pDid });
|
|
this._connect({ host: rinfo.address, port: rinfo.port }, p2pDid);
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.debug(`Received message - LOCAL_LOOKUP_RESP - Unwanted device was found, don't connect to it`, { stationSN: this.rawStation.station_sn, ip: rinfo.address, port: rinfo.port, p2pDid: p2pDid });
|
|
}
|
|
}
|
|
}
|
|
else if ((0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.LOOKUP_ADDR)) {
|
|
if (!this.connected) {
|
|
const port = msg.subarray(6, 8).readUInt16LE();
|
|
const ip = `${msg[11]}.${msg[10]}.${msg[9]}.${msg[8]}`;
|
|
logging_1.rootP2PLogger.trace(`Received message - LOOKUP_ADDR - Got response`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, response: { ip: ip, port: port } });
|
|
if (ip === "0.0.0.0") {
|
|
logging_1.rootP2PLogger.trace(`Received message - LOOKUP_ADDR - Got invalid ip address 0.0.0.0, ignoring response...`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, response: { ip: ip, port: port } });
|
|
return;
|
|
}
|
|
if ((0, utils_1.isPrivateIp)(ip))
|
|
this.localIPAddress = ip;
|
|
if (this.connectionType === types_1.P2PConnectionType.ONLY_LOCAL) {
|
|
if ((0, utils_1.isPrivateIp)(ip)) {
|
|
this._clearLookupTimeout();
|
|
this._clearLookupRetryTimeout();
|
|
logging_1.rootP2PLogger.debug(`Trying to connect in ONLY_LOCAL mode...`, { stationSN: this.rawStation.station_sn, ip: ip, port: port });
|
|
this._connect({ host: ip, port: port }, this.rawStation.p2p_did);
|
|
}
|
|
}
|
|
else if (this.connectionType === types_1.P2PConnectionType.QUICKEST) {
|
|
this._clearLookupTimeout();
|
|
this._clearLookupRetryTimeout();
|
|
logging_1.rootP2PLogger.debug(`Trying to connect in QUICKEST mode...`, { stationSN: this.rawStation.station_sn, ip: ip, port: port });
|
|
this._connect({ host: ip, port: port }, this.rawStation.p2p_did);
|
|
}
|
|
}
|
|
}
|
|
else if ((0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.CAM_ID) || (0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.TURN_SERVER_CAM_ID)) {
|
|
// Answer from the device to a CAM_CHECK message
|
|
if (!this.connected) {
|
|
logging_1.rootP2PLogger.debug(`Received message - CAM_ID - Connected to station ${this.rawStation.station_sn} on host ${rinfo.address} port ${rinfo.port}`);
|
|
this._clearLocalLookupRetryTimeout();
|
|
this._clearLookupRetryTimeout();
|
|
this._clearLookup2RetryTimeout();
|
|
this._clearLookupTimeout();
|
|
this._clearConnectTimeout();
|
|
this._clearLookup2Timeout();
|
|
this.connected = true;
|
|
this.connectTime = new Date().getTime();
|
|
this.lastPong = null;
|
|
this.lastPongData = undefined;
|
|
this.connectAddress = { host: rinfo.address, port: rinfo.port };
|
|
if ((0, utils_1.isPrivateIp)(rinfo.address))
|
|
this.localIPAddress = rinfo.address;
|
|
this.scheduleHeartbeat();
|
|
if (device_1.Device.isSmartSafe(this.rawStation.device_type)) {
|
|
const payload = (0, utils_1.buildVoidCommandPayload)(http_1.Station.CHANNEL);
|
|
const data = Buffer.concat([(0, utils_1.buildCommandHeader)(this.seqNumber, types_1.CommandType.CMD_GATEWAYINFO), payload]);
|
|
const message = {
|
|
sequence: this.seqNumber,
|
|
commandType: types_1.CommandType.CMD_GATEWAYINFO,
|
|
channel: http_1.Station.CHANNEL,
|
|
data: data,
|
|
retries: 0,
|
|
acknowledged: false,
|
|
};
|
|
this.messageStates.set(message.sequence, message);
|
|
message.retryTimeout = setTimeout(() => {
|
|
this.resendNotAcknowledgedCommand(message.sequence);
|
|
}, this.RESEND_NOT_ACKNOWLEDGED_COMMAND);
|
|
this.seqNumber = this._incrementSequence(this.seqNumber);
|
|
this.sendMessage(`Send smartsafe gateway command to station`, this.connectAddress, types_1.RequestMessageType.DATA, data);
|
|
const tmpSendQueue = [...this.sendQueue];
|
|
this.sendQueue = [];
|
|
this.sendCommandPing(http_1.Station.CHANNEL);
|
|
tmpSendQueue.forEach(element => {
|
|
this.sendQueue.push(element);
|
|
});
|
|
}
|
|
else if (device_1.Device.isLockWifiR10(this.rawStation.device_type) || device_1.Device.isLockWifiR20(this.rawStation.device_type)) {
|
|
const tmpSendQueue = [...this.sendQueue];
|
|
this.sendQueue = [];
|
|
const payload = (0, utils_1.buildVoidCommandPayload)(http_1.Station.CHANNEL);
|
|
const data = Buffer.concat([(0, utils_1.buildCommandHeader)(0, types_1.CommandType.CMD_GATEWAYINFO), payload.subarray(0, payload.length - 2), (0, utils_1.buildCommandHeader)(0, types_1.CommandType.CMD_PING).subarray(2), payload]);
|
|
const message = {
|
|
sequence: this.seqNumber,
|
|
commandType: types_1.CommandType.CMD_PING,
|
|
channel: http_1.Station.CHANNEL,
|
|
data: data,
|
|
retries: 0,
|
|
acknowledged: false,
|
|
};
|
|
this.messageStates.set(message.sequence, message);
|
|
message.retryTimeout = setTimeout(() => {
|
|
this.resendNotAcknowledgedCommand(message.sequence);
|
|
}, this.RESEND_NOT_ACKNOWLEDGED_COMMAND);
|
|
this.seqNumber = this._incrementSequence(this.seqNumber);
|
|
this.sendMessage(`Send lock wifi gateway v12 command to station`, this.connectAddress, types_1.RequestMessageType.DATA, data);
|
|
tmpSendQueue.forEach(element => {
|
|
this.sendQueue.push(element);
|
|
});
|
|
}
|
|
else if (this.rawStation.devices !== undefined && this.rawStation.devices !== null && this.rawStation.devices.length !== undefined && this.rawStation.devices.length > 0 && device_1.Device.isLockWifiVideo(this.rawStation.devices[0]?.device_type)) {
|
|
const tmpSendQueue = [...this.sendQueue];
|
|
this.sendQueue = [];
|
|
const payload = (0, utils_1.buildVoidCommandPayload)(http_1.Station.CHANNEL);
|
|
const data = Buffer.concat([(0, utils_1.buildCommandHeader)(0, types_1.CommandType.CMD_GATEWAYINFO), payload.subarray(0, payload.length - 2), (0, utils_1.buildCommandHeader)(0, types_1.CommandType.CMD_PING).subarray(2), payload]);
|
|
const message = {
|
|
sequence: this.seqNumber,
|
|
commandType: types_1.CommandType.CMD_PING,
|
|
channel: http_1.Station.CHANNEL,
|
|
data: data,
|
|
retries: 0,
|
|
acknowledged: false,
|
|
};
|
|
this.messageStates.set(message.sequence, message);
|
|
message.retryTimeout = setTimeout(() => {
|
|
this.resendNotAcknowledgedCommand(message.sequence);
|
|
}, this.RESEND_NOT_ACKNOWLEDGED_COMMAND);
|
|
this.seqNumber = this._incrementSequence(this.seqNumber);
|
|
this.sendMessage(`Send lock wifi gateway command to station`, this.connectAddress, types_1.RequestMessageType.DATA, data);
|
|
tmpSendQueue.forEach(element => {
|
|
this.sendQueue.push(element);
|
|
});
|
|
}
|
|
else {
|
|
const tmpSendQueue = [...this.sendQueue];
|
|
this.sendQueue = [];
|
|
this.sendCommandWithoutData(types_1.CommandType.CMD_GATEWAYINFO, http_1.Station.CHANNEL);
|
|
tmpSendQueue.forEach(element => {
|
|
this.sendQueue.push(element);
|
|
});
|
|
}
|
|
this.sendQueuedMessage();
|
|
if (this.energySavingDevice) {
|
|
this.scheduleP2PKeepalive();
|
|
}
|
|
this.emit("connect", this.connectAddress);
|
|
}
|
|
}
|
|
else if ((0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.PONG)) {
|
|
// Response to a ping from our side
|
|
this.lastPong = new Date().getTime();
|
|
if (msg.length > 4)
|
|
this.lastPongData = msg.subarray(4);
|
|
else
|
|
this.lastPongData = undefined;
|
|
return;
|
|
}
|
|
else if ((0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.PING)) {
|
|
// Response with PONG to keep alive
|
|
this.sendMessage(`Send pong`, { host: rinfo.address, port: rinfo.port }, types_1.RequestMessageType.PONG);
|
|
return;
|
|
}
|
|
else if ((0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.END)) {
|
|
// Connection is closed by device
|
|
logging_1.rootP2PLogger.debug(`Received message - END`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port });
|
|
this.onClose();
|
|
return;
|
|
}
|
|
else if ((0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.ACK)) {
|
|
// Device ACK a message from our side
|
|
// Number of Acks sended in the message
|
|
const dataTypeBuffer = msg.subarray(4, 6);
|
|
const dataType = this.getDataType(dataTypeBuffer);
|
|
const numAcksBuffer = msg.subarray(6, 8);
|
|
const numAcks = numAcksBuffer.readUIntBE(0, numAcksBuffer.length);
|
|
for (let i = 1; i <= numAcks; i++) {
|
|
const idx = 6 + i * 2;
|
|
const seqBuffer = msg.subarray(idx, idx + 2);
|
|
const ackedSeqNo = seqBuffer.readUIntBE(0, seqBuffer.length);
|
|
// -> Message with seqNo was received at the station
|
|
logging_1.rootP2PLogger.trace(`Received message - ACK ${types_1.P2PDataType[dataType]} - sequence ${ackedSeqNo}`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, ackedSeqNo: ackedSeqNo, dataType: types_1.P2PDataType[dataType] });
|
|
if (dataType === types_1.P2PDataType.DATA) {
|
|
const msg_state = this.messageStates.get(ackedSeqNo);
|
|
if (msg_state && !msg_state.acknowledged) {
|
|
this._clearTimeout(msg_state.retryTimeout);
|
|
this._clearTimeout(msg_state.timeout);
|
|
if (msg_state.commandType === types_1.CommandType.CMD_PING || msg_state.commandType === types_1.CommandType.CMD_GET_DEVICE_PING) {
|
|
this.messageStates.delete(ackedSeqNo);
|
|
this.sendQueuedMessage();
|
|
}
|
|
else {
|
|
msg_state.acknowledged = true;
|
|
msg_state.timeout = setTimeout(() => {
|
|
//TODO: Retry command in these case?
|
|
if (msg_state.commandType !== types_1.CommandType.CMD_GATEWAYINFO) {
|
|
logging_1.rootP2PLogger.warn(`Result data for command not received`, { stationSN: this.rawStation.station_sn, message: { sequence: msg_state.sequence, commandType: msg_state.commandType, nestedCommandType: msg_state.nestedCommandType, channel: msg_state.channel, acknowledged: msg_state.acknowledged, retries: msg_state.retries, returnCode: msg_state.returnCode, data: msg_state.data } });
|
|
this.emit("command", {
|
|
command_type: msg_state.nestedCommandType !== undefined ? msg_state.nestedCommandType : msg_state.commandType,
|
|
channel: msg_state.channel,
|
|
return_code: types_1.ErrorCode.ERROR_COMMAND_TIMEOUT,
|
|
customData: msg_state.customData
|
|
});
|
|
}
|
|
else {
|
|
this.p2pSeqMapping.forEach((value, key, map) => {
|
|
if (value === ackedSeqNo) {
|
|
map.delete(key);
|
|
}
|
|
});
|
|
this.p2pDataSeqNumber--;
|
|
logging_1.rootP2PLogger.debug(`Result data for command CMD_GATEWAYINFO not received`, { stationSN: this.rawStation.station_sn, message: { sequence: msg_state.sequence, commandType: msg_state.commandType, nestedCommandType: msg_state.nestedCommandType, channel: msg_state.channel, acknowledged: msg_state.acknowledged, retries: msg_state.retries, returnCode: msg_state.returnCode, data: msg_state.data } });
|
|
}
|
|
this.messageStates.delete(ackedSeqNo);
|
|
this.sendQueuedMessage();
|
|
}, msg_state.commandType !== types_1.CommandType.CMD_GATEWAYINFO ? this.MAX_COMMAND_RESULT_WAIT : this.MAX_GATEWAY_COMMAND_RESULT_WAIT);
|
|
this.messageStates.set(ackedSeqNo, msg_state);
|
|
this.sendQueuedMessage();
|
|
}
|
|
}
|
|
}
|
|
else if (dataType === types_1.P2PDataType.VIDEO) {
|
|
const msg_state = this.messageVideoStates.get(ackedSeqNo);
|
|
if (msg_state) {
|
|
this._clearTimeout(msg_state.timeout);
|
|
this.messageVideoStates.delete(ackedSeqNo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if ((0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.DATA)) {
|
|
if (this.connected) {
|
|
const seqNo = msg.subarray(6, 8).readUInt16BE();
|
|
const dataTypeBuffer = msg.subarray(4, 6);
|
|
const dataType = this.getDataType(dataTypeBuffer);
|
|
const message = {
|
|
bytesToRead: msg.subarray(2, 4).readUInt16BE(),
|
|
type: dataType,
|
|
seqNo: seqNo,
|
|
data: msg.subarray(8)
|
|
};
|
|
this.sendAck({ host: rinfo.address, port: rinfo.port }, dataTypeBuffer, seqNo);
|
|
logging_1.rootP2PLogger.debug(`Received message - DATA ${types_1.P2PDataType[message.type]} - Processing sequence ${message.seqNo}...`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, dataType: types_1.P2PDataType[message.type], seqNo: message.seqNo });
|
|
if (message.seqNo === this.expectedSeqNo[dataType]) {
|
|
// expected seq packet arrived
|
|
const timeout = this.currentMessageState[dataType].waitForSeqNoTimeout;
|
|
if (!!timeout) {
|
|
clearTimeout(timeout);
|
|
this.currentMessageState[dataType].waitForSeqNoTimeout = undefined;
|
|
}
|
|
this.expectedSeqNo[dataType] = this._incrementSequence(this.expectedSeqNo[dataType]);
|
|
this.parseDataMessage(message);
|
|
logging_1.rootP2PLogger.trace(`Received message - DATA ${types_1.P2PDataType[message.type]} - Received expected sequence`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, dataType: types_1.P2PDataType[message.type], seqNo: message.seqNo, expectedSeqNo: this.expectedSeqNo[dataType], queuedDataSize: this.currentMessageState[dataType].queuedData.size });
|
|
let queuedMessage = this.currentMessageState[dataType].queuedData.get(this.expectedSeqNo[dataType]);
|
|
while (queuedMessage) {
|
|
logging_1.rootP2PLogger.trace(`Received message - DATA ${types_1.P2PDataType[queuedMessage.type]} - Work off queued data`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, dataType: types_1.P2PDataType[message.type], seqNo: queuedMessage.seqNo, expectedSeqNo: this.expectedSeqNo[dataType], queuedDataSize: this.currentMessageState[dataType].queuedData.size });
|
|
this.expectedSeqNo[dataType] = this._incrementSequence(this.expectedSeqNo[dataType]);
|
|
this.parseDataMessage(queuedMessage);
|
|
this.currentMessageState[dataType].queuedData.delete(queuedMessage.seqNo);
|
|
queuedMessage = this.currentMessageState[dataType].queuedData.get(this.expectedSeqNo[dataType]);
|
|
}
|
|
}
|
|
else if (this._wasSequenceNumberAlreadyProcessed(this.expectedSeqNo[dataType], message.seqNo)) {
|
|
// We have already seen this message, skip!
|
|
// This can happen because the device is sending the message till it gets a ACK
|
|
// which can take some time.
|
|
logging_1.rootP2PLogger.trace(`Received message - DATA ${types_1.P2PDataType[message.type]} - Received already processed sequence`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, dataType: types_1.P2PDataType[message.type], seqNo: message.seqNo, expectedSeqNo: this.expectedSeqNo[dataType], queuedDataSize: this.currentMessageState[dataType].queuedData.size });
|
|
return;
|
|
}
|
|
else {
|
|
if (!this.currentMessageState[dataType].waitForSeqNoTimeout)
|
|
this.currentMessageState[dataType].waitForSeqNoTimeout = setTimeout(() => {
|
|
this.endStream(dataType, true);
|
|
this.currentMessageState[dataType].waitForSeqNoTimeout = undefined;
|
|
}, this.MAX_EXPECTED_SEQNO_WAIT);
|
|
if (!this.currentMessageState[dataType].queuedData.get(message.seqNo)) {
|
|
this.currentMessageState[dataType].queuedData.set(message.seqNo, message);
|
|
logging_1.rootP2PLogger.trace(`Received message - DATA ${types_1.P2PDataType[message.type]} - Received not expected sequence, added to the queue for future processing`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, dataType: types_1.P2PDataType[message.type], seqNo: message.seqNo, expectedSeqNo: this.expectedSeqNo[dataType], queuedDataSize: this.currentMessageState[dataType].queuedData.size });
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.trace(`Received message - DATA ${types_1.P2PDataType[message.type]} - Received not expected sequence, discarded since already present in queue for future processing`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, dataType: types_1.P2PDataType[message.type], seqNo: message.seqNo, expectedSeqNo: this.expectedSeqNo[dataType], queuedDataSize: this.currentMessageState[dataType].queuedData.size });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if ((0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.LOOKUP_ADDR2)) {
|
|
if (!this.connected) {
|
|
const port = msg.subarray(6, 8).readUInt16LE();
|
|
const ip = `${msg[11]}.${msg[10]}.${msg[9]}.${msg[8]}`;
|
|
const data = msg.subarray(20, 24);
|
|
this._clearLookupTimeout();
|
|
this._clearLookupRetryTimeout();
|
|
this._clearLookup2RetryTimeout();
|
|
logging_1.rootP2PLogger.trace(`Received message - LOOKUP_ADDR2 - Got response`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, response: { ip: ip, port: port, data: data.toString("hex") } });
|
|
logging_1.rootP2PLogger.debug(`Connecting to host ${ip} on port ${port} (CHECK_CAM2)...`, { stationSN: this.rawStation.station_sn, ip: ip, port: port, data: data.toString("hex") });
|
|
for (let i = 0; i < 4; i++)
|
|
this.sendCamCheck2({ host: ip, port: port }, data);
|
|
this._startConnectTimeout();
|
|
if (this.p2pTurnHandshaking[ip] === undefined) {
|
|
this.p2pTurnHandshaking[ip] = true;
|
|
this.sendMessage(`Send TURN_SERVER_INIT`, { host: ip, port: port }, types_1.RequestMessageType.TURN_SERVER_INIT);
|
|
}
|
|
}
|
|
}
|
|
else if ((0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.TURN_SERVER_OK)) {
|
|
if (!this.connected && !this.p2pTurnConfirmed) {
|
|
logging_1.rootP2PLogger.trace(`Received message - TURN_SERVER_OK - Got response`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, response: { message: msg.toString("hex"), length: msg.length } });
|
|
this.sendMessage(`Send TURN_CLIENT_OK`, { host: rinfo.address, port: rinfo.port }, types_1.RequestMessageType.TURN_CLIENT_OK);
|
|
this.p2pTurnConfirmed = true;
|
|
}
|
|
}
|
|
else if ((0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.TURN_SERVER_TOKEN)) {
|
|
if (!this.connected) {
|
|
const ip = `${msg[7]}.${msg[6]}.${msg[5]}.${msg[4]}`;
|
|
const port = msg.subarray(8, 10).readUInt16BE();
|
|
const binaryIP = msg.subarray(4, 8);
|
|
logging_1.rootP2PLogger.debug(`Connecting to host ${ip} on port ${port} (CHECK_CAM2)...`, { stationSN: this.rawStation.station_sn, ip: ip, port: port, binaryIP: binaryIP.toString("hex") });
|
|
for (let i = 0; i < 4; i++)
|
|
this.sendCamCheck2({ host: rinfo.address, port: port }, binaryIP);
|
|
logging_1.rootP2PLogger.trace(`Received message - TURN_SERVER_TOKEN - Got response`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, response: { port: port, binaryIP: binaryIP.toString("hex") } });
|
|
this.cloudLookupWithTurnServer({ host: rinfo.address, port: port }, binaryIP);
|
|
}
|
|
}
|
|
else if ((0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.TURN_SERVER_LOOKUP_OK) || (0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.UNKNOWN_83) || (0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.TURN_SERVER_LIST)) {
|
|
// Do nothing / ignore
|
|
}
|
|
else if ((0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.LOOKUP_RESP)) {
|
|
if (!this.connected) {
|
|
const responseCode = msg.subarray(4, 6).readUInt16LE();
|
|
logging_1.rootP2PLogger.trace(`Received message - LOOKUP_RESP - Got response`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, response: { responseCode: responseCode } });
|
|
}
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.debug(`Received unknown message`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, response: { message: msg.toString("hex"), length: msg.length } });
|
|
}
|
|
}
|
|
parseDataMessage(message) {
|
|
if ((message.type === types_1.P2PDataType.BINARY || message.type === types_1.P2PDataType.VIDEO) && !this.currentMessageState[message.type].p2pStreaming) {
|
|
logging_1.rootP2PLogger.trace(`Parsing message - DATA ${types_1.P2PDataType[message.type]} - Stream not started ignore this data`, { stationSN: this.rawStation.station_sn, seqNo: message.seqNo, header: this.currentMessageBuilder[message.type].header, bytesRead: this.currentMessageBuilder[message.type].bytesRead, bytesToRead: message.bytesToRead, messageSize: message.data.length });
|
|
}
|
|
else {
|
|
if (this.currentMessageState[message.type].leftoverData.length > 0) {
|
|
message.data = Buffer.concat([this.currentMessageState[message.type].leftoverData, message.data]);
|
|
this.currentMessageState[message.type].leftoverData = Buffer.from([]);
|
|
}
|
|
let data = message.data;
|
|
let runaway_limit = 0;
|
|
do {
|
|
// is this the first message?
|
|
const firstPartMessage = data.subarray(0, 4).toString() === utils_1.MAGIC_WORD;
|
|
if (firstPartMessage) {
|
|
const header = {
|
|
commandId: 0,
|
|
bytesToRead: 0,
|
|
channel: 0,
|
|
signCode: 0,
|
|
type: 0
|
|
};
|
|
header.commandId = data.subarray(4, 6).readUIntLE(0, 2);
|
|
header.bytesToRead = data.subarray(6, 10).readUIntLE(0, 4);
|
|
header.channel = data.subarray(12, 13).readUInt8();
|
|
header.signCode = data.subarray(13, 14).readUInt8();
|
|
header.type = data.subarray(14, 15).readUInt8();
|
|
this.currentMessageBuilder[message.type].header = header;
|
|
data = data.subarray(this.P2P_DATA_HEADER_BYTES);
|
|
if (data.length >= header.bytesToRead) {
|
|
const payload = data.subarray(0, header.bytesToRead);
|
|
this.currentMessageBuilder[message.type].messages[message.seqNo] = payload;
|
|
this.currentMessageBuilder[message.type].bytesRead = payload.byteLength;
|
|
data = data.subarray(header.bytesToRead);
|
|
if (data.length <= this.P2P_DATA_HEADER_BYTES) {
|
|
this.currentMessageState[message.type].leftoverData = data;
|
|
data = Buffer.from([]);
|
|
}
|
|
}
|
|
else {
|
|
if (data.length <= this.P2P_DATA_HEADER_BYTES) {
|
|
this.currentMessageState[message.type].leftoverData = data;
|
|
}
|
|
else {
|
|
this.currentMessageBuilder[message.type].messages[message.seqNo] = data;
|
|
this.currentMessageBuilder[message.type].bytesRead = data.byteLength;
|
|
}
|
|
data = Buffer.from([]);
|
|
}
|
|
}
|
|
else {
|
|
// finish message and print
|
|
if (this.currentMessageBuilder[message.type].header.bytesToRead - this.currentMessageBuilder[message.type].bytesRead <= data.length) {
|
|
const payload = data.subarray(0, this.currentMessageBuilder[message.type].header.bytesToRead - this.currentMessageBuilder[message.type].bytesRead);
|
|
this.currentMessageBuilder[message.type].messages[message.seqNo] = payload;
|
|
this.currentMessageBuilder[message.type].bytesRead += payload.byteLength;
|
|
data = data.subarray(payload.byteLength);
|
|
if (data.length <= this.P2P_DATA_HEADER_BYTES) {
|
|
this.currentMessageState[message.type].leftoverData = data;
|
|
data = Buffer.from([]);
|
|
}
|
|
}
|
|
else {
|
|
if (data.length <= this.P2P_DATA_HEADER_BYTES) {
|
|
this.currentMessageState[message.type].leftoverData = data;
|
|
}
|
|
else {
|
|
this.currentMessageBuilder[message.type].messages[message.seqNo] = data;
|
|
this.currentMessageBuilder[message.type].bytesRead += data.byteLength;
|
|
}
|
|
data = Buffer.from([]);
|
|
}
|
|
}
|
|
logging_1.rootP2PLogger.trace(`Parsing message - DATA ${types_1.P2PDataType[message.type]} - Received data`, { stationSN: this.rawStation.station_sn, seqNo: message.seqNo, header: this.currentMessageBuilder[message.type].header, bytesRead: this.currentMessageBuilder[message.type].bytesRead, bytesToRead: this.currentMessageBuilder[message.type].header.bytesToRead, firstPartMessage: firstPartMessage, messageSize: message.data.length, runaway_limit: runaway_limit });
|
|
if (this.currentMessageBuilder[message.type].bytesRead === this.currentMessageBuilder[message.type].header.bytesToRead) {
|
|
const completeMessage = (0, utils_1.sortP2PMessageParts)(this.currentMessageBuilder[message.type].messages);
|
|
const data_message = {
|
|
...this.currentMessageBuilder[message.type].header,
|
|
seqNo: (message.seqNo + this.offsetDataSeqNumber),
|
|
dataType: message.type,
|
|
data: completeMessage
|
|
};
|
|
this.handleData(data_message);
|
|
this.initializeMessageBuilder(message.type);
|
|
if (data.length > 0 && message.type === types_1.P2PDataType.DATA) {
|
|
logging_1.rootP2PLogger.debug(`Parsing message - DATA ${types_1.P2PDataType[message.type]} - Parsed data`, { stationSN: this.rawStation.station_sn, seqNo: message.seqNo, data_message: data_message, datalen: data.length, data: data.toString("hex"), offsetDataSeqNumber: this.offsetDataSeqNumber, seqNumber: this.seqNumber, p2pDataSeqNumber: this.p2pDataSeqNumber });
|
|
this.offsetDataSeqNumber++;
|
|
}
|
|
}
|
|
runaway_limit++;
|
|
} while ((data.length > 0) && (runaway_limit < this.LOOP_RUNAWAY_LIMIT));
|
|
if (runaway_limit >= this.LOOP_RUNAWAY_LIMIT) {
|
|
logging_1.rootP2PLogger.warn(`Infinite loop detected (limit >= ${this.LOOP_RUNAWAY_LIMIT}) during parsing of p2p message`, { stationSN: this.rawStation.station_sn, seqNo: message.seqNo, dataType: types_1.P2PDataType[message.type], header: this.currentMessageBuilder[message.type].header, bytesRead: this.currentMessageBuilder[message.type].bytesRead, bytesToRead: this.currentMessageBuilder[message.type].header.bytesToRead, message: message.data.toString("hex"), messageSize: message.data.length });
|
|
this.initializeMessageBuilder(message.type);
|
|
}
|
|
}
|
|
}
|
|
handleData(message) {
|
|
if (message.dataType === types_1.P2PDataType.CONTROL) {
|
|
this.handleDataControl(message);
|
|
}
|
|
else if (message.dataType === types_1.P2PDataType.DATA) {
|
|
const commandStr = types_1.CommandType[message.commandId];
|
|
const result_msg = message.type === 1 ? true : false;
|
|
if (result_msg) {
|
|
let return_code = 0;
|
|
let resultData;
|
|
if (message.bytesToRead > 0) {
|
|
if (message.signCode > 0) {
|
|
try {
|
|
message.data = (0, utils_1.decryptP2PData)(message.data, this.p2pKey);
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Decrypt Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
|
|
}
|
|
}
|
|
return_code = message.data.subarray(0, 4).readUInt32LE() | 0;
|
|
resultData = message.data.subarray(4);
|
|
}
|
|
const error_codeStr = types_1.ErrorCode[return_code];
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Received data`, { stationSN: this.rawStation.station_sn, seqNo: message.seqNo, commandIdName: commandStr, commandId: message.commandId, resultCodeName: error_codeStr, resultCode: return_code, resultData: resultData?.toString("hex"), data: message.data.toString("hex"), seqNumber: this.seqNumber, p2pDataSeqNumber: this.p2pDataSeqNumber, offsetDataSeqNumber: this.offsetDataSeqNumber });
|
|
let msg_state = this.messageStates.get(message.seqNo);
|
|
const goodSeqNumber = this.p2pSeqMapping.get(message.seqNo);
|
|
if (goodSeqNumber) {
|
|
this.p2pSeqMapping.delete(message.seqNo);
|
|
msg_state = this.messageStates.get(goodSeqNumber);
|
|
logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Result data received - Detecting correct sequence number`, { stationSN: this.rawStation.station_sn, commandIdName: commandStr, commandId: message.commandId, seqNumber: message.seqNo, newSeqNumber: goodSeqNumber, p2pSeqMappingCount: this.p2pSeqMapping.size });
|
|
message.seqNo = goodSeqNumber;
|
|
}
|
|
if (msg_state) {
|
|
if (msg_state.commandType === message.commandId) {
|
|
this._clearTimeout(msg_state.timeout);
|
|
const command_type = msg_state.nestedCommandType !== undefined ? msg_state.nestedCommandType : msg_state.commandType;
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Result data for command received`, { stationSN: this.rawStation.station_sn, message: { sequence: msg_state.sequence, commandType: msg_state.commandType, nestedCommandType: msg_state.nestedCommandType, channel: msg_state.channel, acknowledged: msg_state.acknowledged, retries: msg_state.retries, returnCode: return_code, data: msg_state.data, customData: msg_state.customData }, resultCodeName: error_codeStr, resultCode: return_code });
|
|
if (return_code === types_1.ErrorCode.ERROR_FAILED_TO_REQUEST) {
|
|
msg_state.returnCode = return_code;
|
|
this._sendCommand(msg_state);
|
|
}
|
|
else {
|
|
if (command_type !== types_1.CommandType.CMD_GATEWAYINFO) {
|
|
this.emit("command", {
|
|
command_type: command_type,
|
|
channel: msg_state.channel,
|
|
return_code: return_code,
|
|
customData: msg_state.customData
|
|
});
|
|
}
|
|
this.messageStates.delete(message.seqNo);
|
|
if (command_type === types_1.CommandType.CMD_SMARTSAFE_SETTINGS || command_type === types_1.CommandType.CMD_SET_PAYLOAD_LOCKV12 || command_type === types_1.CommandType.CMD_TRANSFER_PAYLOAD) {
|
|
if (msg_state.customData) {
|
|
for (const index of Object.keys(this.customDataStaging)) {
|
|
const id = Number.parseInt(index);
|
|
if (new Date().getTime() - this.customDataStaging[id].timestamp > 2 * 60 * 1000) {
|
|
delete this.customDataStaging[id];
|
|
}
|
|
}
|
|
this.customDataStaging[msg_state.nestedCommandType2 ? msg_state.nestedCommandType2 : msg_state.nestedCommandType ? msg_state.nestedCommandType : msg_state.commandType] = {
|
|
channel: msg_state.channel,
|
|
customData: msg_state.customData,
|
|
timestamp: new Date().getTime(),
|
|
};
|
|
}
|
|
this.secondaryCommandTimeout = setTimeout(() => {
|
|
logging_1.rootP2PLogger.warn(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Result data for secondary command not received`, { stationSN: this.rawStation.station_sn, message: { sequence: msg_state.sequence, commandType: msg_state.commandType, nestedCommandType: msg_state.nestedCommandType, channel: msg_state.channel, acknowledged: msg_state.acknowledged, retries: msg_state.retries, returnCode: msg_state.returnCode, data: msg_state.data, customData: msg_state.customData } });
|
|
this.secondaryCommandTimeout = undefined;
|
|
this.emit("secondary command", {
|
|
command_type: msg_state.nestedCommandType !== undefined ? msg_state.nestedCommandType : msg_state.commandType,
|
|
channel: msg_state.channel,
|
|
return_code: types_1.ErrorCode.ERROR_COMMAND_TIMEOUT,
|
|
customData: msg_state.customData
|
|
});
|
|
this._clearESDDisconnectTimeout();
|
|
this.sendQueuedMessage();
|
|
}, this.MAX_COMMAND_RESULT_WAIT);
|
|
}
|
|
else {
|
|
this._clearESDDisconnectTimeout();
|
|
this.sendQueuedMessage();
|
|
}
|
|
if (msg_state.commandType === types_1.CommandType.CMD_START_REALTIME_MEDIA ||
|
|
(msg_state.nestedCommandType === types_1.CommandType.CMD_START_REALTIME_MEDIA && msg_state.commandType === types_1.CommandType.CMD_SET_PAYLOAD) ||
|
|
msg_state.commandType === types_1.CommandType.CMD_RECORD_VIEW ||
|
|
(msg_state.nestedCommandType === http_1.ParamType.COMMAND_START_LIVESTREAM && msg_state.commandType === types_1.CommandType.CMD_DOORBELL_SET_PAYLOAD)) {
|
|
this.waitForStreamData(types_1.P2PDataType.VIDEO, true);
|
|
}
|
|
else if (msg_state.commandType === types_1.CommandType.CMD_DOWNLOAD_VIDEO) {
|
|
this.waitForStreamData(types_1.P2PDataType.BINARY, true);
|
|
}
|
|
else if (msg_state.commandType === types_1.CommandType.CMD_START_TALKBACK || (msg_state.commandType === types_1.CommandType.CMD_DOORBELL_SET_PAYLOAD && msg_state.nestedCommandType === types_1.IndoorSoloSmartdropCommandType.CMD_START_SPEAK)) {
|
|
if (return_code === types_1.ErrorCode.ERROR_PPCS_SUCCESSFUL) {
|
|
this.startTalkback(msg_state.channel);
|
|
}
|
|
else if (return_code === types_1.ErrorCode.ERROR_NOT_FIND_DEV) {
|
|
this.emit("talkback error", msg_state.channel, new error_1.TalkbackError("Someone is responding now.", { context: { station: this.rawStation.station_sn, channel: msg_state.channel } }));
|
|
}
|
|
else if (return_code === types_1.ErrorCode.ERROR_DEV_BUSY) {
|
|
this.emit("talkback error", msg_state.channel, new error_1.TalkbackError("Wait a second, device is busy.", { context: { station: this.rawStation.station_sn, channel: msg_state.channel } }));
|
|
}
|
|
else {
|
|
this.emit("talkback error", msg_state.channel, new error_1.TalkbackError("Connect failed please try again later.", { context: { station: this.rawStation.station_sn, channel: msg_state.channel } }));
|
|
}
|
|
}
|
|
else if (msg_state.commandType === types_1.CommandType.CMD_STOP_TALKBACK || (msg_state.commandType === types_1.CommandType.CMD_DOORBELL_SET_PAYLOAD && msg_state.nestedCommandType === types_1.IndoorSoloSmartdropCommandType.CMD_END_SPEAK)) {
|
|
this.stopTalkback(msg_state.channel);
|
|
}
|
|
else if (msg_state.commandType === types_1.CommandType.CMD_SDINFO_EX && resultData && resultData.length >= 8) {
|
|
const totalCapacity = resultData.subarray(0, 4).readUInt32LE();
|
|
const availableCapacity = resultData.subarray(4, 8).readUInt32LE();
|
|
if (return_code >= -1) {
|
|
this.emit("sd info ex", return_code, totalCapacity, availableCapacity);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
this.messageStates.delete(message.seqNo);
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Expected different command type for received sequencenumber!`, { stationSN: this.rawStation.station_sn, msg_sequence: msg_state.sequence, msg_channel: msg_state.channel, msg_commandType: msg_state.commandType, seqNumber: this.seqNumber, p2pDataSeqNumber: this.p2pDataSeqNumber, offsetDataSeqNumber: this.offsetDataSeqNumber, message: { seqNo: message.seqNo, commandType: types_1.CommandType[message.commandId], channel: message.channel, signCode: message.signCode, data: message.data.toString("hex") } });
|
|
logging_1.rootP2PLogger.warn(`P2P protocol instability detected for station ${this.rawStation.station_sn}. Please reinitialise the connection to solve the problem!`);
|
|
}
|
|
}
|
|
else if (message.commandId !== types_1.CommandType.CMD_PING && message.commandId !== types_1.CommandType.CMD_GET_DEVICE_PING && message.commandId !== types_1.CommandType.CMD_GATEWAYINFO) {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Received unexpected data!`, { stationSN: this.rawStation.station_sn, seqNumber: this.seqNumber, p2pDataSeqNumber: this.p2pDataSeqNumber, offsetDataSeqNumber: this.offsetDataSeqNumber, message: { seqNo: message.seqNo, commandType: types_1.CommandType[message.commandId], channel: message.channel, signCode: message.signCode, data: message.data.toString("hex") } });
|
|
}
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Unsupported response`, { stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, commandType: message.commandId, channel: message.channel, signCode: message.signCode, data: message.data.toString("hex") } });
|
|
}
|
|
}
|
|
else if (message.dataType === types_1.P2PDataType.VIDEO || message.dataType === types_1.P2PDataType.BINARY) {
|
|
this.handleDataBinaryAndVideo(message);
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Not implemented data type`, { stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, commandType: message.commandId, channel: message.channel, signCode: message.signCode, data: message.data.toString("hex") } });
|
|
}
|
|
}
|
|
isIFrame(data, isKeyFrame) {
|
|
if (this.rawStation.station_sn.startsWith("T8410") || this.rawStation.station_sn.startsWith("T8400") || this.rawStation.station_sn.startsWith("T8401") || this.rawStation.station_sn.startsWith("T8411") ||
|
|
this.rawStation.station_sn.startsWith("T8202") || this.rawStation.station_sn.startsWith("T8422") || this.rawStation.station_sn.startsWith("T8424") || this.rawStation.station_sn.startsWith("T8423") ||
|
|
this.rawStation.station_sn.startsWith("T8130") || this.rawStation.station_sn.startsWith("T8131") || this.rawStation.station_sn.startsWith("T8420") || this.rawStation.station_sn.startsWith("T8440") ||
|
|
this.rawStation.station_sn.startsWith("T8171") || this.rawStation.station_sn.startsWith("T8426") ||
|
|
this.rawStation.station_sn.startsWith("T8441") || this.rawStation.station_sn.startsWith("T8442") || (0, utils_1.checkT8420)(this.rawStation.station_sn)) {
|
|
//TODO: Need to add battery doorbells as seen in source => T8210,T8220,T8221,T8222
|
|
return isKeyFrame;
|
|
}
|
|
const iframe = (0, utils_1.isIFrame)(data);
|
|
if (iframe === false) {
|
|
// Fallback
|
|
return isKeyFrame;
|
|
}
|
|
return iframe;
|
|
}
|
|
waitForStreamData(dataType, sendStopCommand = false) {
|
|
if (this.currentMessageState[dataType].p2pStreamingTimeout) {
|
|
clearTimeout(this.currentMessageState[dataType].p2pStreamingTimeout);
|
|
}
|
|
this.currentMessageState[dataType].p2pStreamingTimeout = setTimeout(() => {
|
|
logging_1.rootP2PLogger.info(`Stopping the station stream for the device ${this.deviceSNs[this.currentMessageState[dataType].p2pStreamChannel]?.sn}, because we haven't received any data for ${this.MAX_STREAM_DATA_WAIT / 1000} seconds`);
|
|
this.endStream(dataType, sendStopCommand);
|
|
}, this.MAX_STREAM_DATA_WAIT);
|
|
}
|
|
handleDataBinaryAndVideo(message) {
|
|
if (!this.currentMessageState[message.dataType].invalidStream) {
|
|
switch (message.commandId) {
|
|
case types_1.CommandType.CMD_VIDEO_FRAME:
|
|
this.waitForStreamData(message.dataType, true);
|
|
const videoMetaData = {
|
|
streamType: 0,
|
|
videoSeqNo: 0,
|
|
videoFPS: 15,
|
|
videoWidth: 1920,
|
|
videoHeight: 1080,
|
|
videoTimestamp: 0,
|
|
videoDataLength: 0,
|
|
aesKey: ""
|
|
};
|
|
const data_length = message.data.readUInt32LE();
|
|
const isKeyFrame = message.data.subarray(4, 5).readUInt8() === 1 ? true : false;
|
|
videoMetaData.videoDataLength = message.data.subarray(0, 4).readUInt32LE();
|
|
videoMetaData.streamType = message.data.subarray(5, 6).readUInt8();
|
|
videoMetaData.videoSeqNo = message.data.subarray(6, 8).readUInt16LE();
|
|
videoMetaData.videoFPS = message.data.subarray(8, 10).readUInt16LE();
|
|
videoMetaData.videoWidth = message.data.subarray(10, 12).readUInt16LE();
|
|
videoMetaData.videoHeight = message.data.subarray(12, 14).readUInt16LE();
|
|
videoMetaData.videoTimestamp = message.data.subarray(14, 20).readUIntLE(0, 6);
|
|
let payloadStart = 22;
|
|
if (message.signCode > 0 && data_length >= 128) {
|
|
const key = message.data.subarray(22, 150);
|
|
const rsaKey = this.currentMessageState[message.dataType].rsaKey;
|
|
if (rsaKey) {
|
|
try {
|
|
videoMetaData.aesKey = rsaKey.decrypt(key).toString("hex");
|
|
logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Decrypted AES key`, { stationSN: this.rawStation.station_sn, key: videoMetaData.aesKey });
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.warn(`Error: AES key could not be decrypted! The entire stream is discarded.`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, key: key.toString("hex") });
|
|
this.currentMessageState[message.dataType].invalidStream = true;
|
|
this.emit("livestream error", message.channel, new error_1.LivestreamError("Station AES key could not be decrypted! The entire stream is discarded.", { context: { station: this.rawStation.station_sn } }));
|
|
return;
|
|
}
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.warn(`Private RSA key is missing! Stream could not be decrypted. The entire stream for station ${this.rawStation.station_sn} is discarded.`);
|
|
this.currentMessageState[message.dataType].invalidStream = true;
|
|
this.emit("livestream error", message.channel, new error_1.LivestreamError("Station Private RSA key is missing! Stream could not be decrypted. The entire stream is discarded.", { context: { station: this.rawStation.station_sn } }));
|
|
return;
|
|
}
|
|
payloadStart = 151;
|
|
}
|
|
let video_data;
|
|
if (videoMetaData.aesKey !== "") {
|
|
const encrypted_data = message.data.subarray(payloadStart, payloadStart + 128);
|
|
const unencrypted_data = message.data.subarray(payloadStart + 128, payloadStart + videoMetaData.videoDataLength);
|
|
video_data = Buffer.concat([(0, utils_1.decryptAESData)(videoMetaData.aesKey, encrypted_data), unencrypted_data]);
|
|
}
|
|
else {
|
|
video_data = message.data.subarray(payloadStart, payloadStart + videoMetaData.videoDataLength);
|
|
}
|
|
logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME`, { stationSN: this.rawStation.station_sn, dataSize: message.data.length, metadata: videoMetaData, videoDataSize: video_data.length });
|
|
this.currentMessageState[message.dataType].p2pStreamMetadata.videoFPS = videoMetaData.videoFPS;
|
|
this.currentMessageState[message.dataType].p2pStreamMetadata.videoHeight = videoMetaData.videoHeight;
|
|
this.currentMessageState[message.dataType].p2pStreamMetadata.videoWidth = videoMetaData.videoWidth;
|
|
if (!this.currentMessageState[message.dataType].p2pStreamFirstVideoDataReceived) {
|
|
if (this.rawStation.station_sn.startsWith("T8410") || this.rawStation.station_sn.startsWith("T8400") || this.rawStation.station_sn.startsWith("T8401") || this.rawStation.station_sn.startsWith("T8411") ||
|
|
this.rawStation.station_sn.startsWith("T8202") || this.rawStation.station_sn.startsWith("T8422") || this.rawStation.station_sn.startsWith("T8424") || this.rawStation.station_sn.startsWith("T8423") ||
|
|
this.rawStation.station_sn.startsWith("T8130") || this.rawStation.station_sn.startsWith("T8131") || this.rawStation.station_sn.startsWith("T8420") || this.rawStation.station_sn.startsWith("T8440") ||
|
|
this.rawStation.station_sn.startsWith("T8171") || this.rawStation.station_sn.startsWith("T8426") ||
|
|
this.rawStation.station_sn.startsWith("T8441") || this.rawStation.station_sn.startsWith("T8442") || (0, utils_1.checkT8420)(this.rawStation.station_sn)) {
|
|
this.currentMessageState[message.dataType].p2pStreamMetadata.videoCodec = videoMetaData.streamType === 1 ? types_1.VideoCodec.H264 : videoMetaData.streamType === 2 ? types_1.VideoCodec.H265 : (0, utils_1.getVideoCodec)(video_data);
|
|
logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME - Video codec information received from packet`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[message.commandId], commandId: message.commandId, channel: message.channel, metadata: videoMetaData });
|
|
}
|
|
else if (this.isIFrame(video_data, isKeyFrame)) {
|
|
this.currentMessageState[message.dataType].p2pStreamMetadata.videoCodec = (0, utils_1.getVideoCodec)(video_data);
|
|
logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME - Video codec extracted from video data`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[message.commandId], commandId: message.commandId, channel: message.channel, metadata: videoMetaData });
|
|
}
|
|
else {
|
|
this.currentMessageState[message.dataType].p2pStreamMetadata.videoCodec = (0, utils_1.getVideoCodec)(video_data);
|
|
if (this.currentMessageState[message.dataType].p2pStreamMetadata.videoCodec === types_1.VideoCodec.UNKNOWN) {
|
|
this.currentMessageState[message.dataType].p2pStreamMetadata.videoCodec = videoMetaData.streamType === 1 ? types_1.VideoCodec.H264 : videoMetaData.streamType === 2 ? types_1.VideoCodec.H265 : types_1.VideoCodec.UNKNOWN;
|
|
if (this.currentMessageState[message.dataType].p2pStreamMetadata.videoCodec === types_1.VideoCodec.UNKNOWN) {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME - Unknown video codec`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[message.commandId], commandId: message.commandId, channel: message.channel, metadata: videoMetaData });
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME - Fallback, using video codec information received from packet`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[message.commandId], commandId: message.commandId, channel: message.channel, metadata: videoMetaData });
|
|
}
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME - Fallback, video codec extracted from video data`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[message.commandId], commandId: message.commandId, channel: message.channel, metadata: videoMetaData });
|
|
}
|
|
}
|
|
this.currentMessageState[message.dataType].p2pStreamFirstVideoDataReceived = true;
|
|
if (!this.currentMessageState[message.dataType].p2pStreamFirstAudioDataReceived) {
|
|
this.currentMessageState[message.dataType].waitForAudioData = setTimeout(() => {
|
|
this.currentMessageState[message.dataType].waitForAudioData = undefined;
|
|
this.currentMessageState[message.dataType].p2pStreamMetadata.audioCodec = types_1.AudioCodec.NONE;
|
|
this.currentMessageState[message.dataType].p2pStreamFirstAudioDataReceived = true;
|
|
if (this.currentMessageState[message.dataType].p2pStreamFirstAudioDataReceived && this.currentMessageState[message.dataType].p2pStreamFirstVideoDataReceived && this.currentMessageState[message.dataType].p2pStreamNotStarted) {
|
|
this.emitStreamStartEvent(message.dataType);
|
|
}
|
|
}, this.AUDIO_CODEC_ANALYZE_TIMEOUT);
|
|
}
|
|
}
|
|
if (this.currentMessageState[message.dataType].p2pStreamNotStarted) {
|
|
if (this.currentMessageState[message.dataType].p2pStreamFirstAudioDataReceived && this.currentMessageState[message.dataType].p2pStreamFirstVideoDataReceived) {
|
|
this.emitStreamStartEvent(message.dataType);
|
|
}
|
|
}
|
|
if (message.dataType === types_1.P2PDataType.VIDEO) {
|
|
if ((0, utils_1.findStartCode)(video_data)) {
|
|
logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME: startcode found`, { stationSN: this.rawStation.station_sn, isKeyFrame: isKeyFrame, preFrameVideoDataLength: this.currentMessageState[message.dataType].preFrameVideoData.length });
|
|
if (!this.currentMessageState[message.dataType].receivedFirstIFrame)
|
|
this.currentMessageState[message.dataType].receivedFirstIFrame = this.isIFrame(video_data, isKeyFrame);
|
|
if (this.currentMessageState[message.dataType].receivedFirstIFrame) {
|
|
if (this.currentMessageState[message.dataType].preFrameVideoData.length > this.MAX_VIDEO_PACKET_BYTES)
|
|
this.currentMessageState[message.dataType].preFrameVideoData = Buffer.from([]);
|
|
if (this.currentMessageState[message.dataType].preFrameVideoData.length > 0) {
|
|
this.currentMessageState[message.dataType].videoStream?.push(this.currentMessageState[message.dataType].preFrameVideoData);
|
|
}
|
|
this.currentMessageState[message.dataType].preFrameVideoData = Buffer.from(video_data);
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME: Skipping because first frame is not an I frame.`, { stationSN: this.rawStation.station_sn });
|
|
}
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME: No startcode found`, { stationSN: this.rawStation.station_sn, isKeyFrame: isKeyFrame, preFrameVideoDataLength: this.currentMessageState[message.dataType].preFrameVideoData.length });
|
|
if (this.currentMessageState[message.dataType].preFrameVideoData.length > 0) {
|
|
this.currentMessageState[message.dataType].preFrameVideoData = Buffer.concat([this.currentMessageState[message.dataType].preFrameVideoData, video_data]);
|
|
}
|
|
}
|
|
}
|
|
else if (message.dataType === types_1.P2PDataType.BINARY) {
|
|
this.currentMessageState[message.dataType].videoStream?.push(video_data);
|
|
}
|
|
break;
|
|
case types_1.CommandType.CMD_AUDIO_FRAME:
|
|
this.waitForStreamData(message.dataType, true);
|
|
const audioMetaData = {
|
|
audioType: types_1.AudioCodec.NONE,
|
|
audioSeqNo: 0,
|
|
audioTimestamp: 0,
|
|
audioDataLength: 0
|
|
};
|
|
audioMetaData.audioDataLength = message.data.subarray(0, 4).readUInt32LE();
|
|
audioMetaData.audioType = message.data.subarray(5, 6).readUInt8();
|
|
audioMetaData.audioSeqNo = message.data.subarray(6, 8).readUInt16LE();
|
|
audioMetaData.audioTimestamp = message.data.subarray(8, 14).readUIntLE(0, 6);
|
|
const audio_data = Buffer.from(message.data.subarray(16));
|
|
logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_AUDIO_FRAME`, { stationSN: this.rawStation.station_sn, dataSize: message.data.length, metadata: audioMetaData, audioDataSize: audio_data.length });
|
|
if (this.currentMessageState[message.dataType].waitForAudioData !== undefined) {
|
|
clearTimeout(this.currentMessageState[message.dataType].waitForAudioData);
|
|
}
|
|
if (!this.currentMessageState[message.dataType].p2pStreamFirstAudioDataReceived) {
|
|
this.currentMessageState[message.dataType].p2pStreamFirstAudioDataReceived = true;
|
|
this.currentMessageState[message.dataType].p2pStreamMetadata.audioCodec = audioMetaData.audioType === 0 ? types_1.AudioCodec.AAC : audioMetaData.audioType === 1 ? types_1.AudioCodec.AAC_LC : audioMetaData.audioType === 7 ? types_1.AudioCodec.AAC_ELD : types_1.AudioCodec.UNKNOWN;
|
|
}
|
|
if (this.currentMessageState[message.dataType].p2pStreamNotStarted) {
|
|
if (this.currentMessageState[message.dataType].p2pStreamFirstAudioDataReceived && this.currentMessageState[message.dataType].p2pStreamFirstVideoDataReceived) {
|
|
this.emitStreamStartEvent(message.dataType);
|
|
}
|
|
}
|
|
this.currentMessageState[message.dataType].audioStream?.push(audio_data);
|
|
break;
|
|
default:
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Not implemented message`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[message.commandId], commandId: message.commandId, channel: message.channel, data: message.data.toString("hex") });
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Invalid stream data, dropping complete stream`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[message.commandId], commandId: message.commandId, channel: message.channel, data: message.data.toString("hex") });
|
|
}
|
|
}
|
|
handleDataControl(message) {
|
|
try {
|
|
let data = message.data;
|
|
if (message.signCode > 0) {
|
|
//data = decryptP2PData(message.data, this.p2pKey!);
|
|
try {
|
|
data = (0, utils_1.decryptP2PData)(message.data, Buffer.from((0, utils_1.getP2PCommandEncryptionKey)(this.rawStation.station_sn, this.rawStation.p2p_did)));
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Decrypt Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
|
|
}
|
|
}
|
|
logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Received data`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[message.commandId], commandId: message.commandId, data: message.data.toString("hex"), seqNumber: this.seqNumber, p2pDataSeqNumber: this.p2pDataSeqNumber, offsetDataSeqNumber: this.offsetDataSeqNumber });
|
|
switch (message.commandId) {
|
|
case types_1.CommandType.CMD_GET_ALARM_MODE:
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Alarm mode changed to: ${types_2.AlarmMode[data.readUIntBE(0, 1)]}`, { stationSN: this.rawStation.station_sn, });
|
|
this.emit("alarm mode", data.readUIntBE(0, 1));
|
|
break;
|
|
case types_1.CommandType.CMD_CAMERA_INFO:
|
|
try {
|
|
const cameraData = (0, utils_1.getNullTerminatedString)(data, "utf8");
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Camera info`, { stationSN: this.rawStation.station_sn, cameraInfo: cameraData });
|
|
this.emit("camera info", (0, utils_3.parseJSON)(cameraData, logging_1.rootP2PLogger));
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Camera info - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
|
|
}
|
|
break;
|
|
case types_1.CommandType.CMD_CONVERT_MP4_OK:
|
|
const totalBytes = data.subarray(1).readUInt32LE();
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_CONVERT_MP4_OK`, { stationSN: this.rawStation.station_sn, channel: message.channel, totalBytes: totalBytes });
|
|
this.downloadTotalBytes = totalBytes;
|
|
this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreaming = true;
|
|
this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreamChannel = message.channel;
|
|
break;
|
|
case types_1.CommandType.CMD_WIFI_CONFIG:
|
|
const rssi = data.readInt32LE();
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_WIFI_CONFIG`, { stationSN: this.rawStation.station_sn, channel: message.channel, rssi: rssi });
|
|
this.emit("wifi rssi", message.channel, rssi);
|
|
break;
|
|
case types_1.CommandType.CMD_DOWNLOAD_FINISH:
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DOWNLOAD_FINISH`, { stationSN: this.rawStation.station_sn, channel: message.channel });
|
|
this.endStream(types_1.P2PDataType.BINARY);
|
|
break;
|
|
case types_1.CommandType.CMD_DOORBELL_NOTIFY_PAYLOAD:
|
|
try {
|
|
const str = (0, utils_1.getNullTerminatedString)(data, "utf8");
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DOORBELL_NOTIFY_PAYLOAD`, { stationSN: this.rawStation.station_sn, payload: str });
|
|
//TODO: Finish implementation, emit an event...
|
|
//VDBStreamInfo (1005) and VoltageEvent (1015)
|
|
//this.emit("", parseJSON(str, this.log) as xy);
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DOORBELL_NOTIFY_PAYLOAD - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
|
|
}
|
|
break;
|
|
case types_1.CommandType.CMD_NAS_SWITCH:
|
|
try {
|
|
const str = (0, utils_1.getNullTerminatedString)(data, "utf8");
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NAS_SWITCH`, { stationSN: this.rawStation.station_sn, payload: str });
|
|
this.emit("rtsp url", message.channel, str);
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NAS_SWITCH - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
|
|
}
|
|
break;
|
|
case types_1.CommandType.SUB1G_REP_UNPLUG_POWER_LINE:
|
|
try {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - SUB1G_REP_UNPLUG_POWER_LINE`, { stationSN: this.rawStation.station_sn, payload: data.toString() });
|
|
const chargeType = data.subarray(0, 4).readUInt32LE();
|
|
const batteryLevel = data.subarray(4, 8).readUInt32LE();
|
|
this.emit("charging state", message.channel, chargeType, batteryLevel);
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - SUB1G_REP_UNPLUG_POWER_LINE - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
|
|
}
|
|
break;
|
|
case types_1.CommandType.SUB1G_REP_RUNTIME_STATE:
|
|
try {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - SUB1G_REP_RUNTIME_STATE`, { stationSN: this.rawStation.station_sn, payload: data.toString() });
|
|
const batteryLevel = data.subarray(0, 4).readUInt32LE();
|
|
const temperature = data.subarray(4, 8).readUInt32LE();
|
|
this.emit("runtime state", message.channel, batteryLevel, temperature);
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - SUB1G_REP_RUNTIME_STATE - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
|
|
}
|
|
break;
|
|
case types_1.CommandType.CMD_SET_FLOODLIGHT_MANUAL_SWITCH:
|
|
try {
|
|
const enabled = data.readUIntBE(0, 1) === 1 ? true : false;
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_SET_FLOODLIGHT_MANUAL_SWITCH`, { stationSN: this.rawStation.station_sn, enabled: enabled, payload: data.toString() });
|
|
this.emit("floodlight manual switch", message.channel, enabled);
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_SET_FLOODLIGHT_MANUAL_SWITCH - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
|
|
}
|
|
break;
|
|
case types_1.CommandType.CMD_GET_DEVICE_PING:
|
|
try {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GET_DEVICE_PING`, { stationSN: this.rawStation.station_sn, payload: data.toString() });
|
|
this.sendCommandDevicePing(message.channel);
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GET_DEVICE_PING - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
|
|
}
|
|
break;
|
|
case types_1.CommandType.CMD_NOTIFY_PAYLOAD:
|
|
try {
|
|
logging_1.rootP2PLogger.debug(`Station Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD`, { stationSN: this.rawStation.station_sn, payload: data.toString() });
|
|
const json = (0, utils_3.parseJSON)((0, utils_1.getNullTerminatedString)(data, "utf8"), logging_1.rootP2PLogger);
|
|
if (json !== undefined) {
|
|
if (device_1.Device.isLockWifi(this.rawStation.device_type, this.rawStation.station_sn)) {
|
|
//TODO: Implement notification payload or T8520
|
|
if (json.cmd === types_1.CommandType.P2P_ADD_PW || json.cmd === types_1.CommandType.P2P_QUERY_PW || json.cmd === types_1.CommandType.P2P_GET_LOCK_PARAM || json.cmd === types_1.CommandType.P2P_GET_USER_AND_PW_ID) {
|
|
// encrypted data
|
|
//TODO: Handle decryption of encrypted Data (AES) - For decryption use the cached aeskey used for sending the command!
|
|
const aesKey = this.getLockAESKey(json.cmd);
|
|
if (aesKey !== undefined) {
|
|
const decryptedPayload = (0, utils_1.decryptPayloadData)(Buffer.from(json.payload, "base64"), Buffer.from(aesKey, "hex"), Buffer.from((0, utils_1.getLockVectorBytes)(this.rawStation.station_sn), "hex")).toString();
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Lock - Received`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, decryptedPayload: decryptedPayload, aesKey: aesKey });
|
|
switch (json.cmd) {
|
|
case types_1.CommandType.P2P_ADD_PW:
|
|
// decryptedPayload: {"code":0,"passwordId":"002C"}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (json.cmd === types_1.CommandType.P2P_QUERY_STATUS_IN_LOCK) {
|
|
// Example: {"code":0,"slBattery":"82","slState":"4","trigger":2}
|
|
const payload = json.payload;
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_QUERY_BATTERY_LEVEL, payload.slBattery);
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_QUERY_STATUS, payload.slState);
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD - Not implemented`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, message: data.toString() });
|
|
}
|
|
}
|
|
else if (json.cmd === types_1.CommandType.P2P_QUERY_STATUS_IN_LOCK) {
|
|
// Example: {"code":0,"slBattery":"99","slState":"4","slOpenDirection":"1","trigger":2}
|
|
const payload = json.payload;
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_GET_BATTERY, payload.slBattery);
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_DOORLOCK_GET_STATE, payload.slState);
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_NIGHT_VISION_SIDE, payload.slOpenDirection);
|
|
}
|
|
else if (json.cmd === types_1.CommandType.CMD_DOORLOCK_P2P_SEQ) {
|
|
if (device_1.Device.isLockWifi(this.rawStation.devices[0]?.device_type, this.rawStation.devices[0]?.device_sn) || device_1.Device.isLockWifiNoFinger(this.rawStation.devices[0]?.device_type)) {
|
|
const payload = json.payload;
|
|
if (payload.seq_num !== undefined) {
|
|
this.lockSeqNumber = payload.seq_num;
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD - Lock sequence number`, { stationSN: this.rawStation.station_sn, lockSeqNumber: this.lockSeqNumber, payload: payload });
|
|
}
|
|
if (payload.lock_cmd > 0) {
|
|
this.emit("sequence error", message.channel, payload.lock_cmd, payload.seq_num, payload.stationSn);
|
|
}
|
|
}
|
|
else {
|
|
const payload = json.payload;
|
|
if (payload.seq_num !== undefined) {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD - Lock sequence number`, { stationSN: this.rawStation.station_sn, oldSequenceNumber: this.lockSeqNumber, newSequenceNumber: this.lockSeqNumber + 1, payload: payload });
|
|
this.lockSeqNumber = payload.seq_num + 1;
|
|
}
|
|
if (payload.lock_cmd > 0) {
|
|
if (device_1.Device.isLockWifiR10(this.rawStation.devices[0]?.device_type) || device_1.Device.isLockWifiR20(this.rawStation.devices[0]?.device_type)) {
|
|
this.emit("sequence error", message.channel, types_1.ESLCommand[types_1.ESLBleCommand[payload.lock_cmd]], payload.seq_num, payload.dev_sn);
|
|
}
|
|
else if (device_1.Device.isLockWifiT8506(this.rawStation.devices[0]?.device_type) || device_1.Device.isLockWifiT8502(this.rawStation.devices[0]?.device_type) || device_1.Device.isLockWifiT8510P(this.rawStation.devices[0]?.device_type, this.rawStation.devices[0]?.device_sn) || device_1.Device.isLockWifiT8520P(this.rawStation.devices[0]?.device_type, this.rawStation.devices[0]?.device_sn)) {
|
|
this.emit("sequence error", message.channel, types_1.SmartLockCommand[payload.bus_type == types_1.SmartLockFunctionType.TYPE_2 ? types_1.SmartLockBleCommandFunctionType2[payload.lock_cmd] : types_1.SmartLockBleCommandFunctionType1[payload.lock_cmd]], payload.seq_num, payload.dev_sn);
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD - Lock sequence number - Unknwon device`, { stationSN: this.rawStation.station_sn, oldSequenceNumber: this.lockSeqNumber, newSequenceNumber: this.lockSeqNumber + 1, payload: payload });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (json.cmd === types_1.CommandType.CMD_DOORLOCK_DATA_PASS_THROUGH) {
|
|
const payload = json.payload;
|
|
if (this.deviceSNs[message.channel] !== undefined) {
|
|
if (payload.lock_payload !== undefined) {
|
|
const decoded = (0, utils_1.decodeBase64)((0, utils_1.decodeLockPayload)(Buffer.from(payload.lock_payload)));
|
|
const key = (0, utils_1.generateBasicLockAESKey)(this.deviceSNs[message.channel].adminUserId, this.rawStation.station_sn);
|
|
const iv = (0, utils_1.getLockVectorBytes)(this.rawStation.station_sn);
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DOORLOCK_DATA_PASS_THROUGH`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, key: key, iv: iv, decoded: decoded.toString("hex") });
|
|
payload.lock_payload = (0, utils_1.decryptLockAESData)(key, iv, decoded).toString("hex");
|
|
switch (payload.lock_cmd) {
|
|
case types_1.ESLBleCommand.NOTIFY:
|
|
const notifyBuffer = Buffer.from(payload.lock_payload, "hex");
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_GET_BATTERY, notifyBuffer.subarray(3, 4).readInt8().toString());
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_DOORLOCK_GET_STATE, notifyBuffer.subarray(6, 7).readInt8().toString());
|
|
break;
|
|
default:
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DOORLOCK_DATA_PASS_THROUGH - Not implemented`, { stationSN: this.rawStation.station_sn, message: data.toString() });
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (json.cmd === types_1.CommandType.CMD_SET_PAYLOAD_LOCKV12) {
|
|
const payload = json.payload;
|
|
if (payload.lock_payload !== undefined) {
|
|
const fac = ble_1.BleCommandFactory.parseLockV12(payload.lock_payload);
|
|
if (fac.getCommandCode() !== types_1.ESLBleCommand.NOTIFY) {
|
|
const aesKey = this.getLockAESKey(fac.getCommandCode());
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Lock V12 - Received`, { stationSN: this.rawStation.station_sn, fac: fac.toString(), aesKey: aesKey });
|
|
let data = fac.getData();
|
|
try {
|
|
if (aesKey !== undefined) {
|
|
data = (0, utils_1.decryptPayloadData)(data, Buffer.from(aesKey, "hex"), Buffer.from((0, utils_1.getLockVectorBytes)(this.rawStation.station_sn), "hex"));
|
|
}
|
|
const returnCode = data.readInt8(0);
|
|
const commandType = Number.parseInt(types_1.ESLCommand[types_1.ESLBleCommand[fac.getCommandCode()]]);
|
|
const customData = {
|
|
...this.customDataStaging[commandType]
|
|
};
|
|
if (this.customDataStaging[commandType]) {
|
|
const result = {
|
|
channel: customData.channel,
|
|
command_type: commandType,
|
|
return_code: returnCode,
|
|
customData: customData.customData
|
|
};
|
|
this.emit("secondary command", result);
|
|
delete this.customDataStaging[commandType];
|
|
}
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Lock V12 return code: ${returnCode}`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, decoded: data.toString("hex"), bleCommandCode: types_1.ESLBleCommand[fac.getCommandCode()], returnCode: returnCode, channel: customData?.channel, customData: customData?.customData });
|
|
const parsePayload = new utils_2.ParsePayload(data.subarray(1));
|
|
switch (fac.getCommandCode()) {
|
|
case types_1.ESLBleCommand.QUERY_STATUS_IN_LOCK:
|
|
case types_1.ESLBleCommand.NOTIFY:
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_QUERY_BATTERY_LEVEL, parsePayload.readInt8(ble_1.BleParameterIndex.ONE).toString());
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_QUERY_STATUS, parsePayload.readInt8(ble_1.BleParameterIndex.TWO).toString());
|
|
break;
|
|
case types_1.ESLBleCommand.GET_LOCK_PARAM:
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_LOCK_SOUND, parsePayload.readInt8(ble_1.BleParameterIndex.ONE).toString());
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_AUTO_LOCK, parsePayload.readInt8(ble_1.BleParameterIndex.TWO).toString());
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_AUTO_LOCK_TIMER, parsePayload.readUint16LE(ble_1.BleParameterIndex.THREE).toString());
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_AUTO_LOCK_SCHEDULE, parsePayload.readInt8(ble_1.BleParameterIndex.FOUR).toString());
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_AUTO_LOCK_SCHEDULE_STARTTIME, parsePayload.readStringHex(ble_1.BleParameterIndex.FIVE));
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_AUTO_LOCK_SCHEDULE_ENDTIME, parsePayload.readStringHex(ble_1.BleParameterIndex.SIX));
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_ONE_TOUCH_LOCK, parsePayload.readInt8(ble_1.BleParameterIndex.SEVEN).toString());
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_WRONG_TRY_PROTECT, parsePayload.readInt8(ble_1.BleParameterIndex.EIGHT).toString());
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_WRONG_TRY_LOCKDOWN, parsePayload.readUint16LE(ble_1.BleParameterIndex.NINE).toString());
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_WRONG_TRY_ATTEMPTS, parsePayload.readInt8(ble_1.BleParameterIndex.TEN).toString());
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_SCRAMBLE_PASSCODE, parsePayload.readInt8(ble_1.BleParameterIndex.ELEVEN).toString());
|
|
//this.emit("parameter", message.channel, CommandType.CMD_SMARTLOCK_LOG, parsePayload.readInt8(BleParameterIndex.TWELVE).toString());
|
|
//this.emit("parameter", message.channel, CommandType.CMD_SMARTLOCK_WIFI_STATUS, parsePayload.readInt8(BleParameterIndex.THIRTEEN).toString());
|
|
break;
|
|
case types_1.ESLBleCommand.ADD_PW:
|
|
if (customData && customData.customData && customData.customData.command && customData.customData.command.name === http_1.CommandName.DeviceAddUser) {
|
|
this.api.updateUserPassword(customData.customData.command.value?.deviceSN, customData.customData.command.value?.shortUserId, parsePayload.readStringHex(ble_1.BleParameterIndex.ONE), customData.customData.command.value?.schedule);
|
|
}
|
|
break;
|
|
default:
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock - Not implemented`, { stationSN: this.rawStation.station_sn, fac: fac.toString(), returnCode: returnCode, channel: customData?.channel, customData: customData?.customData });
|
|
break;
|
|
}
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Lock V12 unable to decrypt (maybe event from other lock connection)`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, payload: payload });
|
|
}
|
|
this._clearSecondaryCommandTimeout();
|
|
this.sendQueuedMessage();
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Lock V12 - Received notify`, { stationSN: this.rawStation.station_sn, fac: fac.toString() });
|
|
}
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Lock V12 - Unexpected response`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, message: data.toString() });
|
|
}
|
|
}
|
|
else if (json.cmd === types_1.CommandType.CMD_TRANSFER_PAYLOAD) {
|
|
const payload = json.payload;
|
|
if (payload.lock_payload !== undefined) {
|
|
try {
|
|
const fac = ble_1.BleCommandFactory.parseSmartLock(payload.lock_payload);
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock - Received`, { stationSN: this.rawStation.station_sn, fac: fac.toString() });
|
|
if (!fac.isPartial()) {
|
|
let data = fac.getData();
|
|
if (data) {
|
|
if (fac.isEncrypted()) {
|
|
const aesKey = (0, utils_1.generateSmartLockAESKey)(this.rawStation.member.admin_user_id, Number.parseInt(payload.time, 16));
|
|
const iv = (0, utils_1.getLockVectorBytes)(payload.dev_sn);
|
|
if (aesKey !== undefined) {
|
|
data = (0, utils_1.decryptPayloadData)(data, aesKey, Buffer.from(iv, "hex"));
|
|
}
|
|
}
|
|
if (data.length > 0 && fac.getDataType() !== undefined) {
|
|
const returnCode = data.readInt8(0);
|
|
const functionTypeCommand = fac.getDataType() === types_1.SmartLockFunctionType.TYPE_2 ? types_1.SmartLockBleCommandFunctionType2 : types_1.SmartLockBleCommandFunctionType1;
|
|
const commandType = Number.parseInt(types_1.SmartLockCommand[functionTypeCommand[fac.getCommandCode()]]);
|
|
const customData = {
|
|
...this.customDataStaging[commandType]
|
|
};
|
|
if (this.customDataStaging[commandType]) {
|
|
const result = {
|
|
channel: customData.channel,
|
|
command_type: commandType,
|
|
return_code: returnCode,
|
|
customData: customData.customData
|
|
};
|
|
this.emit("secondary command", result);
|
|
delete this.customDataStaging[commandType];
|
|
}
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock return code: ${returnCode}`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, decoded: data.toString("hex"), bleCommandCode: functionTypeCommand[fac.getCommandCode()], returnCode: returnCode });
|
|
const parsePayload = new utils_2.ParsePayload(data.subarray(1));
|
|
if (fac.getDataType() === types_1.SmartLockFunctionType.TYPE_2) {
|
|
switch (fac.getCommandCode()) {
|
|
case types_1.SmartLockBleCommandFunctionType2.QUERY_STATUS_IN_LOCK:
|
|
case types_1.SmartLockBleCommandFunctionType2.NOTIFY:
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_QUERY_BATTERY_LEVEL, parsePayload.readInt8(ble_1.BleParameterIndex.ONE).toString());
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_QUERY_STATUS, parsePayload.readInt8(ble_1.BleParameterIndex.TWO).toString());
|
|
break;
|
|
case types_1.SmartLockBleCommandFunctionType2.GET_LOCK_PARAM:
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_AUTO_LOCK, parsePayload.readInt8(ble_1.BleParameterIndex.ONE).toString());
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_AUTO_LOCK_TIMER, parsePayload.readUint16LE(ble_1.BleParameterIndex.TWO).toString());
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_AUTO_LOCK_SCHEDULE, parsePayload.readInt8(ble_1.BleParameterIndex.THREE).toString());
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_AUTO_LOCK_SCHEDULE_STARTTIME, parsePayload.readStringHex(ble_1.BleParameterIndex.FOUR));
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_AUTO_LOCK_SCHEDULE_ENDTIME, parsePayload.readStringHex(ble_1.BleParameterIndex.FIVE));
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_ONE_TOUCH_LOCK, parsePayload.readInt8(ble_1.BleParameterIndex.SIX).toString());
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_SCRAMBLE_PASSCODE, parsePayload.readInt8(ble_1.BleParameterIndex.SEVEN).toString());
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_WRONG_TRY_PROTECT, parsePayload.readInt8(ble_1.BleParameterIndex.EIGHT).toString());
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_WRONG_TRY_ATTEMPTS, parsePayload.readInt8(ble_1.BleParameterIndex.NINE).toString());
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_WRONG_TRY_LOCKDOWN, parsePayload.readUint16LE(ble_1.BleParameterIndex.TEN).toString());
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_LOCK_SOUND, parsePayload.readInt8(ble_1.BleParameterIndex.ELEVEN).toString());
|
|
//this.emit("parameter", message.channel, CommandType.CMD_SMARTLOCK_WIFI_STATUS, parsePayload.readInt8(BleParameterIndex.TWELVE).toString());
|
|
//this.emit("parameter", message.channel, CommandType.CMD_SMARTLOCK_LOG, parsePayload.readInt8(BleParameterIndex.THIRTEEN).toString());
|
|
break;
|
|
case types_1.SmartLockBleCommandFunctionType2.ADD_PW:
|
|
if (customData && customData.customData && customData.customData.command && customData.customData.command.name === http_1.CommandName.DeviceAddUser) {
|
|
this.api.updateUserPassword(customData.customData.command.value?.deviceSN, customData.customData.command.value?.shortUserId, parsePayload.readStringHex(ble_1.BleParameterIndex.ONE), customData.customData.command.value?.schedule);
|
|
}
|
|
break;
|
|
default:
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock - Not implemented`, { stationSN: this.rawStation.station_sn, fac: fac.toString(), returnCode: returnCode, channel: customData?.channel, customData: customData?.customData });
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock - Not implemented`, { stationSN: this.rawStation.station_sn, fac: fac.toString(), returnCode: returnCode, channel: customData?.channel, customData: customData?.customData });
|
|
}
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock - Unsupported data length or missint function type`, { stationSN: this.rawStation.station_sn, fac: fac.toString() });
|
|
}
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock - No data`, { stationSN: this.rawStation.station_sn, fac: fac.toString() });
|
|
}
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock - Partial data`, { stationSN: this.rawStation.station_sn, fac: fac.toString() });
|
|
}
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, payload: payload });
|
|
}
|
|
this._clearSecondaryCommandTimeout();
|
|
this.sendQueuedMessage();
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock - Unexpected response`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, message: data.toString() });
|
|
}
|
|
}
|
|
else if (device_1.Device.isSmartSafe(this.rawStation.device_type)) {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD SmartSafe`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd });
|
|
switch (json.cmd) {
|
|
case types_1.CommandType.CMD_SMARTSAFE_SETTINGS:
|
|
{
|
|
const payload = json.payload;
|
|
try {
|
|
const data = (0, utils_1.decodeSmartSafeData)(this.rawStation.station_sn, Buffer.from(payload.data, "hex"));
|
|
const returnCode = data.data.readInt8(0);
|
|
const customData = {
|
|
...this.customDataStaging[payload.prj_id]
|
|
};
|
|
if (this.customDataStaging[payload.prj_id]) {
|
|
const result = {
|
|
channel: customData.channel,
|
|
command_type: payload.prj_id,
|
|
return_code: returnCode,
|
|
customData: customData.customData
|
|
};
|
|
this.emit("secondary command", result);
|
|
delete this.customDataStaging[payload.prj_id];
|
|
}
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD SmartSafe return code: ${data.data.readInt8(0)}`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, decoded: data, commandCode: types_1.SmartSafeCommandCode[data.commandCode], returnCode: returnCode, channel: customData?.channel, customData: customData?.customData });
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD SmartSafe Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, payload: payload });
|
|
}
|
|
this._clearSecondaryCommandTimeout();
|
|
this.sendQueuedMessage();
|
|
break;
|
|
}
|
|
case types_1.CommandType.CMD_SMARTSAFE_STATUS_UPDATE:
|
|
{
|
|
const payload = json.payload;
|
|
switch (payload.event_type) {
|
|
case types_3.SmartSafeEvent.LOCK_STATUS:
|
|
{
|
|
const eventValues = payload.event_value;
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD SmartSafe Status update - LOCK_STATUS`, { stationSN: this.rawStation.station_sn, eventValues: eventValues });
|
|
/*
|
|
type values:
|
|
1: Unlocked by PIN
|
|
2: Unlocked by User
|
|
3: Unlocked by key
|
|
4: Unlocked by App
|
|
5: Unlocked by Dual Unlock
|
|
*/
|
|
if (eventValues.action === 0) {
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTSAFE_LOCK_STATUS, "0");
|
|
}
|
|
else if (eventValues.action === 1) {
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTSAFE_LOCK_STATUS, "1");
|
|
}
|
|
else if (eventValues.action === 2) {
|
|
this.emit("jammed", message.channel);
|
|
}
|
|
else if (eventValues.action === 3) {
|
|
this.emit("low battery", message.channel);
|
|
}
|
|
break;
|
|
}
|
|
case types_3.SmartSafeEvent.SHAKE_ALARM:
|
|
this.emit("shake alarm", message.channel, payload.event_value);
|
|
break;
|
|
case types_3.SmartSafeEvent.ALARM_911:
|
|
this.emit("911 alarm", message.channel, payload.event_value);
|
|
break;
|
|
//case SmartSafeEvent.BATTERY_STATUS:
|
|
// break;
|
|
case types_3.SmartSafeEvent.INPUT_ERR_MAX:
|
|
this.emit("wrong try-protect alarm", message.channel);
|
|
break;
|
|
default:
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD SmartSafe Status update - Not implemented`, { stationSN: this.rawStation.station_sn, message: data.toString() });
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD SmartSafe - Not implemented`, { stationSN: this.rawStation.station_sn, message: data.toString() });
|
|
break;
|
|
}
|
|
}
|
|
else if (json.cmd === types_1.CommandType.CMD_ENTRY_SENSOR_STATUS) {
|
|
// {"cmd":1550,"payload":{"status":1}}
|
|
const payload = json.payload;
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD EntrySensor Status update`, { stationSN: this.rawStation.station_sn, status: payload?.status });
|
|
if (payload) {
|
|
this.emit("sensor status", message.channel, payload.status);
|
|
}
|
|
}
|
|
else if (json.cmd === types_1.CommandType.CMD_CAMERA_GARAGE_DOOR_STATUS) {
|
|
// {"cmd":7500,"payload":{"type":24,"notify_tag":"","door_id":2}}
|
|
const payload = json.payload;
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD GarageDoor Status update`, { stationSN: this.rawStation.station_sn, doorId: payload?.door_id, status: payload?.type, notify_tag: payload?.notify_tag });
|
|
if (payload) {
|
|
this.emit("garage door status", message.channel, payload.door_id, payload.type);
|
|
}
|
|
}
|
|
else if (json.cmd === types_1.CommandType.CMD_STORAGE_INFO_HB3) {
|
|
const payload = json.payload;
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD StorageInfo HB3 update`, { stationSN: this.rawStation.station_sn, body: payload?.body });
|
|
if (payload) {
|
|
this.emit("storage info hb3", message.channel, payload.body);
|
|
}
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD - Not implemented`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, message: data.toString() });
|
|
}
|
|
}
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString() } });
|
|
}
|
|
break;
|
|
case types_1.CommandType.CMD_GET_DELAY_ALARM:
|
|
try {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GET_DELAY_ALARM :`, { stationSN: this.rawStation.station_sn, payload: data.toString("hex") });
|
|
//When the alarm is armed, CMD_GET_DELAY_ALARM is called with event data 0, so ignore it
|
|
const alarmEventNumber = data.subarray(0, 4).readUInt32LE();
|
|
const alarmDelay = data.subarray(4, 8).readUInt32LE();
|
|
if (alarmEventNumber === 0) {
|
|
this.emit("alarm armed");
|
|
}
|
|
else {
|
|
this.emit("alarm delay", alarmEventNumber, alarmDelay);
|
|
}
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GET_DELAY_ALARM - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
|
|
}
|
|
break;
|
|
case types_1.CommandType.CMD_SET_TONE_FILE:
|
|
try {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_SET_TONE_FILE :`, { stationSN: this.rawStation.station_sn, payload: data.toString("hex") });
|
|
const alarmEventNumber = data.subarray(0, 4).readUInt32LE();
|
|
this.emit("alarm event", alarmEventNumber);
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_SET_TONE_FILE - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
|
|
}
|
|
break;
|
|
case types_1.CommandType.CMD_SET_SNOOZE_MODE:
|
|
// Received for station managed devices when snooze time ends
|
|
try {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_SET_SNOOZE_MODE`, { stationSN: this.rawStation.station_sn, payload: Buffer.from(data.toString(), "base64").toString() });
|
|
this.emit("parameter", message.channel, types_1.CommandType.CMD_SET_SNOOZE_MODE, data.toString());
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_SET_SNOOZE_MODE - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
|
|
}
|
|
break;
|
|
case types_1.CommandType.CMD_PING:
|
|
// Ignore
|
|
break;
|
|
case types_1.CommandType.CMD_DATABASE_IMAGE:
|
|
// Received data for preview image download
|
|
try {
|
|
const str = (0, utils_1.getNullTerminatedString)(data, "utf8");
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DATABASE_IMAGE`, { stationSN: this.rawStation.station_sn, message: str });
|
|
const image = (0, utils_3.parseJSON)(str, logging_1.rootP2PLogger);
|
|
this.emit("image download", image.file, (0, utils_2.decodeImage)(this.rawStation.p2p_did, Buffer.from(image.content, "base64")));
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DATABASE_IMAGE - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString() } });
|
|
}
|
|
break;
|
|
case types_1.CommandType.CMD_GET_TFCARD_STATUS:
|
|
try {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GET_TFCARD_STATUS :`, { stationSN: this.rawStation.station_sn, payload: data.toString("hex") });
|
|
const tfCardStatus = data.subarray(0, 4).readUInt32LE();
|
|
this.emit("tfcard status", message.channel, tfCardStatus);
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GET_TFCARD_STATUS - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
|
|
}
|
|
break;
|
|
case types_1.CommandType.CMD_DATABASE:
|
|
try {
|
|
const str = (0, utils_1.getNullTerminatedString)(data, "utf8");
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DATABASE :`, { stationSN: this.rawStation.station_sn, payload: str });
|
|
const databaseResponse = (0, utils_3.parseJSON)(str, logging_1.rootP2PLogger);
|
|
switch (databaseResponse.cmd) {
|
|
case types_1.CommandType.CMD_DATABASE_QUERY_LATEST_INFO:
|
|
{
|
|
let data = [];
|
|
if (databaseResponse.data !== undefined && databaseResponse.data !== "[]")
|
|
data = databaseResponse.data;
|
|
const result = [];
|
|
for (const record of data) {
|
|
if (record.payload.crop_hb3_path !== "") {
|
|
result.push({
|
|
device_sn: record.device_sn,
|
|
event_count: record.payload.event_count,
|
|
crop_local_path: record.payload.crop_hb3_path
|
|
});
|
|
}
|
|
else {
|
|
result.push({
|
|
device_sn: record.device_sn,
|
|
event_count: record.payload.event_count,
|
|
crop_cloud_path: record.payload.crop_cloud_path
|
|
});
|
|
}
|
|
}
|
|
this.emit("database query latest", databaseResponse.mIntRet, result);
|
|
break;
|
|
}
|
|
case types_1.CommandType.CMD_DATABASE_COUNT_BY_DATE: {
|
|
let data = [];
|
|
if (databaseResponse.data !== undefined && databaseResponse.data !== "[]")
|
|
data = databaseResponse.data;
|
|
const result = [];
|
|
for (const record of data) {
|
|
result.push({
|
|
day: date_and_time_1.default.parse(record.days, "YYYYMMDD"),
|
|
count: record.count
|
|
});
|
|
}
|
|
this.emit("database count by date", databaseResponse.mIntRet, result);
|
|
break;
|
|
}
|
|
case types_1.CommandType.CMD_DATABASE_QUERY_LOCAL: {
|
|
let data = [];
|
|
if (databaseResponse.data !== undefined && databaseResponse.data !== "[]")
|
|
data = databaseResponse.data;
|
|
const result = new sweet_collections_1.SortedMap((a, b) => a - b);
|
|
for (const record of data) {
|
|
for (const tableRecord of record.payload) {
|
|
let tmpRecord = result.get(tableRecord.record_id);
|
|
if (tmpRecord === undefined) {
|
|
tmpRecord = {
|
|
record_id: tableRecord.record_id,
|
|
device_sn: tableRecord.device_sn,
|
|
station_sn: tableRecord.station_sn,
|
|
};
|
|
}
|
|
if (record.table_name === "history_record_info") {
|
|
tmpRecord.history = {
|
|
device_type: tableRecord.device_type,
|
|
account: tableRecord.account,
|
|
start_time: date_and_time_1.default.parse(tableRecord.start_time, "YYYY-MM-DD HH:mm:ss"),
|
|
end_time: date_and_time_1.default.parse(tableRecord.end_time, "YYYY-MM-DD HH:mm:ss"),
|
|
frame_num: tableRecord.frame_num,
|
|
storage_type: tableRecord.storage_type,
|
|
storage_cloud: tableRecord.storage_cloud,
|
|
cipher_id: tableRecord.cipher_id,
|
|
vision: tableRecord.vision,
|
|
video_type: tableRecord.video_type,
|
|
has_lock: tableRecord.has_lock,
|
|
automation_id: tableRecord.automation_id,
|
|
trigger_type: tableRecord.trigger_type,
|
|
push_mode: tableRecord.push_mode,
|
|
mic_status: tableRecord.mic_status,
|
|
res_change: tableRecord.res_change,
|
|
res_best_width: tableRecord.res_best_width,
|
|
res_best_height: tableRecord.res_best_height,
|
|
self_learning: tableRecord.self_learning,
|
|
storage_path: tableRecord.storage_path,
|
|
thumb_path: tableRecord.thumb_path,
|
|
write_status: tableRecord.write_status,
|
|
cloud_path: tableRecord.cloud_path,
|
|
folder_size: tableRecord.folder_size,
|
|
storage_status: tableRecord.storage_status,
|
|
storage_label: tableRecord.storage_label,
|
|
time_zone: tableRecord.time_zone,
|
|
mp4_cloud: tableRecord.mp4_cloud,
|
|
snapshot_cloud: tableRecord.snapshot_cloud,
|
|
table_version: tableRecord.table_version,
|
|
};
|
|
}
|
|
else if (record.table_name === "record_crop_picture_info") {
|
|
if (tmpRecord.picture === undefined) {
|
|
tmpRecord.picture = [];
|
|
}
|
|
tmpRecord.picture.push({
|
|
picture_id: tableRecord.picture_id,
|
|
detection_type: tableRecord.detection_type,
|
|
person_id: tableRecord.person_id,
|
|
crop_path: tableRecord.crop_path,
|
|
event_time: date_and_time_1.default.parse(tableRecord.event_time, "YYYY-MM-DD HH:mm:ss"),
|
|
person_recog_flag: tableRecord.person_recog_flag,
|
|
crop_pic_quality: tableRecord.crop_pic_quality,
|
|
pic_marking_flag: tableRecord.pic_marking_flag,
|
|
group_id: tableRecord.group_id,
|
|
crop_id: tableRecord.crop_id,
|
|
start_time: date_and_time_1.default.parse(tableRecord.start_time, "YYYY-MM-DD HH:mm:ss"),
|
|
storage_type: tableRecord.storage_type,
|
|
storage_status: tableRecord.storage_status,
|
|
storage_label: tableRecord.storage_label,
|
|
table_version: tableRecord.table_version,
|
|
update_time: tableRecord.update_time,
|
|
});
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Not implemented - CMD_DATABASE_QUERY_LOCAL - table_name: ${record.table_name}`, { stationSN: this.rawStation.station_sn });
|
|
}
|
|
result.set(tableRecord.record_id, tmpRecord);
|
|
}
|
|
}
|
|
this.emit("database query local", databaseResponse.mIntRet, Array.from(result.values()));
|
|
break;
|
|
}
|
|
case types_1.CommandType.CMD_DATABASE_DELETE: {
|
|
const data = databaseResponse.data;
|
|
let failed_delete = [];
|
|
if (databaseResponse.data !== undefined && data.failed_delete !== "[]")
|
|
failed_delete = data.failed_delete;
|
|
this.emit("database delete", databaseResponse.mIntRet, failed_delete);
|
|
break;
|
|
}
|
|
default:
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Not implemented - CMD_DATABASE message`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[message.commandId], commandId: message.commandId, channel: message.channel, databaseResponse: databaseResponse });
|
|
break;
|
|
}
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DATABASE - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString() } });
|
|
}
|
|
break;
|
|
case types_1.CommandType.CMD_GATEWAYINFO:
|
|
const cipherID = data.subarray(0, 2).readUInt16LE();
|
|
//const unknownNumber = data.subarray(2, 2).readUInt16LE();
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - cipherID`, { stationSN: this.rawStation.station_sn, channel: message.channel, data: data.toString("hex"), cipherID: cipherID });
|
|
const encryptedKey = (0, utils_1.readNullTerminatedBuffer)(data.subarray(4));
|
|
this.api.getCipher(/*this.rawStation.station_sn, */ cipherID, this.rawStation.member.admin_user_id).then((cipher) => {
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - get cipher with cipherID`, { stationSN: this.rawStation.station_sn, channel: message.channel, data: data.toString("hex"), cipherID: cipherID, cipher: JSON.stringify(cipher) });
|
|
if (cipher !== undefined) {
|
|
this.encryption = types_1.EncryptionType.LEVEL_2;
|
|
const rsa = (0, utils_1.getRSAPrivateKey)(cipher.private_key, this.enableEmbeddedPKCS1Support);
|
|
this.p2pKey = rsa.decrypt(encryptedKey);
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - set encryption level 2`, { stationSN: this.rawStation.station_sn, key: this.p2pKey.toString("hex") });
|
|
}
|
|
else {
|
|
this.encryption = types_1.EncryptionType.LEVEL_1;
|
|
this.p2pKey = Buffer.from((0, utils_1.getP2PCommandEncryptionKey)(this.rawStation.station_sn, this.rawStation.p2p_did));
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - set encryption level 1`, { stationSN: this.rawStation.station_sn, key: this.p2pKey.toString("hex") });
|
|
}
|
|
this._clearTimeout(this.messageStates.get(message.seqNo)?.timeout);
|
|
this.p2pSeqMapping.forEach((value, key, map) => {
|
|
if (value === message.seqNo) {
|
|
map.delete(key);
|
|
}
|
|
});
|
|
this.p2pDataSeqNumber--;
|
|
this.messageStates.delete(message.seqNo);
|
|
this.sendQueuedMessage();
|
|
}).catch((err) => {
|
|
const error = (0, error_1.ensureError)(err);
|
|
this.encryption = types_1.EncryptionType.LEVEL_1;
|
|
this.p2pKey = Buffer.from((0, utils_1.getP2PCommandEncryptionKey)(this.rawStation.station_sn, this.rawStation.p2p_did));
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - set encryption level 1 (fallback)`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") }, key: this.p2pKey.toString("hex") });
|
|
this._clearTimeout(this.messageStates.get(message.seqNo)?.timeout);
|
|
this.p2pSeqMapping.forEach((value, key, map) => {
|
|
if (value === message.seqNo) {
|
|
map.delete(key);
|
|
}
|
|
});
|
|
this.p2pDataSeqNumber--;
|
|
this.messageStates.delete(message.seqNo);
|
|
this.sendQueuedMessage();
|
|
});
|
|
break;
|
|
default:
|
|
logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Not implemented`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[message.commandId], commandId: message.commandId, channel: message.channel, data: data.toString("hex") });
|
|
break;
|
|
}
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
|
|
}
|
|
}
|
|
async sendAck(address, dataType, seqNo) {
|
|
const num_pending_acks = 1; // Max possible: 17 in one ack packet
|
|
const pendingAcksBuffer = Buffer.allocUnsafe(2);
|
|
pendingAcksBuffer.writeUInt16BE(num_pending_acks, 0);
|
|
const seqBuffer = Buffer.allocUnsafe(2);
|
|
seqBuffer.writeUInt16BE(seqNo, 0);
|
|
const payload = Buffer.concat([dataType, pendingAcksBuffer, seqBuffer]);
|
|
await this.sendMessage(`Send ack`, address, types_1.RequestMessageType.ACK, payload);
|
|
}
|
|
getDataType(input) {
|
|
if (input.compare(types_1.P2PDataTypeHeader.DATA) === 0) {
|
|
return types_1.P2PDataType.DATA;
|
|
}
|
|
else if (input.compare(types_1.P2PDataTypeHeader.VIDEO) === 0) {
|
|
return types_1.P2PDataType.VIDEO;
|
|
}
|
|
else if (input.compare(types_1.P2PDataTypeHeader.CONTROL) === 0) {
|
|
return types_1.P2PDataType.CONTROL;
|
|
}
|
|
else if (input.compare(types_1.P2PDataTypeHeader.BINARY) === 0) {
|
|
return types_1.P2PDataType.BINARY;
|
|
}
|
|
return types_1.P2PDataType.UNKNOWN;
|
|
}
|
|
async close() {
|
|
this.terminating = true;
|
|
this._clearLookupTimeout();
|
|
this._clearLocalLookupRetryTimeout();
|
|
this._clearLookupRetryTimeout();
|
|
this._clearConnectTimeout();
|
|
this._clearHeartbeatTimeout();
|
|
this._clearMessageStateTimeouts();
|
|
this._clearMessageVideoStateTimeouts();
|
|
this._clearSecondaryCommandTimeout();
|
|
this.sendQueue = [];
|
|
if (this.socket) {
|
|
if (this.connected) {
|
|
await this.sendMessage(`Send end connection`, this.connectAddress, types_1.RequestMessageType.END);
|
|
this._disconnected();
|
|
}
|
|
else {
|
|
this._initialize();
|
|
}
|
|
}
|
|
}
|
|
getHeartbeatInterval() {
|
|
return this.HEARTBEAT_INTERVAL;
|
|
}
|
|
onClose() {
|
|
this.socket.removeAllListeners();
|
|
this.socket = (0, dgram_1.createSocket)("udp4");
|
|
this.socket.on("message", (msg, rinfo) => this.handleMsg(msg, rinfo));
|
|
this.socket.on("error", (error) => this.onError(error));
|
|
this.socket.on("close", () => this.onClose());
|
|
this.binded = false;
|
|
this._disconnected();
|
|
}
|
|
onError(err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.debug(`Socket Error:`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn });
|
|
}
|
|
scheduleHeartbeat() {
|
|
if (this.isConnected()) {
|
|
this.sendPing(this.connectAddress);
|
|
this.heartbeatTimeout = setTimeout(() => {
|
|
this.scheduleHeartbeat();
|
|
}, this.getHeartbeatInterval());
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.debug(`Heartbeat not activated because no connection is present!`, { stationSN: this.rawStation.station_sn });
|
|
}
|
|
}
|
|
scheduleP2PKeepalive() {
|
|
if (this.isConnected()) {
|
|
this.sendCommandPing(http_1.Station.CHANNEL);
|
|
this.keepaliveTimeout = setTimeout(() => {
|
|
this.scheduleP2PKeepalive();
|
|
}, this.KEEPALIVE_INTERVAL);
|
|
this.closeEnergySavingDevice();
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.debug(`P2P keepalive not activated because no connection is present`, { stationSN: this.rawStation.station_sn });
|
|
}
|
|
}
|
|
getDownloadRSAPrivateKey() {
|
|
if (this.currentMessageState[types_1.P2PDataType.BINARY].rsaKey === null) {
|
|
this.currentMessageState[types_1.P2PDataType.BINARY].rsaKey = (0, utils_1.getNewRSAPrivateKey)(this.enableEmbeddedPKCS1Support);
|
|
}
|
|
return this.currentMessageState[types_1.P2PDataType.BINARY].rsaKey;
|
|
}
|
|
setDownloadRSAPrivateKeyPem(pem) {
|
|
this.currentMessageState[types_1.P2PDataType.BINARY].rsaKey = (0, utils_1.getRSAPrivateKey)(pem, this.enableEmbeddedPKCS1Support);
|
|
}
|
|
getRSAPrivateKey() {
|
|
return this.currentMessageState[types_1.P2PDataType.VIDEO].rsaKey;
|
|
}
|
|
initializeStream(datatype) {
|
|
this.currentMessageState[datatype].videoStream?.destroy();
|
|
this.currentMessageState[datatype].audioStream?.destroy();
|
|
this.currentMessageState[datatype].videoStream = null;
|
|
this.currentMessageState[datatype].audioStream = null;
|
|
this.currentMessageState[datatype].videoStream = new stream_1.Readable({ autoDestroy: true,
|
|
// eslint-disable-next-line @typescript-eslint/no-empty-function
|
|
read() { } /*,
|
|
|
|
destroy(this, error, _callback) {
|
|
if (error) {
|
|
this.emit("error", error);
|
|
}
|
|
this.emit("end");
|
|
this.emit("close");
|
|
}*/
|
|
});
|
|
this.currentMessageState[datatype].audioStream = new stream_1.Readable({ autoDestroy: true,
|
|
// eslint-disable-next-line @typescript-eslint/no-empty-function
|
|
read() { } /*,
|
|
|
|
destroy(this, error, _callback) {
|
|
if (error) {
|
|
this.emit("error", error);
|
|
}
|
|
this.emit("end");
|
|
this.emit("close");
|
|
}*/
|
|
});
|
|
this.currentMessageState[datatype].p2pStreaming = false;
|
|
if (this.currentMessageState[datatype].waitForSeqNoTimeout !== undefined) {
|
|
clearTimeout(this.currentMessageState[datatype].waitForSeqNoTimeout);
|
|
this.currentMessageState[datatype].waitForSeqNoTimeout = undefined;
|
|
}
|
|
if (this.currentMessageState[datatype].waitForAudioData !== undefined) {
|
|
clearTimeout(this.currentMessageState[datatype].waitForAudioData);
|
|
this.currentMessageState[datatype].waitForAudioData = undefined;
|
|
}
|
|
}
|
|
endStream(datatype, sendStopCommand = false) {
|
|
if (this.currentMessageState[datatype].p2pStreaming) {
|
|
if (sendStopCommand) {
|
|
switch (datatype) {
|
|
case types_1.P2PDataType.VIDEO:
|
|
this.sendCommandWithInt({
|
|
commandType: types_1.CommandType.CMD_STOP_REALTIME_MEDIA,
|
|
value: this.currentMessageState[datatype].p2pStreamChannel,
|
|
channel: this.currentMessageState[datatype].p2pStreamChannel
|
|
}, {
|
|
command: {
|
|
name: http_1.CommandName.DeviceStopLivestream
|
|
}
|
|
});
|
|
break;
|
|
case types_1.P2PDataType.BINARY:
|
|
this.sendCommandWithInt({
|
|
commandType: types_1.CommandType.CMD_DOWNLOAD_CANCEL,
|
|
value: this.currentMessageState[datatype].p2pStreamChannel,
|
|
strValueSub: this.rawStation.member.admin_user_id,
|
|
channel: this.currentMessageState[datatype].p2pStreamChannel
|
|
}, {
|
|
command: {
|
|
name: http_1.CommandName.DeviceCancelDownload
|
|
}
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
this.currentMessageState[datatype].p2pStreaming = false;
|
|
this.currentMessageState[datatype].videoStream?.push(null);
|
|
this.currentMessageState[datatype].audioStream?.push(null);
|
|
if (this.currentMessageState[datatype].p2pStreamingTimeout) {
|
|
clearTimeout(this.currentMessageState[datatype].p2pStreamingTimeout);
|
|
this.currentMessageState[datatype].p2pStreamingTimeout = undefined;
|
|
}
|
|
if (!this.currentMessageState[datatype].invalidStream && !this.currentMessageState[datatype].p2pStreamNotStarted)
|
|
this.emitStreamStopEvent(datatype);
|
|
if (this.currentMessageState[datatype].queuedData.size > 0) {
|
|
this.expectedSeqNo[datatype] = this._incrementSequence([...this.currentMessageState[datatype].queuedData.keys()][this.currentMessageState[datatype].queuedData.size - 1]);
|
|
}
|
|
this.initializeMessageBuilder(datatype);
|
|
this.initializeMessageState(datatype, this.currentMessageState[datatype].rsaKey);
|
|
this.initializeStream(datatype);
|
|
this.closeEnergySavingDevice();
|
|
}
|
|
}
|
|
endRTSPStream(channel) {
|
|
if (this.currentMessageState[types_1.P2PDataType.DATA].rtspStreaming[channel]) {
|
|
this.currentMessageState[types_1.P2PDataType.DATA].rtspStream[channel] = false;
|
|
this.currentMessageState[types_1.P2PDataType.DATA].rtspStreaming[channel] = false;
|
|
this.emit("rtsp livestream stopped", channel);
|
|
}
|
|
}
|
|
emitStreamStartEvent(datatype) {
|
|
this.currentMessageState[datatype].p2pStreamNotStarted = false;
|
|
if (datatype === types_1.P2PDataType.VIDEO) {
|
|
this.emit("livestream started", this.currentMessageState[datatype].p2pStreamChannel, this.currentMessageState[datatype].p2pStreamMetadata, this.currentMessageState[datatype].videoStream, this.currentMessageState[datatype].audioStream);
|
|
}
|
|
else if (datatype === types_1.P2PDataType.BINARY) {
|
|
this.emit("download started", this.currentMessageState[datatype].p2pStreamChannel, this.currentMessageState[datatype].p2pStreamMetadata, this.currentMessageState[datatype].videoStream, this.currentMessageState[datatype].audioStream);
|
|
}
|
|
}
|
|
emitStreamStopEvent(datatype) {
|
|
if (datatype === types_1.P2PDataType.VIDEO) {
|
|
this.emit("livestream stopped", this.currentMessageState[datatype].p2pStreamChannel);
|
|
}
|
|
else if (datatype === types_1.P2PDataType.BINARY) {
|
|
this.emit("download finished", this.currentMessageState[datatype].p2pStreamChannel);
|
|
}
|
|
}
|
|
isStreaming(channel, datatype) {
|
|
if (this.currentMessageState[datatype].p2pStreamChannel === channel)
|
|
return this.currentMessageState[datatype].p2pStreaming;
|
|
return false;
|
|
}
|
|
isLiveStreaming(channel) {
|
|
return this.isStreaming(channel, types_1.P2PDataType.VIDEO);
|
|
}
|
|
isCurrentlyStreaming() {
|
|
for (const element of Object.values(this.currentMessageState)) {
|
|
if (element.p2pStreaming || element.p2pTalkback)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
isRTSPLiveStreaming(channel) {
|
|
return this.currentMessageState[types_1.P2PDataType.DATA].rtspStreaming[channel] ? this.currentMessageState[types_1.P2PDataType.DATA].rtspStreaming[channel] : false;
|
|
}
|
|
isDownloading(channel) {
|
|
return this.isStreaming(channel, types_1.P2PDataType.BINARY);
|
|
}
|
|
getLockSequenceNumber() {
|
|
if (this.lockSeqNumber === -1) {
|
|
let deviceType = undefined;
|
|
let deviceSN = undefined;
|
|
if (this.rawStation?.devices?.length > 0) {
|
|
deviceType = this.rawStation?.devices[0]?.device_type;
|
|
deviceSN = this.rawStation?.devices[0]?.device_sn;
|
|
}
|
|
this.lockSeqNumber = (0, utils_1.generateLockSequence)(deviceType, deviceSN);
|
|
}
|
|
return this.lockSeqNumber;
|
|
}
|
|
incLockSequenceNumber() {
|
|
if (this.lockSeqNumber === -1) {
|
|
this.getLockSequenceNumber();
|
|
}
|
|
else
|
|
this.lockSeqNumber++;
|
|
return this.lockSeqNumber;
|
|
}
|
|
setConnectionType(type) {
|
|
this.connectionType = type;
|
|
}
|
|
getConnectionType() {
|
|
return this.connectionType;
|
|
}
|
|
isEnergySavingDevice() {
|
|
return this.energySavingDevice;
|
|
}
|
|
async getDSKKeys() {
|
|
if (this.api.isConnected()) {
|
|
try {
|
|
const data = {
|
|
invalid_dsks: {},
|
|
station_sns: [this.rawStation.station_sn],
|
|
transaction: `${new Date().getTime()}`
|
|
};
|
|
data.invalid_dsks[this.rawStation.station_sn] = "";
|
|
const response = await this.api.request({
|
|
method: "post",
|
|
endpoint: "v1/app/equipment/get_dsk_keys",
|
|
data: data
|
|
});
|
|
logging_1.rootP2PLogger.debug(`Get DSK keys - Response:`, { stationSN: this.rawStation.station_sn, data: response.data });
|
|
if (response.status == 200) {
|
|
const result = response.data;
|
|
if (result.code == 0) {
|
|
const dataresult = result.data;
|
|
dataresult.dsk_keys.forEach(key => {
|
|
if (key.station_sn == this.rawStation.station_sn) {
|
|
this.dskKey = key.dsk_key;
|
|
this.dskExpiration = new Date(key.expiration * 1000);
|
|
logging_1.rootP2PLogger.debug(`Get DSK keys - received key and expiration`, { stationSN: this.rawStation.station_sn, dskKey: this.dskKey, dskExpiration: this.dskExpiration });
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.error(`Get DSK keys - Response code not ok`, { stationSN: this.rawStation.station_sn, code: result.code, msg: result.msg });
|
|
}
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.error(`Get DSK keys - Status return code not 200`, { stationSN: this.rawStation.station_sn, status: response.status, statusText: response.statusText });
|
|
}
|
|
}
|
|
catch (err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.error(`Get DSK keys - Generic Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn });
|
|
}
|
|
}
|
|
}
|
|
updateRawStation(value) {
|
|
this.rawStation = value;
|
|
this.channel = http_1.Station.getChannel(value.device_type);
|
|
if (this.rawStation.devices?.length > 0) {
|
|
if (!this.energySavingDevice) {
|
|
for (const device of this.rawStation.devices) {
|
|
if (device.device_sn === this.rawStation.station_sn && device_1.Device.hasBattery(device.device_type)) {
|
|
this.energySavingDevice = true;
|
|
break;
|
|
}
|
|
}
|
|
if (this.energySavingDevice)
|
|
logging_1.rootP2PLogger.debug(`Identified standalone battery device ${this.rawStation.station_sn} => activate p2p keepalive command`);
|
|
}
|
|
}
|
|
else {
|
|
this.energySavingDevice = false;
|
|
}
|
|
if (this.rawStation.devices)
|
|
for (const device of this.rawStation.devices) {
|
|
this.deviceSNs[device.device_channel] = {
|
|
sn: device.device_sn,
|
|
adminUserId: this.rawStation.member.admin_user_id
|
|
};
|
|
}
|
|
}
|
|
initializeTalkbackStream(channel = 0) {
|
|
this.talkbackStream = new talkback_1.TalkbackStream();
|
|
this.talkbackStream.on("data", (audioData) => { this.sendTalkbackAudioFrame(audioData, channel); });
|
|
this.talkbackStream.on("error", (error) => { this.onTalkbackStreamError(error); });
|
|
this.talkbackStream.on("close", () => { this.onTalkbackStreamClose(); });
|
|
}
|
|
sendTalkbackAudioFrame(audioData, channel) {
|
|
const messageHeader = (0, utils_1.buildCommandHeader)(this.videoSeqNumber, types_1.CommandType.CMD_AUDIO_FRAME, types_1.P2PDataTypeHeader.VIDEO);
|
|
const messageAudioHeader = (0, utils_1.buildTalkbackAudioFrameHeader)(audioData, channel);
|
|
const messageData = Buffer.concat([messageHeader, messageAudioHeader, audioData]);
|
|
const message = {
|
|
sequence: this.videoSeqNumber,
|
|
channel: channel,
|
|
data: messageData,
|
|
retries: 0
|
|
};
|
|
this.videoSeqNumber = this._incrementSequence(this.videoSeqNumber);
|
|
this._sendVideoData(message);
|
|
}
|
|
onTalkbackStreamClose() {
|
|
this.talkbackStream?.removeAllListeners();
|
|
}
|
|
onTalkbackStreamError(err) {
|
|
const error = (0, error_1.ensureError)(err);
|
|
logging_1.rootP2PLogger.debug(`Talkback Stream Error:`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn });
|
|
}
|
|
async _sendVideoData(message) {
|
|
if (message.retries < this.MAX_RETRIES) {
|
|
message.retries++;
|
|
}
|
|
else {
|
|
logging_1.rootP2PLogger.error(`Sending video data - Max send video data retries ${this.messageVideoStates.get(message.sequence)?.retries} reached. Discard data.`, { stationSN: this.rawStation.station_sn, sequence: message.sequence, channel: message.channel, retries: message.retries });
|
|
this.messageVideoStates.delete(message.sequence);
|
|
this.emit("talkback error", message.channel, new error_1.TalkbackError("Max send video data retries reached. Discard data packet.", { context: { station: this.rawStation.station_sn, channel: message.channel, retries: message.retries } }));
|
|
return;
|
|
}
|
|
message = message;
|
|
message.timeout = setTimeout(() => {
|
|
this._sendVideoData(message);
|
|
}, this.MAX_AKNOWLEDGE_TIMEOUT);
|
|
this.messageVideoStates.set(message.sequence, message);
|
|
logging_1.rootP2PLogger.trace("Sending p2p video data...", { station: this.rawStation.station_sn, sequence: message.sequence, channel: message.channel, retries: message.retries, messageVideoStatesSize: this.messageVideoStates.size });
|
|
await this.sendMessage(`Send video data`, this.connectAddress, types_1.RequestMessageType.DATA, message.data);
|
|
}
|
|
isTalkbackOngoing(channel) {
|
|
if (this.currentMessageState[types_1.P2PDataType.VIDEO].p2pTalkbackChannel === channel)
|
|
return this.currentMessageState[types_1.P2PDataType.VIDEO].p2pTalkback;
|
|
return false;
|
|
}
|
|
startTalkback(channel = 0) {
|
|
this.currentMessageState[types_1.P2PDataType.VIDEO].p2pTalkback = true;
|
|
this.currentMessageState[types_1.P2PDataType.VIDEO].p2pTalkbackChannel = channel;
|
|
this.initializeTalkbackStream(channel);
|
|
this.talkbackStream?.startTalkback();
|
|
this.emit("talkback started", channel, this.talkbackStream);
|
|
}
|
|
stopTalkback(channel = 0) {
|
|
this.currentMessageState[types_1.P2PDataType.VIDEO].p2pTalkback = false;
|
|
this.currentMessageState[types_1.P2PDataType.VIDEO].p2pTalkbackChannel = -1;
|
|
this.talkbackStream?.stopTalkback();
|
|
this.emit("talkback stopped", channel);
|
|
this.closeEnergySavingDevice();
|
|
}
|
|
setLockAESKey(commandCode, aesKey) {
|
|
this.lockAESKeys.set(commandCode, aesKey);
|
|
}
|
|
getLockAESKey(commandCode) {
|
|
return this.lockAESKeys.get(commandCode);
|
|
}
|
|
isConnecting() {
|
|
return this.connecting;
|
|
}
|
|
}
|
|
exports.P2PClientProtocol = P2PClientProtocol;
|
|
//# sourceMappingURL=session.js.map
|