@homebridge-eufy-security/eufy-security-client 3.7.2-dev.0

package/build/push/service.js

@@ -0,0 +1,965 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PushNotificationService = void 0;
+const qs = __importStar(require("qs"));
+const tiny_typed_emitter_1 = require("tiny-typed-emitter");
+const utils_1 = require("./utils");
+const client_1 = require("./client");
+const device_1 = require("../http/device");
+const types_1 = require("../http/types");
+const utils_2 = require("../http/utils");
+const utils_3 = require("../utils");
+const error_1 = require("./error");
+const error_2 = require("../error");
+const logging_1 = require("../logging");
+const _1 = require(".");
+const station_1 = require("../http/station");
+class PushNotificationService extends tiny_typed_emitter_1.TypedEmitter {
+    APP_PACKAGE = "com.oceanwing.battery.cam";
+    APP_ID = "1:348804314802:android:440a6773b3620da7";
+    APP_SENDER_ID = "348804314802";
+    APP_CERT_SHA1 = "F051262F9F99B638F3C76DE349830638555B4A0A";
+    FCM_PROJECT_ID = "batterycam-3250a";
+    GOOGLE_API_KEY = "AIzaSyCSz1uxGrHXsEktm7O3_wv-uLGpC9BvXR8";
+    AUTH_VERSION = "FIS_v2";
+    pushClient;
+    credentialsTimeout;
+    retryTimeout;
+    retryDelay = 0;
+    credentials;
+    persistentIds = [];
+    connected = false;
+    connecting = false;
+    got;
+    constructor() {
+        super();
+    }
+    async loadLibraries() {
+        const { default: got } = await import("got");
+        this.got = got;
+    }
+    static async initialize() {
+        const service = new PushNotificationService();
+        await service.loadLibraries();
+        return service;
+    }
+    buildExpiresAt(expiresIn) {
+        if (expiresIn.endsWith("ms")) {
+            return new Date().getTime() + Number.parseInt(expiresIn.substring(0, expiresIn.length - 2));
+        }
+        else if (expiresIn.endsWith("s")) {
+            return new Date().getTime() + Number.parseInt(expiresIn.substring(0, expiresIn.length - 1)) * 1000;
+        }
+        throw new error_1.UnknownExpiryFormaError("Unknown expiresIn-format", { context: { format: expiresIn } });
+    }
+    async registerFid(fid) {
+        const url = `https://firebaseinstallations.googleapis.com/v1/projects/${this.FCM_PROJECT_ID}/installations`;
+        try {
+            const response = await this.got(url, {
+                method: "post",
+                json: {
+                    fid: fid,
+                    appId: `${this.APP_ID}`,
+                    authVersion: `${this.AUTH_VERSION}`,
+                    sdkVersion: "a:16.3.1",
+                },
+                headers: {
+                    "X-Android-Package": `${this.APP_PACKAGE}`,
+                    "X-Android-Cert": `${this.APP_CERT_SHA1}`,
+                    "x-goog-api-key": `${this.GOOGLE_API_KEY}`,
+                },
+                responseType: "json",
+                http2: false,
+                throwHttpErrors: false,
+                retry: {
+                    limit: 3,
+                    methods: ["POST"],
+                },
+                hooks: {
+                    beforeError: [
+                        (error) => {
+                            const { response, options } = error;
+                            const statusCode = response?.statusCode || 0;
+                            const { method, url, prefixUrl } = options;
+                            const shortUrl = (0, utils_3.getShortUrl)(typeof url === "string" ? new URL(url) : url === undefined ? new URL("") : url, typeof prefixUrl === "string" ? prefixUrl : prefixUrl.toString());
+                            const body = response?.body ? response.body : error.message;
+                            if (response?.body) {
+                                error.name = "RegisterFidError";
+                                error.message = `${statusCode} ${method} ${shortUrl}\n${body}`;
+                            }
+                            return error;
+                        },
+                    ],
+                },
+            });
+            if (response.statusCode == 200) {
+                const result = response.body;
+                return {
+                    ...result,
+                    authToken: {
+                        ...result.authToken,
+                        expiresAt: this.buildExpiresAt(result.authToken.expiresIn),
+                    },
+                };
+            }
+            else {
+                logging_1.rootPushLogger.error("Register FID - Status return code not 200", {
+                    status: response.statusCode,
+                    statusText: response.statusMessage,
+                    data: response.body,
+                });
+                throw new error_1.FidRegistrationFailedError("FID registration failed", {
+                    context: { status: response.statusCode, statusText: response.statusMessage, data: response.body },
+                });
+            }
+        }
+        catch (err) {
+            const error = (0, error_2.ensureError)(err);
+            logging_1.rootPushLogger.error("Register FID - Generic Error", { error: (0, utils_3.getError)(error) });
+            throw new error_1.FidRegistrationFailedError("FID registration failed", { cause: error, context: { fid: fid } });
+        }
+    }
+    async renewFidToken(fid, refreshToken) {
+        const url = `https://firebaseinstallations.googleapis.com/v1/projects/${this.FCM_PROJECT_ID}/installations/${fid}/authTokens:generate`;
+        try {
+            const response = await this.got(url, {
+                method: "post",
+                json: {
+                    installation: {
+                        appId: `${this.APP_ID}`,
+                        sdkVersion: "a:16.3.1",
+                    },
+                },
+                headers: {
+                    "X-Android-Package": `${this.APP_PACKAGE}`,
+                    "X-Android-Cert": `${this.APP_CERT_SHA1}`,
+                    "x-goog-api-key": `${this.GOOGLE_API_KEY}`,
+                    Authorization: `${this.AUTH_VERSION} ${refreshToken}`,
+                },
+                responseType: "json",
+                http2: false,
+                throwHttpErrors: false,
+                retry: {
+                    limit: 3,
+                    methods: ["POST"],
+                },
+                hooks: {
+                    beforeError: [
+                        (error) => {
+                            const { response, options } = error;
+                            const statusCode = response?.statusCode || 0;
+                            const { method, url, prefixUrl } = options;
+                            const shortUrl = (0, utils_3.getShortUrl)(typeof url === "string" ? new URL(url) : url === undefined ? new URL("") : url, typeof prefixUrl === "string" ? prefixUrl : prefixUrl.toString());
+                            const body = response?.body ? response.body : error.message;
+                            if (response?.body) {
+                                error.name = "RenewFidTokenError";
+                                error.message = `${statusCode} ${method} ${shortUrl}\n${body}`;
+                            }
+                            return error;
+                        },
+                    ],
+                },
+            });
+            if (response.statusCode == 200) {
+                const result = response.body;
+                return {
+                    ...result,
+                    expiresAt: this.buildExpiresAt(result.expiresIn),
+                };
+            }
+            else {
+                logging_1.rootPushLogger.error("Renew FID Token - Status return code not 200", {
+                    status: response.statusCode,
+                    statusText: response.statusMessage,
+                    data: response.body,
+                });
+                throw new error_1.RenewFidTokenFailedError("FID Token renewal failed", {
+                    context: { status: response.statusCode, statusText: response.statusMessage, data: response.body },
+                });
+            }
+        }
+        catch (err) {
+            const error = (0, error_2.ensureError)(err);
+            logging_1.rootPushLogger.error("Renew FID Token - Generic Error", { error: (0, utils_3.getError)(error) });
+            throw new error_1.RenewFidTokenFailedError("FID Token renewal failed", {
+                cause: error,
+                context: { fid: fid, refreshToken: refreshToken },
+            });
+        }
+    }
+    async createPushCredentials() {
+        const generatedFid = (0, utils_1.generateFid)();
+        return await this.registerFid(generatedFid)
+            .then(async (registerFidResponse) => {
+            const checkinResponse = await this.executeCheckin();
+            return {
+                fidResponse: registerFidResponse,
+                checkinResponse: checkinResponse,
+            };
+        })
+            .then(async (result) => {
+            const registerGcmResponse = await this.registerGcm(result.fidResponse, result.checkinResponse);
+            return {
+                ...result,
+                gcmResponse: registerGcmResponse,
+            };
+        })
+            .catch((err) => {
+            const error = (0, error_2.ensureError)(err);
+            throw error;
+        });
+    }
+    async renewPushCredentials(credentials) {
+        return await this.renewFidToken(credentials.fidResponse.fid, credentials.fidResponse.refreshToken)
+            .then(async (response) => {
+            credentials.fidResponse.authToken = response;
+            return await this.executeCheckin();
+        })
+            .then(async (response) => {
+            const registerGcmResponse = await this.registerGcm(credentials.fidResponse, response);
+            return {
+                fidResponse: credentials.fidResponse,
+                checkinResponse: response,
+                gcmResponse: registerGcmResponse,
+            };
+        })
+            .catch(() => {
+            return this.createPushCredentials();
+        });
+    }
+    async loginPushCredentials(credentials) {
+        logging_1.rootPushLogger.info("fidresponse", credentials.fidResponse);
+        return await this.executeCheckin()
+            .then(async (response) => {
+            const registerGcmResponse = await this.registerGcm(credentials.fidResponse, response);
+            return {
+                fidResponse: credentials.fidResponse,
+                checkinResponse: response,
+                gcmResponse: registerGcmResponse,
+            };
+        })
+            .catch(() => {
+            return this.createPushCredentials();
+        });
+    }
+    async executeCheckin() {
+        const url = "https://android.clients.google.com/checkin";
+        try {
+            const buffer = await (0, utils_1.buildCheckinRequest)();
+            const response = await this.got(url, {
+                method: "post",
+                body: Buffer.from(buffer),
+                headers: {
+                    "Content-Type": "application/x-protobuf",
+                },
+                responseType: "buffer",
+                http2: false,
+                throwHttpErrors: false,
+                retry: {
+                    limit: 3,
+                    methods: ["POST"],
+                },
+                hooks: {
+                    beforeError: [
+                        (error) => {
+                            const { response, options } = error;
+                            const statusCode = response?.statusCode || 0;
+                            const { method, url, prefixUrl } = options;
+                            const shortUrl = (0, utils_3.getShortUrl)(typeof url === "string" ? new URL(url) : url === undefined ? new URL("") : url, typeof prefixUrl === "string" ? prefixUrl : prefixUrl.toString());
+                            const body = response?.body ? response.body : error.message;
+                            if (response?.body) {
+                                error.name = "ExecuteCheckInError";
+                                error.message = `${statusCode} ${method} ${shortUrl}\n${body}`;
+                            }
+                            return error;
+                        },
+                    ],
+                },
+            });
+            if (response.statusCode == 200) {
+                return await (0, utils_1.parseCheckinResponse)(response.body);
+            }
+            else {
+                logging_1.rootPushLogger.error("Check in - Status return code not 200", {
+                    status: response.statusCode,
+                    statusText: response.statusMessage,
+                    data: response.body,
+                });
+                throw new error_1.ExecuteCheckInError("Google checkin failed", {
+                    context: { status: response.statusCode, statusText: response.statusMessage, data: response.body },
+                });
+            }
+        }
+        catch (err) {
+            const error = (0, error_2.ensureError)(err);
+            logging_1.rootPushLogger.error("Check in - Generic Error", { error: (0, utils_3.getError)(error) });
+            throw new error_1.ExecuteCheckInError("Google checkin failed", { cause: error });
+        }
+    }
+    async registerGcm(fidInstallationResponse, checkinResponse) {
+        const url = "https://android.clients.google.com/c2dm/register3";
+        const androidId = checkinResponse.androidId;
+        const fid = fidInstallationResponse.fid;
+        const securityToken = checkinResponse.securityToken;
+        const retry = 5;
+        try {
+            for (let retry_count = 1; retry_count <= retry; retry_count++) {
+                logging_1.rootPushLogger.debug(`Register GCM - Attempt ${retry_count} of ${retry}`, {
+                    androidId: androidId,
+                    fid: fid,
+                    securityToken: securityToken,
+                });
+                const response = await this.got(url, {
+                    method: "post",
+                    body: qs.stringify({
+                        "X-subtype": `${this.APP_SENDER_ID}`,
+                        sender: `${this.APP_SENDER_ID}`,
+                        "X-app_ver": "741",
+                        "X-osv": "25",
+                        "X-cliv": "fiid-20.2.0",
+                        "X-gmsv": "201216023",
+                        "X-appid": `${fid}`,
+                        "X-scope": "*",
+                        "X-Goog-Firebase-Installations-Auth": `${fidInstallationResponse.authToken.token}`,
+                        "X-gmp_app_id": `${this.APP_ID}`,
+                        "X-Firebase-Client": "fire-abt/17.1.1+fire-installations/16.3.1+fire-android/+fire-analytics/17.4.2+fire-iid/20.2.0+fire-rc/17.0.0+fire-fcm/20.2.0+fire-cls/17.0.0+fire-cls-ndk/17.0.0+fire-core/19.3.0",
+                        "X-firebase-app-name-hash": "R1dAH9Ui7M-ynoznwBdw01tLxhI",
+                        "X-Firebase-Client-Log-Type": "1",
+                        "X-app_ver_name": "v2.2.2_741",
+                        app: `${this.APP_PACKAGE}`,
+                        device: `${androidId}`,
+                        app_ver: "741",
+                        info: "g3EMJXXElLwaQEb1aBJ6XhxiHjPTUxc",
+                        gcm_ver: "201216023",
+                        plat: "0",
+                        cert: `${this.APP_CERT_SHA1}`,
+                        target_ver: "28",
+                    }),
+                    headers: {
+                        Authorization: `AidLogin ${androidId}:${securityToken}`,
+                        app: `${this.APP_PACKAGE}`,
+                        gcm_ver: "201216023",
+                        "User-Agent": "Android-GCM/1.5",
+                        "content-type": "application/x-www-form-urlencoded",
+                    },
+                    http2: false,
+                    throwHttpErrors: false,
+                    retry: {
+                        limit: 3,
+                        methods: ["POST"],
+                    },
+                    hooks: {
+                        beforeError: [
+                            (error) => {
+                                const { response, options } = error;
+                                const statusCode = response?.statusCode || 0;
+                                const { method, url, prefixUrl } = options;
+                                const shortUrl = (0, utils_3.getShortUrl)(typeof url === "string" ? new URL(url) : url === undefined ? new URL("") : url, typeof prefixUrl === "string" ? prefixUrl : prefixUrl.toString());
+                                const body = response?.body ? response.body : error.message;
+                                if (response?.body) {
+                                    error.name = "RegisterGcmError";
+                                    error.message = `${statusCode} ${method} ${shortUrl}\n${body}`;
+                                }
+                                return error;
+                            },
+                        ],
+                    },
+                });
+                if (response.statusCode == 200) {
+                    const result = response.body.split("=");
+                    if (result[0] == "Error") {
+                        logging_1.rootPushLogger.debug("GCM register error, retry...", {
+                            retry: retry,
+                            retryCount: retry_count,
+                            response: response.body,
+                        });
+                        if (retry_count == retry)
+                            throw new error_1.RegisterGcmError("Max GCM registration retries reached", {
+                                context: { message: result[1], retry: retry, retryCount: retry_count },
+                            });
+                    }
+                    else {
+                        return {
+                            token: result[1],
+                        };
+                    }
+                }
+                else {
+                    logging_1.rootPushLogger.error("Register GCM - Status return code not 200", {
+                        status: response.statusCode,
+                        statusText: response.statusMessage,
+                        data: response.body,
+                    });
+                    throw new error_1.RegisterGcmError("Google register to GCM failed", {
+                        context: { status: response.statusCode, statusText: response.statusMessage, data: response.body },
+                    });
+                }
+                await (0, utils_1.sleep)(10000 * retry_count);
+            }
+            throw new error_1.RegisterGcmError("Max GCM registration retries reached");
+        }
+        catch (err) {
+            const error = (0, error_2.ensureError)(err);
+            logging_1.rootPushLogger.error("Register GCM - Generic Error", { error: (0, utils_3.getError)(error) });
+            throw new error_1.RegisterGcmError("Google register to GCM failed", {
+                cause: error,
+                context: { fidInstallationResponse: fidInstallationResponse, checkinResponse: checkinResponse },
+            });
+        }
+    }
+    _normalizePushMessage(message) {
+        const normalizedMessage = {
+            name: "",
+            event_time: 0,
+            type: -1,
+            station_sn: "",
+            device_sn: "",
+        };
+        if (message.payload.payload) {
+            const payload = message.payload;
+            // CusPush
+            try {
+                normalizedMessage.type = Number.parseInt(payload.type);
+            }
+            catch (err) {
+                const error = (0, error_2.ensureError)(err);
+                logging_1.rootPushLogger.error(`Normalize push message - type - Error`, { error: (0, utils_3.getError)(error), message: message });
+            }
+            if (normalizedMessage.type in _1.ServerPushEvent) {
+                // server push notification
+                const serverPushData = payload.payload;
+                normalizedMessage.email = serverPushData.email;
+                normalizedMessage.person_name = serverPushData.nick_name;
+                normalizedMessage.verify_code = serverPushData.verify_code;
+                switch (normalizedMessage.type) {
+                    case _1.ServerPushEvent.ALARM_NOTIFY:
+                    case _1.ServerPushEvent.ALARM_GUEST_NOTIFY:
+                        const alarmPushData = payload.payload;
+                        normalizedMessage.device_sn = alarmPushData.device_sn;
+                        normalizedMessage.station_sn = alarmPushData.station_sn;
+                        normalizedMessage.alarm_status = alarmPushData.alarm_status;
+                        normalizedMessage.alarm_action = alarmPushData.alarm_action_channel;
+                        try {
+                            normalizedMessage.alarm_type = Number.parseInt(alarmPushData.alarm_id);
+                        }
+                        catch (err) {
+                            const error = (0, error_2.ensureError)(err);
+                            logging_1.rootPushLogger.error(`Normalize push message - alarm_type - Error`, {
+                                error: (0, utils_3.getError)(error),
+                                message: message,
+                            });
+                        }
+                        try {
+                            normalizedMessage.event_time =
+                                alarmPushData.alert_time !== undefined
+                                    ? (0, utils_1.convertTimestampMs)(alarmPushData.alert_time)
+                                    : Number.parseInt(alarmPushData.alert_time);
+                        }
+                        catch (err) {
+                            const error = (0, error_2.ensureError)(err);
+                            logging_1.rootPushLogger.error(`Normalize push message - event_time - Error`, {
+                                error: (0, utils_3.getError)(error),
+                                message: message,
+                            });
+                        }
+                        break;
+                }
+            }
+            else {
+                try {
+                    normalizedMessage.event_time =
+                        payload.event_time !== undefined
+                            ? (0, utils_1.convertTimestampMs)(Number.parseInt(payload.event_time))
+                            : Number.parseInt(payload.event_time);
+                }
+                catch (err) {
+                    const error = (0, error_2.ensureError)(err);
+                    logging_1.rootPushLogger.error(`Normalize push message - Type ${types_1.DeviceType[normalizedMessage.type]} CusPush - event_time - Error`, { error: (0, utils_3.getError)(error), message: message });
+                }
+                try {
+                    normalizedMessage.push_time =
+                        payload.push_time !== undefined
+                            ? (0, utils_1.convertTimestampMs)(Number.parseInt(payload.push_time))
+                            : Number.parseInt(payload.push_time);
+                }
+                catch (err) {
+                    const error = (0, error_2.ensureError)(err);
+                    logging_1.rootPushLogger.error(`Normalize push message - Type ${types_1.DeviceType[normalizedMessage.type]} CusPush - push_time - Error`, { error: (0, utils_3.getError)(error), message: message });
+                }
+                normalizedMessage.station_sn = payload.station_sn;
+                normalizedMessage.title = payload.title;
+                normalizedMessage.content = payload.content;
+                if (normalizedMessage.type === types_1.DeviceType.FLOODLIGHT)
+                    normalizedMessage.device_sn = payload.station_sn;
+                else
+                    normalizedMessage.device_sn = payload.device_sn;
+                if ((0, utils_3.isEmpty)(normalizedMessage.device_sn) && !(0, utils_3.isEmpty)(normalizedMessage.station_sn)) {
+                    normalizedMessage.device_sn = normalizedMessage.station_sn;
+                }
+                if (station_1.Station.isStationHomeBase3(normalizedMessage.type) ||
+                    (normalizedMessage.station_sn.startsWith("T8030") && device_1.Device.isCamera(normalizedMessage.type))) {
+                    const platformPushData = payload.payload;
+                    normalizedMessage.name = platformPushData.name ? platformPushData.name : "";
+                    normalizedMessage.channel = platformPushData.channel !== undefined ? platformPushData.channel : 0;
+                    normalizedMessage.cipher = platformPushData.cipher !== undefined ? platformPushData.cipher : 0;
+                    normalizedMessage.event_session =
+                        platformPushData.session_id !== undefined ? platformPushData.session_id : "";
+                    normalizedMessage.event_type =
+                        platformPushData.a !== undefined ? platformPushData.a : platformPushData.event_type;
+                    normalizedMessage.file_path = platformPushData.file_path !== undefined ? platformPushData.file_path : "";
+                    normalizedMessage.pic_url = platformPushData.pic_url !== undefined ? platformPushData.pic_url : "";
+                    normalizedMessage.push_count = platformPushData.push_count !== undefined ? platformPushData.push_count : 1;
+                    normalizedMessage.notification_style = platformPushData.notification_style;
+                    normalizedMessage.storage_type =
+                        platformPushData.storage_type !== undefined ? platformPushData.storage_type : 1;
+                    normalizedMessage.msg_type = platformPushData.msg_type;
+                    normalizedMessage.person_name = platformPushData.nick_name;
+                    normalizedMessage.person_id = platformPushData.person_id;
+                    normalizedMessage.tfcard_status = platformPushData.tfcard_status;
+                    normalizedMessage.user_type = platformPushData.user;
+                    normalizedMessage.user_name = platformPushData.user_name;
+                    normalizedMessage.station_guard_mode = platformPushData.arming;
+                    normalizedMessage.station_current_mode = platformPushData.mode;
+                    normalizedMessage.alarm_delay = platformPushData.alarm_delay;
+                    normalizedMessage.sound_alarm =
+                        platformPushData.alarm !== undefined ? (platformPushData.alarm === 1 ? true : false) : undefined;
+                }
+                else if (device_1.Device.isBatteryDoorbell(normalizedMessage.type) ||
+                    device_1.Device.isWiredDoorbellDual(normalizedMessage.type)) {
+                    const batteryDoorbellPushData = payload.payload;
+                    normalizedMessage.name = batteryDoorbellPushData.name ? batteryDoorbellPushData.name : "";
+                    //Get family face names from Doorbell Dual "Family Recognition" event
+                    if (batteryDoorbellPushData.objects !== undefined) {
+                        normalizedMessage.person_name =
+                            batteryDoorbellPushData.objects.names !== undefined
+                                ? batteryDoorbellPushData.objects.names.join(",")
+                                : "";
+                    }
+                    if (normalizedMessage.person_name === "") {
+                        normalizedMessage.person_name = batteryDoorbellPushData.nick_name;
+                    }
+                    normalizedMessage.channel =
+                        batteryDoorbellPushData.channel !== undefined ? batteryDoorbellPushData.channel : 0;
+                    normalizedMessage.cipher = batteryDoorbellPushData.cipher !== undefined ? batteryDoorbellPushData.cipher : 0;
+                    normalizedMessage.event_session =
+                        batteryDoorbellPushData.session_id !== undefined ? batteryDoorbellPushData.session_id : "";
+                    normalizedMessage.event_type = batteryDoorbellPushData.event_type;
+                    normalizedMessage.file_path =
+                        batteryDoorbellPushData.file_path !== undefined &&
+                            batteryDoorbellPushData.file_path !== "" &&
+                            batteryDoorbellPushData.channel !== undefined
+                            ? (0, utils_2.getAbsoluteFilePath)(normalizedMessage.type, batteryDoorbellPushData.channel, batteryDoorbellPushData.file_path)
+                            : "";
+                    normalizedMessage.pic_url =
+                        batteryDoorbellPushData.pic_url !== undefined ? batteryDoorbellPushData.pic_url : "";
+                    normalizedMessage.push_count =
+                        batteryDoorbellPushData.push_count !== undefined ? batteryDoorbellPushData.push_count : 1;
+                    normalizedMessage.notification_style = batteryDoorbellPushData.notification_style;
+                }
+                else if (device_1.Device.isIndoorCamera(normalizedMessage.type) ||
+                    device_1.Device.isSoloCameras(normalizedMessage.type) ||
+                    device_1.Device.isWallLightCam(normalizedMessage.type) ||
+                    device_1.Device.isOutdoorPanAndTiltCamera(normalizedMessage.type) ||
+                    device_1.Device.isFloodLightT8420X(normalizedMessage.type, normalizedMessage.device_sn) ||
+                    (device_1.Device.isFloodLight(normalizedMessage.type) && normalizedMessage.type !== types_1.DeviceType.FLOODLIGHT)) {
+                    const indoorPushData = payload.payload;
+                    normalizedMessage.name = indoorPushData.name ? indoorPushData.name : "";
+                    normalizedMessage.channel = indoorPushData.channel;
+                    normalizedMessage.cipher = indoorPushData.cipher;
+                    normalizedMessage.event_session = indoorPushData.session_id;
+                    normalizedMessage.event_type = indoorPushData.event_type;
+                    //normalizedMessage.file_path = indoorPushData.file_path !== undefined && indoorPushData.file_path !== "" && indoorPushData.channel !== undefined ? getAbsoluteFilePath(normalizedMessage.type, indoorPushData.channel, indoorPushData.file_path) : "";
+                    normalizedMessage.file_path = indoorPushData.file_path;
+                    normalizedMessage.pic_url = indoorPushData.pic_url !== undefined ? indoorPushData.pic_url : "";
+                    normalizedMessage.push_count = indoorPushData.push_count !== undefined ? indoorPushData.push_count : 1;
+                    normalizedMessage.notification_style = indoorPushData.notification_style;
+                    normalizedMessage.msg_type = indoorPushData.msg_type;
+                    normalizedMessage.timeout = indoorPushData.timeout;
+                    normalizedMessage.tfcard_status = indoorPushData.tfcard_status;
+                    normalizedMessage.storage_type = indoorPushData.storage_type !== undefined ? indoorPushData.storage_type : 1;
+                    normalizedMessage.unique_id = indoorPushData.unique_id;
+                }
+                else if (device_1.Device.isSmartSafe(normalizedMessage.type)) {
+                    const smartSafePushData = payload.payload;
+                    normalizedMessage.event_type = smartSafePushData.event_type;
+                    normalizedMessage.event_value = smartSafePushData.event_value;
+                    /*
+                              event_value: {
+                                  type: 3,    3/4
+                                  action: 1,
+                                  figure_id: 0,
+                                  user_id: 0
+                              }
+                              */
+                    normalizedMessage.name = smartSafePushData.dev_name !== undefined ? smartSafePushData.dev_name : "";
+                    /*normalizedMessage.short_user_id = smartSafePushData.short_user_id !== undefined ? smartSafePushData.short_user_id : "";
+                              normalizedMessage.user_id = smartSafePushData.user_id !== undefined ? smartSafePushData.user_id : "";*/
+                }
+                else if (device_1.Device.isLock(normalizedMessage.type) && !device_1.Device.isLockWifiVideo(normalizedMessage.type)) {
+                    const lockPushData = payload.payload;
+                    normalizedMessage.event_type = lockPushData.event_type;
+                    normalizedMessage.short_user_id = lockPushData.short_user_id !== undefined ? lockPushData.short_user_id : "";
+                    normalizedMessage.user_id = lockPushData.user_id !== undefined ? lockPushData.user_id : "";
+                    normalizedMessage.name = lockPushData.device_name !== undefined ? lockPushData.device_name : "";
+                    normalizedMessage.person_name = lockPushData.nick_name !== undefined ? lockPushData.nick_name : "";
+                }
+                else if (device_1.Device.isLockWifiVideo(normalizedMessage.type)) {
+                    const lockPushData = payload.payload;
+                    normalizedMessage.event_type = lockPushData.event_type;
+                    normalizedMessage.short_user_id = lockPushData.short_user_id !== undefined ? lockPushData.short_user_id : "";
+                    normalizedMessage.user_id = lockPushData.user_id !== undefined ? lockPushData.user_id : "";
+                    normalizedMessage.name = lockPushData.device_name !== undefined ? lockPushData.device_name : "";
+                    normalizedMessage.person_name = lockPushData.nick_name !== undefined ? lockPushData.nick_name : "";
+                }
+                else if (device_1.Device.isGarageCamera(normalizedMessage.type)) {
+                    const garageDoorPushData = payload.payload;
+                    normalizedMessage.event_type = garageDoorPushData.event_type;
+                    normalizedMessage.user_name = garageDoorPushData.user_name !== undefined ? garageDoorPushData.user_name : "";
+                    normalizedMessage.door_id = garageDoorPushData.door_id !== undefined ? garageDoorPushData.door_id : -1;
+                    normalizedMessage.name = garageDoorPushData.door_name !== undefined ? garageDoorPushData.door_name : "";
+                    normalizedMessage.pic_url = garageDoorPushData.pic_url !== undefined ? garageDoorPushData.pic_url : "";
+                    normalizedMessage.file_path = garageDoorPushData.file_path !== undefined ? garageDoorPushData.file_path : "";
+                    normalizedMessage.storage_type =
+                        garageDoorPushData.storage_type !== undefined ? garageDoorPushData.storage_type : 1;
+                    normalizedMessage.power = garageDoorPushData.power !== undefined ? garageDoorPushData.power : undefined;
+                }
+                else {
+                    const cusPushData = payload.payload;
+                    normalizedMessage.name =
+                        cusPushData.device_name && cusPushData.device_name !== null && cusPushData.device_name !== ""
+                            ? cusPushData.device_name
+                            : cusPushData.n
+                                ? cusPushData.n
+                                : cusPushData.name
+                                    ? cusPushData.name
+                                    : "";
+                    normalizedMessage.channel = cusPushData.c ? cusPushData.c : cusPushData.channel;
+                    normalizedMessage.cipher = cusPushData.k ? cusPushData.k : cusPushData.cipher;
+                    normalizedMessage.event_session = cusPushData.session_id;
+                    normalizedMessage.event_type = cusPushData.a ? cusPushData.a : cusPushData.event_type;
+                    normalizedMessage.file_path =
+                        cusPushData.c !== undefined && cusPushData.p !== undefined && cusPushData.p !== ""
+                            ? (0, utils_2.getAbsoluteFilePath)(normalizedMessage.type, cusPushData.c, cusPushData.p)
+                            : cusPushData.file_path
+                                ? cusPushData.file_path
+                                : "";
+                    normalizedMessage.pic_url = cusPushData.pic_url !== undefined ? cusPushData.pic_url : "";
+                    normalizedMessage.push_count = cusPushData.push_count !== undefined ? cusPushData.push_count : 1;
+                    normalizedMessage.notification_style = cusPushData.notification_style;
+                    normalizedMessage.tfcard_status = cusPushData.tfcard;
+                    normalizedMessage.alarm_delay_type = cusPushData.alarm_type;
+                    normalizedMessage.alarm_delay = cusPushData.alarm_delay;
+                    normalizedMessage.alarm_type = cusPushData.type;
+                    normalizedMessage.sound_alarm =
+                        cusPushData.alarm !== undefined ? (cusPushData.alarm === 1 ? true : false) : undefined;
+                    normalizedMessage.user_name = cusPushData.user_name;
+                    normalizedMessage.user_type = cusPushData.user;
+                    normalizedMessage.user_id = cusPushData.user_id;
+                    normalizedMessage.short_user_id = cusPushData.short_user_id;
+                    normalizedMessage.station_guard_mode = cusPushData.arming;
+                    normalizedMessage.station_current_mode = cusPushData.mode;
+                    normalizedMessage.person_name =
+                        cusPushData.f && cusPushData.f !== ""
+                            ? cusPushData.f
+                            : cusPushData.nick_name && cusPushData.nick_name
+                                ? cusPushData.nick_name
+                                : "";
+                    normalizedMessage.sensor_open =
+                        cusPushData.e !== undefined ? (cusPushData.e == "1" ? true : false) : undefined;
+                    normalizedMessage.device_online =
+                        cusPushData.m !== undefined ? (cusPushData.m === 1 ? true : false) : undefined;
+                    try {
+                        normalizedMessage.fetch_id = cusPushData.i !== undefined ? Number.parseInt(cusPushData.i) : undefined;
+                    }
+                    catch (err) {
+                        const error = (0, error_2.ensureError)(err);
+                        logging_1.rootPushLogger.error(`Normalize push message - Type ${types_1.DeviceType[normalizedMessage.type]} CusPushData - fetch_id - Error`, { error: (0, utils_3.getError)(error), message: message });
+                    }
+                    normalizedMessage.sense_id = cusPushData.j;
+                    normalizedMessage.battery_powered =
+                        cusPushData.batt_powered !== undefined ? (cusPushData.batt_powered === 1 ? true : false) : undefined;
+                    try {
+                        normalizedMessage.battery_low =
+                            cusPushData.bat_low !== undefined ? Number.parseInt(cusPushData.bat_low) : undefined;
+                    }
+                    catch (err) {
+                        const error = (0, error_2.ensureError)(err);
+                        logging_1.rootPushLogger.error(`Normalize push message - Type ${types_1.DeviceType[normalizedMessage.type]} CusPushData - battery_low - Error`, { error: (0, utils_3.getError)(error), message: message });
+                    }
+                    normalizedMessage.storage_type = cusPushData.storage_type !== undefined ? cusPushData.storage_type : 1;
+                    normalizedMessage.unique_id = cusPushData.unique_id;
+                    normalizedMessage.automation_id = cusPushData.automation_id;
+                    normalizedMessage.click_action = cusPushData.click_action;
+                    normalizedMessage.news_id = cusPushData.news_id;
+                    normalizedMessage.msg_type = cusPushData.msg_type;
+                    if (device_1.Device.isStarlight4GLTE(normalizedMessage.type)) {
+                        if (cusPushData.channel && cusPushData.channel !== null && cusPushData.channel !== undefined) {
+                            normalizedMessage.channel = cusPushData.channel;
+                        }
+                        if (cusPushData.cipher && cusPushData.cipher !== null && cusPushData.cipher !== undefined) {
+                            normalizedMessage.cipher = cusPushData.cipher;
+                        }
+                        if (cusPushData.event_type && cusPushData.event_type !== null && cusPushData.event_type !== undefined) {
+                            normalizedMessage.event_type = cusPushData.event_type;
+                        }
+                        if (cusPushData.file_path && cusPushData.file_path !== null && cusPushData.file_path !== undefined) {
+                            normalizedMessage.file_path = cusPushData.file_path;
+                        }
+                        normalizedMessage.msg_type = cusPushData.msg_type;
+                    }
+                    else if (device_1.Device.isSmartDrop(normalizedMessage.type)) {
+                        try {
+                            normalizedMessage.open = cusPushData.e !== undefined ? Number.parseInt(cusPushData.e) : 0;
+                        }
+                        catch (err) {
+                            const error = (0, error_2.ensureError)(err);
+                            logging_1.rootPushLogger.error(`Normalize push message - Type ${types_1.DeviceType[normalizedMessage.type]} CusPushData - open - Error`, { error: (0, utils_3.getError)(error), message: message });
+                        }
+                        try {
+                            normalizedMessage.openType = cusPushData.r !== undefined ? Number.parseInt(cusPushData.r) : 0;
+                        }
+                        catch (err) {
+                            const error = (0, error_2.ensureError)(err);
+                            logging_1.rootPushLogger.error(`Normalize push message - Type ${types_1.DeviceType[normalizedMessage.type]} CusPushData - openType - Error`, { error: (0, utils_3.getError)(error), message: message });
+                        }
+                        normalizedMessage.person_name = cusPushData.p;
+                        normalizedMessage.pin = cusPushData.u;
+                        normalizedMessage.channel = cusPushData.channel !== undefined ? cusPushData.channel : 0;
+                        normalizedMessage.cipher = cusPushData.cipher !== undefined ? cusPushData.cipher : 0;
+                        normalizedMessage.event_session = cusPushData.session_id !== undefined ? cusPushData.session_id : "";
+                        normalizedMessage.file_path = cusPushData.file_path !== undefined ? cusPushData.file_path : "";
+                    }
+                }
+            }
+        }
+        else if (message.payload.doorbell !== undefined) {
+            const doorbellPushData = (0, utils_3.parseJSON)(message.payload.doorbell, logging_1.rootPushLogger);
+            if (doorbellPushData !== undefined) {
+                normalizedMessage.name = "Doorbell";
+                normalizedMessage.type = 5;
+                normalizedMessage.event_time =
+                    doorbellPushData.create_time !== undefined
+                        ? (0, utils_1.convertTimestampMs)(doorbellPushData.create_time)
+                        : doorbellPushData.create_time;
+                normalizedMessage.station_sn = doorbellPushData.device_sn;
+                normalizedMessage.device_sn = doorbellPushData.device_sn;
+                normalizedMessage.title = doorbellPushData.title;
+                normalizedMessage.content = doorbellPushData.content;
+                normalizedMessage.push_time =
+                    doorbellPushData.event_time !== undefined
+                        ? (0, utils_1.convertTimestampMs)(doorbellPushData.event_time)
+                        : doorbellPushData.event_time;
+                normalizedMessage.channel = doorbellPushData.channel;
+                normalizedMessage.cipher = doorbellPushData.cipher;
+                normalizedMessage.event_session = doorbellPushData.event_session;
+                normalizedMessage.event_type = doorbellPushData.event_type;
+                normalizedMessage.file_path = doorbellPushData.file_path;
+                normalizedMessage.pic_url = doorbellPushData.pic_url;
+                normalizedMessage.push_count = doorbellPushData.push_count !== undefined ? doorbellPushData.push_count : 1;
+                normalizedMessage.doorbell_url = doorbellPushData.url;
+                normalizedMessage.doorbell_url_ex = doorbellPushData.url_ex;
+                normalizedMessage.doorbell_video_url = doorbellPushData.video_url;
+            }
+        }
+        return normalizedMessage;
+    }
+    onMessage(message) {
+        logging_1.rootPushLogger.debug("Raw push message received", { message: message });
+        this.emit("raw message", message);
+        const normalizedMessage = this._normalizePushMessage(message);
+        logging_1.rootPushLogger.debug("Normalized push message received", { message: normalizedMessage });
+        this.emit("message", normalizedMessage);
+    }
+    getCurrentPushRetryDelay() {
+        const delay = this.retryDelay == 0 ? 5000 : this.retryDelay;
+        if (this.retryDelay < 60000)
+            this.retryDelay += 10000;
+        if (this.retryDelay >= 60000 && this.retryDelay < 600000)
+            this.retryDelay += 60000;
+        return delay;
+    }
+    setCredentials(credentials) {
+        this.credentials = credentials;
+    }
+    getCredentials() {
+        return this.credentials;
+    }
+    setPersistentIds(persistentIds) {
+        this.persistentIds = persistentIds;
+    }
+    getPersistentIds() {
+        return this.persistentIds;
+    }
+    async _open(renew = false, forceNew = false) {
+        if (forceNew ||
+            !this.credentials ||
+            Object.keys(this.credentials).length === 0 ||
+            (this.credentials &&
+                this.credentials.fidResponse &&
+                new Date().getTime() >= this.credentials.fidResponse.authToken.expiresAt)) {
+            logging_1.rootPushLogger.debug(`Create new push credentials...`, { credentials: this.credentials, renew: renew });
+            this.credentials = await this.createPushCredentials().catch((err) => {
+                const error = (0, error_2.ensureError)(err);
+                logging_1.rootPushLogger.error("Create push credentials Error", {
+                    error: (0, utils_3.getError)(error),
+                    credentials: this.credentials,
+                    renew: renew,
+                });
+                return undefined;
+            });
+        }
+        else if (this.credentials && renew) {
+            logging_1.rootPushLogger.debug(`Renew push credentials...`, { credentials: this.credentials, renew: renew });
+            this.credentials = await this.renewPushCredentials(this.credentials).catch((err) => {
+                const error = (0, error_2.ensureError)(err);
+                logging_1.rootPushLogger.error("Push credentials renew Error", {
+                    error: (0, utils_3.getError)(error),
+                    credentials: this.credentials,
+                    renew: renew,
+                });
+                return undefined;
+            });
+        }
+        else {
+            logging_1.rootPushLogger.debug(`Login with previous push credentials...`, { credentials: this.credentials });
+            this.credentials = await this.loginPushCredentials(this.credentials).catch((err) => {
+                const error = (0, error_2.ensureError)(err);
+                logging_1.rootPushLogger.error("Push credentials login Error", {
+                    error: (0, utils_3.getError)(error),
+                    credentials: this.credentials,
+                    renew: renew,
+                });
+                return undefined;
+            });
+        }
+        if (this.credentials) {
+            this.emit("credential", this.credentials);
+            logging_1.rootPushLogger.debug("Push notification token received", {
+                token: this.credentials.gcmResponse.token,
+                credentials: this.credentials,
+            });
+            this.clearCredentialsTimeout();
+            this.credentialsTimeout = setTimeout(async () => {
+                logging_1.rootPushLogger.info("Push notification token is expiring, renew it.");
+                await this._open(true);
+            }, this.credentials.fidResponse.authToken.expiresAt - new Date().getTime() - 60000);
+            if (this.pushClient) {
+                this.pushClient.removeAllListeners();
+            }
+            logging_1.rootPushLogger.debug("Init PushClient with credentials", { credentials: this.credentials });
+            this.pushClient = await client_1.PushClient.init({
+                androidId: this.credentials.checkinResponse.androidId,
+                securityToken: this.credentials.checkinResponse.securityToken,
+            });
+            if (this.persistentIds)
+                this.pushClient.setPersistentIds(this.persistentIds);
+            const token = this.credentials.gcmResponse.token;
+            this.pushClient.on("connect", () => {
+                this.emit("connect", token);
+                this.connected = true;
+                this.connecting = false;
+            });
+            this.pushClient.on("close", () => {
+                this.emit("close");
+                this.connected = false;
+                this.connecting = false;
+            });
+            this.pushClient.on("message", (msg) => this.onMessage(msg));
+            this.pushClient.connect();
+        }
+        else {
+            this.emit("close");
+            this.connected = false;
+            this.connecting = false;
+            logging_1.rootPushLogger.error("Push notifications are disabled, because the registration failed!", {
+                credentials: this.credentials,
+                renew: renew,
+            });
+        }
+    }
+    async open() {
+        if (!this.connecting && !this.connected) {
+            this.connecting = true;
+            await this._open(false, true).catch((err) => {
+                const error = (0, error_2.ensureError)(err);
+                logging_1.rootPushLogger.error(`Got exception trying to initialize push notifications`, {
+                    error: (0, utils_3.getError)(error),
+                    credentials: this.credentials,
+                });
+            });
+            if (!this.credentials) {
+                this.clearRetryTimeout();
+                const delay = this.getCurrentPushRetryDelay();
+                logging_1.rootPushLogger.info(`Retry to register/login for push notification in ${delay / 1000} seconds...`);
+                this.retryTimeout = setTimeout(async () => {
+                    logging_1.rootPushLogger.info(`Retry to register/login for push notification`);
+                    await this.open();
+                }, delay);
+            }
+            else {
+                this.resetRetryTimeout();
+                this.emit("credential", this.credentials);
+            }
+        }
+        return this.credentials;
+    }
+    close() {
+        this.resetRetryTimeout();
+        this.clearCredentialsTimeout();
+        this.pushClient?.close();
+    }
+    clearCredentialsTimeout() {
+        if (this.credentialsTimeout) {
+            clearTimeout(this.credentialsTimeout);
+            this.credentialsTimeout = undefined;
+        }
+    }
+    clearRetryTimeout() {
+        if (this.retryTimeout) {
+            clearTimeout(this.retryTimeout);
+            this.retryTimeout = undefined;
+        }
+    }
+    resetRetryTimeout() {
+        this.clearRetryTimeout();
+        this.retryDelay = 0;
+    }
+    isConnected() {
+        return this.connected;
+    }
+}
+exports.PushNotificationService = PushNotificationService;
+//# sourceMappingURL=service.js.map