@iotize/ionic/esm2022/lib/current-device.service.mjs

Iotize specific building blocks on top of @ionic/angular.

import { Injectable, NgZone } from '@angular/core';
import { Platform, ToastController } from '@ionic/angular';
import { isCodeError } from '@iotize/common/error';
import { parseTapNdefMessage } from '@iotize/device-com-nfc.cordova';
import { HostProtocol, Tap, TapError, TapResponse, TapResponseStatusError, } from '@iotize/tap';
import { INITIAL_SESSION_STATE, _TAP_EXTENSION_AUTH_, } from '@iotize/tap/auth';
import { ResultCode, } from '@iotize/tap/client/api';
import { TapRequestHelper } from '@iotize/tap/client/impl';
import { _TAP_EXTENSION_DATA_ } from '@iotize/tap/ext/data';
import { _TAP_EXTENSION_DATA_LOG_ } from '@iotize/tap/ext/data-log';
import { factoryReset } from '@iotize/tap/ext/factory-reset';
import { _TAP_EXTENSION_KEEP_ALIVE_ } from '@iotize/tap/ext/keep-alive';
import { ComProtocol, ConnectionState, } from '@iotize/tap/protocol/api';
import { _TAP_SERVICE_ALL_EXTENSIONS_, } from '@iotize/tap/service/all';
import { BehaviorSubject, Subject, of, } from 'rxjs';
import { distinctUntilChanged, filter, shareReplay, skip, startWith, switchMap, tap, } from 'rxjs/operators';
import './extensions';
import { DataManagerIonic } from './extensions/data-manager';
import { debug } from './logger';
import { isSameTag } from './nfc/utility';
import { ProtocolFactoryService } from './protocol-factory.service';
import { runInZone } from './rx-utility/run-in-zone';
import { createBleName } from './utility';
import * as i0 from "@angular/core";
import * as i1 from "@ionic/angular";
import * as i2 from "./protocol-factory.service";
const TAG = 'CurrentDeviceService';
export function LONG_RANGE_PROTOCOL_FILTER(meta) {
    return meta.type !== 'nfc';
}
function getProtocolOrUndefined(client) {
    try {
        return client.getCurrentProtocol();
    }
    catch (err) {
        return undefined;
    }
}
export class TapServiceError extends Error {
    static illegalArgument(msg) {
        throw new Error(`Illegal argument: ${msg}`);
    }
    static illegalStateNoTap() {
        return new TapServiceError('Illegal state: Tap is not set yet');
    }
}
export class CurrentDeviceService {
    platform;
    toastCtrl;
    protocolFactory;
    ngZone;
    /**
     * Hack to prevent angular treeshaking from removing loaded extension.
     */
    _loadedTapExtensions = [
        _TAP_EXTENSION_DATA_,
        _TAP_EXTENSION_DATA_LOG_,
        _TAP_EXTENSION_KEEP_ALIVE_,
        _TAP_SERVICE_ALL_EXTENSIONS_,
        _TAP_EXTENSION_AUTH_,
        factoryReset,
    ];
    _tapOrUndefined = new BehaviorSubject(undefined);
    _tap;
    /**
     * Only connection lost event
     */
    _connectionLost$ = new Subject();
    _sessionState$ = this._tapOrUndefined.pipe(switchMap((tapDeviceOrUndefined) => {
        if (!tapDeviceOrUndefined) {
            return of(INITIAL_SESSION_STATE);
        }
        else {
            return tapDeviceOrUndefined.auth.sessionState;
        }
    }));
    listeners = [];
    keepAlivePeriod = 10 * 1000;
    meta = {};
    /**
     * @deprecated
     */
    _dataManager;
    /**
     * @deprecated
     */
    _tapConfig$ = new BehaviorSubject(undefined);
    _maxFrameSizeCache = {};
    /**
     * Event trigger when currrent Tap changed (set or unset)
     * If tap is removed, value will be undefined
     * Immediatly triggered the current value when subscribing
     */
    tapOrUndefinedChangedWithLastValue = this._tapOrUndefined.pipe(distinctUntilChanged());
    /**
     * Event trigger when currrent Tap changed (set or unset)
     * If tap is removed, value will be undefined
     */
    tapOrUndefinedChanged = this.tapOrUndefinedChangedWithLastValue.pipe(skip(1));
    /**
     * Event trigger when a new Tap is selected (no event when tap is removed)
     */
    tapChanged = this.tapOrUndefinedChanged.pipe(filter((tap) => !!tap));
    /**
     * Event trigger when a new Tap is selected (no event when tap is removed)
     * Immediatly triggered the current value when subscribing
     */
    tapChangedWithLastValue = this.tapOrUndefinedChangedWithLastValue.pipe(filter((tap) => !!tap));
    /**
     * Event triggered when tap is removed
     */
    tapRemoved = new Subject();
    _protocolMeta = new BehaviorSubject(undefined);
    _availableProtocols = new BehaviorSubject([]);
    _isManualDisconnection = false;
    _sessionStateSnapshot = INITIAL_SESSION_STATE;
    get sessionStateSnapshot() {
        return this._sessionStateSnapshot;
    }
    get sessionState() {
        return this._sessionState$;
    }
    get protocolMeta$() {
        return this._protocolMeta.asObservable();
    }
    get availableProtocols$() {
        return this._availableProtocols.asObservable();
    }
    get protocolMeta() {
        return this._protocolMeta.value;
    }
    set protocolMeta(meta) {
        if (meta) {
            this.addProtocolMeta(meta);
        }
        debug(TAG, 'setting protocol meta', meta);
        this._protocolMeta.next(meta);
    }
    get connectionLost() {
        return this._connectionLost$.asObservable();
    }
    get availableProtocols() {
        return this._availableProtocols.value;
    }
    get tap() {
        if (!this._tap) {
            throw new Error('Connect to a device first');
            // throw TapServiceError.illegalStateNoTap();
        }
        return this._tap;
    }
    get tapOrUndefined() {
        return this._tap;
    }
    get hasTap() {
        return this._tap !== undefined;
    }
    set tapConfig(schema) {
        debug(TAG, 'Set Tap config', schema);
        this.dataManager = new DataManagerIonic(this.tap);
        this._tapConfig$.next(schema);
        if (schema) {
            if (schema.config?.data) {
                // this.tap.data.clear();
                this.tap.data.configureWithDataConfig(schema.config.data);
                /*
                this.tap.data.values.subscribe(v => {
        
                })
                this.tap.data.monitoring.asSubject()
                .subscribe(state => {
            
                })
                */
            }
            else {
                this.tap.data.clear();
            }
            //
            // this.dataLogger.converter = new DataLogPacketConverter(
            //   newBundleConfigToOldBundleConfig(schema.config.data.bundles)
            // );
            // debug(TAG, 'Updating datalog converter');
            // this.dataLogger.converter = DataLogPacketConverter.createFromManager(this.tap.bundles, this.tap.variables);
            // if (schema.config.data) {
            //   this.dataLogger.converter = new DataLogPacketConverter(
            //     newBundleConfigToOldBundleConfig(schema.config.data.bundles || [])
            //   );
            // }
        }
    }
    get tapConfig() {
        return this._tapConfig$.value;
    }
    get tapConfig$() {
        return this._tapConfig$;
    }
    isSameTag(tag) {
        if (this.protocolMeta && this.protocolMeta.type === 'nfc') {
            // Check is it's the same tag
            const currentTag = this.protocolMeta.info.tag;
            if (currentTag.id && currentTag.id?.length == 0) {
                return false;
            }
            return isSameTag(currentTag, tag);
        }
        else {
            // It's not nfc currently
            const nfcProtocolMeta = this.availableProtocols.find((p) => p.type === 'nfc');
            if (nfcProtocolMeta) {
                return isSameTag(nfcProtocolMeta.info.tag, tag);
            }
        }
        return false;
    }
    /**
     * Use another communicaiton protocol
     * May be rejected
     * @param meta: ProtocolMeta
     * @param disonnectCurrentProtocol if set to true and if tap is already connected with
     * a communication protocol, it will disconnect from it first
     * @param connectToNew: boolean
     */
    async useProtocol(meta, disonnectCurrentProtocol = true, connectToNew = true) {
        debug(TAG, 'use protocol', meta);
        const protocol = await this.protocolFactory.create(meta);
        if (!this._tap) {
            this.tap = Tap.fromProtocol(protocol);
        }
        else {
            // let oldConnectionState = this._tap.protocol.getConnectionState();
            if (disonnectCurrentProtocol) {
                try {
                    await this.tap.protocol.disconnect().toPromise();
                }
                catch (err) {
                    console.warn('Cannot disconnect current protocol properly: ', err);
                }
            }
            this._tap.useComProtocol(protocol);
        }
        this.protocolMeta = meta;
        if (connectToNew) {
            await this.connect();
        }
    }
    async executeFactoryReset() {
        await this.tap.factoryReset();
        this.tap.auth.clearCache();
        this.tap.encryption.stop();
    }
    set tap(t) {
        this.setTap(t, { emit: true });
    }
    constructor(platform, toastCtrl, protocolFactory, ngZone) {
        this.platform = platform;
        this.toastCtrl = toastCtrl;
        this.protocolFactory = protocolFactory;
        this.ngZone = ngZone;
        debug(TAG, 'NEW INSTANCE', this._loadedTapExtensions);
        this.tapChangedWithLastValue.subscribe((newTap) => {
            newTap.client.addInterceptor((context, next) => {
                return next.handle(context).pipe(tap((tapResponseFrame) => {
                    const response = new TapResponse(tapResponseFrame, context.request);
                    if (response.status === ResultCode.UNAUTHORIZED) {
                        if (TapRequestHelper.pathToString(context.request.header.path) !== this.tap.service.interface.resources.login.path) {
                            this.listeners.forEach((listener) => {
                                if (listener.onTapRequestUnauthorized) {
                                    listener.onTapRequestUnauthorized({
                                        request: context,
                                        response: response,
                                    });
                                }
                            });
                        }
                    }
                    if (!response.isSuccessful()) {
                        this.listeners.forEach((listener) => {
                            if (listener.onTapRequestError) {
                                listener.onTapRequestError({
                                    request: context.request,
                                    error: new TapResponseStatusError(response),
                                    response: response,
                                });
                            }
                        });
                    }
                }, (error) => {
                    this.listeners.forEach((listener) => {
                        console.warn(`Request ${context.request} errored: ${error}`);
                        if (listener.onTapRequestError) {
                            listener.onTapRequestError({
                                request: context.request,
                                error: error,
                            });
                        }
                    });
                }));
            });
        });
        this.sessionState.subscribe((newSessionState) => {
            this._sessionStateSnapshot = newSessionState;
        });
        this.connectionStateReplay.subscribe(async (event) => {
            if (event.newState === ConnectionState.DISCONNECTED) {
                this.keepAliveEngine?.stop();
                if (!this._isManualDisconnection) {
                    this._connectionLost$?.next(event);
                }
            }
            else if (event.newState == ConnectionState.CONNECTED) {
                this.ngZone.runOutsideAngular(() => {
                    if (this.keepAlivePeriod > 0) {
                        debug(TAG, 'Start keep alive with period', this.keepAlivePeriod);
                        this.keepAliveEngine?.start();
                    }
                    else {
                        debug(TAG, 'NO keep alive');
                    }
                });
            }
            this.listeners.forEach((listener) => listener.onTapConnectionStateChange(event));
        });
    }
    addProtocolMeta(meta) {
        if (meta) {
            const protocols = this.availableProtocols;
            const protocolIndex = protocols.findIndex((existing) => {
                return existing.type === meta.type;
            });
            if (protocolIndex >= 0) {
                debug(TAG, 'Protocol meta', meta, 'already exists. Replacing infos');
                protocols[protocolIndex] = meta;
                this._availableProtocols.next(protocols);
            }
            else {
                debug(TAG, 'Adding protocol meta', meta);
                protocols.push(meta);
                this._availableProtocols.next(protocols);
            }
        }
    }
    /**
     * Parse NDefTag and try to create a ProtocolMeta thanks to record
     * @returns undefined if there is no other protocol in the tag
     */
    async registerProtocolsFromTag(tag) {
        let meta;
        if (!tag.ndefMessage) {
            return undefined;
        }
        const info = parseTapNdefMessage(tag.ndefMessage);
        if (info.macAddress && info.macAddress !== '00:00:00:00:00:00') {
            meta = {
                type: 'ble',
                info: {
                    mac: info.macAddress,
                    name: info.name,
                },
            };
        }
        else if (info.ssid) {
            const hostname = (await this.tap.service.wifi.getHostname()).body();
            meta = {
                type: 'wifi',
                info: {
                    ssid: info.ssid,
                    // name: info.name,
                    url: `tcp://${hostname}:2000`,
                },
            };
        }
        if (meta) {
            this.addProtocolMeta(meta);
        }
        return meta;
    }
    async getCurrentHostProtocolMaxFrameSizeCacheFirst() {
        const protocol = this.protocolMeta?.type;
        if (!protocol || !this._maxFrameSizeCache[protocol]) {
            const hostProtocol = (await this.tap.service.interface.getCurrentHostProtocolMaxFrameSize()).body();
            if (hostProtocol.request > 0xff) {
                hostProtocol.request -= 2; // due to 2 more bytes for apdu.header.lc
            }
            if (protocol) {
                this._maxFrameSizeCache[protocol] = hostProtocol;
            }
            else {
                return hostProtocol;
            }
        }
        return this._maxFrameSizeCache[protocol];
    }
    /**
     * Will register available communication protocols on current tap
     * by asking LWM2M resources.
     * @returns the list of new ProtocolMeta found
     */
    async registerProtocolsFromTap() {
        const nProtocolMeta = [];
        const [appNameResponse, serialNumberResponse, authorizedHostProtocolsResponse, bleAddressResponse, ipResponse,] = await this.tap.service.interface.executeMultipleCalls([
            this.tap.service.interface.getAppNameCall(),
            this.tap.service.device.getSerialNumberCall(),
            this.tap.service.interface.getAuthorizedHostProtocolCall(),
            this.tap.service.ble.getAddressCall(),
            this.tap.service.wifi.getIpCall(),
        ]);
        const authorizedHostProtocols = authorizedHostProtocolsResponse.body();
        if (this.protocolMeta?.type !== 'ble' &&
            authorizedHostProtocols.includes(HostProtocol.BLE)) {
            if (this.platform.is('ios')) {
                const bleName = createBleName(appNameResponse.body(), serialNumberResponse.body());
                nProtocolMeta.push({
                    type: 'ble',
                    info: {
                        name: bleName,
                    },
                });
            }
            else {
                nProtocolMeta.push({
                    type: 'ble',
                    info: {
                        mac: bleAddressResponse.body(),
                    },
                });
            }
        }
        if (this.protocolMeta?.type !== 'socket' &&
            this.platform.is('mobile') &&
            authorizedHostProtocols.includes(HostProtocol.WIFI)) {
            const ip = ipResponse.body();
            if (ip && ip !== '0.0.0.0') {
                nProtocolMeta.push({
                    type: 'socket',
                    info: {
                        url: 'tcp://' + ip + ':2000',
                    },
                });
            }
        }
        nProtocolMeta.forEach((meta) => this.addProtocolMeta(meta));
        return nProtocolMeta;
    }
    async useProtocolFromMeta(newProtocolMeta, disonnectCurrentProtocol = true, connectToNew = true) {
        if (!this.protocolMeta || newProtocolMeta.type !== this.protocolMeta.type) {
            return await this.useProtocol(newProtocolMeta, disonnectCurrentProtocol, connectToNew);
        }
    }
    /**
     * Switch from NFC communication protocol to a long range communication
     * @warning this is only available when we are in NFC
     *
     * @return the new protocol meta used or undefined if it does not have a long range protocol to use
     */
    async useLongRangeProtocol() {
        debug(TAG, 'useLongRangeProtocol');
        const currentProtocol = this.protocolMeta;
        if (!this._tap) {
            throw TapServiceError.illegalStateNoTap();
        }
        if (currentProtocol) {
            if (currentProtocol.type === 'nfc') {
                const protocolMeta = this.availableProtocols.find(LONG_RANGE_PROTOCOL_FILTER);
                if (protocolMeta) {
                    debug(TAG, 'Using long range protocol: ', protocolMeta);
                    await this.useProtocolFromMeta(protocolMeta);
                    return protocolMeta;
                }
                else {
                    debug(TAG, 'NFC tag does not have long range protocol information...');
                }
            }
        }
        return undefined;
    }
    /**
     * Connection state events.
     * It works even when tap is changed
     */
    get connectionState() {
        return this._connectionState$;
    }
    /**
     * Connection state events with replay.
     * It works even when tap is changed
     */
    connectionStateReplay = this.tapOrUndefinedChangedWithLastValue.pipe(switchMap((tapDevice) => {
        if (!tapDevice) {
            return of({
                newState: ConnectionState.DISCONNECTED,
                oldState: ConnectionState.DISCONNECTED,
            });
        }
        const currentProtocol = getProtocolOrUndefined(tapDevice.client);
        return tapDevice.client.onProtocolChange().pipe(startWith({
            newProtocol: currentProtocol,
        }), switchMap((event) => {
            if (!event.newProtocol) {
                return of({
                    newState: ConnectionState.DISCONNECTED,
                    oldState: ConnectionState.DISCONNECTED,
                });
            }
            return event.newProtocol.onConnectionStateChange().pipe(runInZone(this.ngZone), startWith({
                newState: event.newProtocol.getConnectionState(),
                oldState: ConnectionState.DISCONNECTED,
            }));
        }));
    }), shareReplay(1));
    /**
     * Any connection state change
     */
    _connectionState$ = this.connectionStateReplay.pipe(skip(1));
    /**
     * @returns true if user is connected as given username or one of the given usernames
     */
    async isLoggedInAsUserOrProfileName(userOrProfileNames) {
        if (typeof userOrProfileNames === 'string') {
            userOrProfileNames = [userOrProfileNames];
        }
        if (typeof userOrProfileNames === 'number') {
            console.warn('invalid parameter for CurrentDeviceService.isLoggedInAsUserOrProfileName() username should be a string');
            userOrProfileNames = [userOrProfileNames.toString()];
        }
        if (!this._tap || !this.tap.auth.sessionStateSnapshot) {
            return false;
        }
        const sessionState = this.tap.auth.sessionStateSnapshot ||
            (await this.tap.auth.refreshSessionState());
        return (userOrProfileNames.includes(sessionState.profileName) ||
            userOrProfileNames.includes(sessionState.name));
    }
    async login(username, password, refreshSessionState = true) {
        return await this.tap.auth.login({ username, password }, {
            noRefreshSessionState: !refreshSessionState,
        });
    }
    async logout(throwErr = false) {
        if (!this._tap) {
            return false;
        }
        try {
            await this._tap.auth.logout();
            return true;
        }
        catch (err) {
            if (throwErr) {
                throw err;
            }
            else {
                this.onError.bind(this);
                return false;
            }
        }
    }
    setTap(newTap, options = { emit: true }) {
        if (!newTap) {
            throw new Error('Illegal state: cannot set undefined tap');
        }
        this._tap = newTap;
        debug(TAG, 'Setting tap...');
        this.meta = {};
        this._tap = newTap;
        if (this.keepAlivePeriod === 0) {
            newTap.keepAlive.stop();
        }
        newTap.keepAlive.period = this.keepAlivePeriod;
        if (options.emit) {
            this.notifyNewTap();
        }
    }
    notifyNewTap() {
        this._tapOrUndefined.next(this._tap);
    }
    setTapFromEvent(event, options = { emit: true }) {
        if (!event.protocolMeta) {
            throw new Error('Missing protocol information');
        }
        this.protocolMeta = event.protocolMeta;
        // this.tap = event.tap;
        this.setTap(event.tap, options);
        debug(TAG, 'setTapFromEvent = >', event);
    }
    /**
     * Connect to the Tap and refresh session state
     * Throw error if it fails
     */
    async connect(
    /**
     * @deprecated
     */
    throwErr = true) {
        try {
            await this.tap.connect();
            await this.refreshSessionState();
            return true;
        }
        catch (err) {
            debug(TAG, 'Throwing error on connection failed');
            throw err;
        }
    }
    /**
     *  Disconnect Tap
     */
    async disconnect() {
        debug(TAG, 'disconnect');
        if (!this.hasProtocol()) {
            return;
        }
        this._isManualDisconnection = true;
        debug(TAG, 'Setting _isManualDisconnection flag to true');
        return (this._tap
            ? this._tap.disconnect()
            : Promise.reject(TapServiceError.illegalStateNoTap())).then((res) => {
            // This is a temporary hack to differentiate manual/unexpected disconnection
            // The timeout is used to make sure that direct events are trigger before we set the manual
            // disconnection flag back to false
            // TODO remove later
            setTimeout(() => {
                debug(TAG, 'Setting _isManualDisconnection flag to false');
                this._isManualDisconnection = false;
            }, 50);
            return res;
        });
    }
    /**
     * Remove currently used Tap
     * If no Tap was set, do nothing
     */
    async remove(disconnect = true) {
        if (this._tap) {
            const oldTap = this._tap;
            debug(TAG, 'Removing tap');
            this.protocolMeta = undefined;
            this._availableProtocols.next([]);
            if (disconnect) {
                await this.disconnect().catch(this.onError.bind(this));
            }
            console.log('Stopping old keep alive', oldTap.keepAlive);
            oldTap.keepAlive.stop();
            this._tap = undefined;
            this._dataManager = undefined;
            this._maxFrameSizeCache = {};
            // this._tapConfig = undefined;
            this.notifyTapRemoved(oldTap);
        }
        else {
            debug(TAG, 'No tap to remove');
        }
    }
    notifyTapRemoved(t) {
        this.tapRemoved.next(t);
        this.notifyNewTap();
    }
    /**
     * @deprecated
     */
    async configureClientIfRequired() {
        if (!this.meta.isClientConfigured) {
            console.log('Configuring client...');
            await this.configureClient().catch((err) => {
                this.onError(err);
            });
        }
    }
    /**
     * Rebuild tap configuration according to data on the Tap
     *
     * @deprecated
     */
    async loadConfigFromDevice() {
        debug(TAG, 'dynamically load Tap config');
        const syncEvent = await this.tap.data.synchronizeTapConfig().toPromise();
        this.meta.isClientConfigured = true;
        // TODO Fix to get real config
        if (syncEvent?.step === 'done') {
            const bundles = syncEvent.bundles;
            this.tapConfig = {
                meta: {
                    version: '1.0.0',
                    partial: true,
                },
                config: {
                    version: 1,
                    data: {
                        bundles: [],
                    },
                },
            };
        }
    }
    set dataManager(v) {
        debug(TAG, 'Setting data manager', v);
        if (this._dataManager) {
            this._dataManager.destroy();
        }
        this._dataManager = v;
    }
    get dataManager() {
        if (!this._dataManager) {
            return undefined;
        }
        return this._dataManager;
    }
    /**
     * Configure client by reading tap device configuration
     *
     * @deprecated will be moved to a separate service
     *
     * @throws
     */
    async configureClient(refresh = false) {
        debug(TAG, 'configureClient');
        if (refresh) {
            this.tapConfig = undefined;
        }
        // TODO only once
        // if (this.modelConfig) {
        //   console.info('load from iotz model configuration file')
        //   let tapConfigConfigurator = new TapConfigConfigurator(this.modelConfig);
        //   await this.tap.configure(tapConfigConfigurator);
        //   this.meta.isClientConfigured = true;
        //   console.log('Variables: ', this.tap.variables);
        // }
        if (this.tapConfig === undefined) {
            await this.loadConfigFromDevice();
            // this.tap.bundles.clear();
            // this.tap.variables.clear();
            // await this.tap.configure(this.readDeviceDataConfigurator).catch(this.onError.bind(this));
        }
    }
    getCurrentProtocol() {
        return getProtocolOrUndefined(this.tap.client);
    }
    get keepAliveEngine() {
        return this._tap?.keepAlive;
    }
    hasProtocol() {
        return this.getCurrentProtocol() !== undefined;
    }
    registerEventListerner(listener) {
        this.listeners.push(listener);
    }
    unregisterEventListener(listener) {
        const index = this.listeners.indexOf(listener);
        if (index >= 0) {
            this.listeners.splice(index, 1);
        }
    }
    /**
     * @deprecated refractor: remove on error from this service to use a global handler
     *
     * @param err
     */
    async onError(err) {
        // TODO remove
        const toast = await this.toastCtrl.create({
            message: err.message || 'Unknown error',
            color: 'danger',
            position: 'bottom',
            duration: 3000,
            buttons: [
                {
                    text: 'Close',
                    role: 'cancel',
                    handler: () => {
                        console.log('Close clicked');
                    },
                },
            ],
        });
        await toast.present();
    }
    async reboot() {
        let rebootResponse;
        try {
            rebootResponse = await this.tap.service.device.reboot();
        }
        catch (err) {
            if (!isCodeError(TapError.Code.ExecuteRequestError, err)) {
                throw err;
            }
            else {
                const cause = err.cause;
                if (cause?.code !== ComProtocol.ErrorCode.TimeoutError) {
                    console.warn('Reboot error', err);
                    throw err;
                }
                // ignore timeout error as tap may reboot before sending response
            }
        }
        if (rebootResponse) {
            rebootResponse.successful();
        }
        await this.clearAuth();
        this.tap.disconnect().catch((err) => { });
    }
    async clearAuth() {
        this.tap.auth.clearCache();
        this.tap.encryption.stop();
        await this.tap.auth.logout().catch((err) => { });
    }
    async refreshSessionState() {
        try {
            return await this.tap.auth.refreshSessionState();
        }
        catch (err) {
            if (isCodeError(TapError.Code.ScramNotStartedYet, err) ||
                isCodeError(TapError.Code.InvalidScramKey, err)) {
                console.warn(`SCRAM session ended due to error`, err.message);
                this.tap.encryption.stop();
                return await this.tap.auth.refreshSessionState();
            }
            else {
                throw err;
            }
        }
    }
    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CurrentDeviceService, deps: [{ token: i1.Platform }, { token: i1.ToastController }, { token: i2.ProtocolFactoryService }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CurrentDeviceService, providedIn: 'root' });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CurrentDeviceService, decorators: [{
            type: Injectable,
            args: [{
                    providedIn: 'root',
                }]
        }], ctorParameters: () => [{ type: i1.Platform }, { type: i1.ToastController }, { type: i2.ProtocolFactoryService }, { type: i0.NgZone }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"current-device.service.js","sourceRoot":"","sources":["../../../../../projects/iotize-ionic/src/lib/current-device.service.ts"],"names":[],"mappings":"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