@meddv/ngx-mqtt
Version:
This library isn't just a wrapper around MQTT.js for angular. It uses observables and takes care of subscription handling and message routing.
372 lines • 51.8 kB
JavaScript
import { EventEmitter, Inject, Injectable } from '@angular/core';
import mqtt from 'mqtt';
import { BehaviorSubject, merge, Observable, Subject, Subscription, using } from 'rxjs';
import { filter, publish, publishReplay, refCount } from 'rxjs/operators';
import { MqttConnectionState } from './mqtt.model';
import { MqttClientService, MqttServiceConfig } from './mqtt.module';
import * as i0 from "@angular/core";
const connect = mqtt.connect;
// A javascript function that takes two objects and merges them recursively
function mergeDeep(target, ...sources) {
if (!sources.length) {
return target;
}
const source = sources.shift();
if (isObject(target) && isObject(source)) {
for (const key in source) {
if (isObject(source[key])) {
if (!target[key]) {
Object.assign(target, { [key]: {} });
}
mergeDeep(target[key], source[key]);
}
else {
Object.assign(target, { [key]: source[key] });
}
}
}
return mergeDeep(target, ...sources);
}
function isObject(item) {
return item && typeof item === 'object' && !Array.isArray(item);
}
/**
* With an instance of MqttService, you can observe and subscribe to MQTT in multiple places, e.g. in different components,
* to only subscribe to the broker once per MQTT filter.
* It also handles proper unsubscription from the broker, if the last observable with a filter is closed.
*/
export class MqttService {
/**
* The constructor needs [connection options]{@link IMqttServiceOptions} regarding the broker and some
* options to configure behavior of this service, like if the connection to the broker
* should be established on creation of this service or not.
*/
constructor(options, client) {
this.options = options;
/** a map of all mqtt observables by filter */
this.observables = {};
/** the connection state */
this.state = new BehaviorSubject(MqttConnectionState.CLOSED);
/** an observable of the last mqtt message */
this.messages = new Subject();
this._clientId = this._generateClientId();
this._connectTimeout = 10000;
this._reconnectPeriod = 10000;
this._onConnect = new EventEmitter();
this._onReconnect = new EventEmitter();
this._onClose = new EventEmitter();
this._onOffline = new EventEmitter();
this._onError = new EventEmitter();
this._onEnd = new EventEmitter();
this._onMessage = new EventEmitter();
this._onSuback = new EventEmitter();
this._onPacketsend = new EventEmitter();
this._onPacketreceive = new EventEmitter();
this._handleOnConnect = (e) => {
if (this.options.connectOnCreate === true) {
Object.keys(this.observables).forEach((filterString) => {
this.client.subscribe(filterString);
});
}
this.state.next(MqttConnectionState.CONNECTED);
this._onConnect.emit(e);
};
this._handleOnReconnect = () => {
if (this.options.connectOnCreate === true) {
Object.keys(this.observables).forEach((filterString) => {
this.client.subscribe(filterString);
});
}
this.state.next(MqttConnectionState.CONNECTING);
this._onReconnect.emit();
};
this._handleOnClose = () => {
this.state.next(MqttConnectionState.CLOSED);
this._onClose.emit();
};
this._handleOnOffline = () => {
this._onOffline.emit();
};
this._handleOnError = (e) => {
this._onError.emit(e);
console.error(e);
};
this._handleOnEnd = () => {
this._onEnd.emit();
};
this._handleOnMessage = (topic, payload, packet) => {
this._onMessage.emit(packet);
if (packet.cmd === 'publish') {
this.messages.next(packet);
}
};
this._handleOnPacketsend = (e) => {
this._onPacketsend.emit(e);
};
this._handleOnPacketreceive = (e) => {
this._onPacketreceive.emit(e);
};
if (options.connectOnCreate !== false) {
this.connect({}, client);
}
this.state.subscribe();
}
/**
* gets the _clientId
*/
get clientId() {
return this._clientId;
}
/** An EventEmitter to listen to connect messages */
get onConnect() {
return this._onConnect;
}
/** An EventEmitter to listen to reconnect messages */
get onReconnect() {
return this._onReconnect;
}
/** An EventEmitter to listen to close messages */
get onClose() {
return this._onClose;
}
/** An EventEmitter to listen to offline events */
get onOffline() {
return this._onOffline;
}
/** An EventEmitter to listen to error events */
get onError() {
return this._onError;
}
/** An EventEmitter to listen to close messages */
get onEnd() {
return this._onEnd;
}
/** An EventEmitter to listen to message events */
get onMessage() {
return this._onMessage;
}
/** An EventEmitter to listen to packetsend messages */
get onPacketsend() {
return this._onPacketsend;
}
/** An EventEmitter to listen to packetreceive messages */
get onPacketreceive() {
return this._onPacketreceive;
}
/** An EventEmitter to listen to suback events */
get onSuback() {
return this._onSuback;
}
/** An actual connection state **/
get connectionState() {
return this.state.value;
}
/**
* This static method shall be used to determine whether a MQTT
* topic matches a given filter. The matching rules are specified in the MQTT
* standard documentation and in the library test suite.
*
* @param {string} filter A filter may contain wildcards like '#' and '+'.
* @param {string} topic A topic may not contain wildcards.
* @return {boolean} true on match and false otherwise.
*/
static filterMatchesTopic(filterString, topic) {
if (filterString[0] === '#' && topic[0] === '$') {
return false;
}
// Preparation: split and reverse on '/'. The JavaScript split function is sane.
const fs = (filterString || '').split('/').reverse();
const ts = (topic || '').split('/').reverse();
// This function is tail recursive and compares both arrays one element at a time.
const match = () => {
// Cutting of the last element of both the filter and the topic using pop().
const f = fs.pop();
const t = ts.pop();
switch (f) {
// In case the filter level is '#', this is a match no matter whether
// the topic is undefined on this level or not ('#' matches parent element as well!).
case '#':
return true;
// In case the filter level is '+', we shall dive into the recursion only if t is not undefined.
case '+':
return t ? match() : false;
// In all other cases the filter level must match the topic level,
// both must be defined and the filter tail must match the topic
// tail (which is determined by the recursive call of match()).
default:
return f === t && (f === undefined ? true : match());
}
};
return match();
}
/**
* connect manually connects to the mqtt broker.
*/
connect(opts, client) {
const options = mergeDeep(this.options || {}, opts);
const protocol = options.protocol || 'ws';
const hostname = options.hostname || 'localhost';
if (options.url) {
this._url = options.url;
}
else {
this._url = `${protocol}://${hostname}`;
this._url += options.port ? `:${options.port}` : '';
this._url += options.path ? `${options.path}` : '';
}
this.state.next(MqttConnectionState.CONNECTING);
const mergedOptions = mergeDeep({
clientId: this._clientId,
reconnectPeriod: this._reconnectPeriod,
connectTimeout: this._connectTimeout
}, options);
if (this.client) {
this.client.end(true);
}
if (!client) {
this.client = connect(this._url, mergedOptions);
}
else {
this.client = client;
}
this._clientId = mergedOptions.clientId;
this.client.on('connect', this._handleOnConnect);
this.client.on('reconnect', this._handleOnReconnect);
this.client.on('close', this._handleOnClose);
this.client.on('offline', this._handleOnOffline);
this.client.on('error', this._handleOnError);
this.client.stream.on('error', this._handleOnError);
this.client.on('end', this._handleOnEnd);
this.client.on('message', this._handleOnMessage);
this.client.on('packetsend', this._handleOnPacketsend);
this.client.on('packetreceive', this._handleOnPacketreceive);
}
/**
* disconnect disconnects from the mqtt client.
* This method `should` be executed when leaving the application.
*/
disconnect(force = true) {
if (!this.client) {
throw new Error('mqtt client not connected');
}
this.client.end(force);
}
/**
* With this method, you can observe messages for a mqtt topic.
* The observable will only emit messages matching the filter.
* The first one subscribing to the resulting observable executes a mqtt subscribe.
* The last one unsubscribing this filter executes a mqtt unsubscribe.
* Every new subscriber gets the latest message.
*/
observeRetained(filterString, opts = { qos: 1 }) {
return this._generalObserve(filterString, () => publishReplay(1), opts);
}
/**
* With this method, you can observe messages for a mqtt topic.
* The observable will only emit messages matching the filter.
* The first one subscribing to the resulting observable executes a mqtt subscribe.
* The last one unsubscribing this filter executes a mqtt unsubscribe.
*/
observe(filterString, opts = { qos: 1 }) {
return this._generalObserve(filterString, () => publish(), opts);
}
/**
* With this method, you can observe messages for a mqtt topic.
* The observable will only emit messages matching the filter.
* The first one subscribing to the resulting observable executes a mqtt subscribe.
* The last one unsubscribing this filter executes a mqtt unsubscribe.
* Depending on the publish function, the messages will either be replayed after new
* subscribers subscribe or the messages are just passed through
*/
_generalObserve(filterString, publishFn, opts) {
if (!this.client) {
throw new Error('mqtt client not connected');
}
if (!this.observables[filterString]) {
const rejected = new Subject();
this.observables[filterString] = using(
// resourceFactory: Do the actual ref-counting MQTT subscription.
// refcount is decreased on unsubscribe.
() => {
const subscription = new Subscription();
this.client.subscribe(filterString, opts, (err, granted) => {
if (granted) { // granted can be undefined when an error occurs when the client is disconnecting
granted.forEach((granted_) => {
if (granted_.qos === 128) {
delete this.observables[granted_.topic];
this.client.unsubscribe(granted_.topic);
rejected.error(`subscription for '${granted_.topic}' rejected!`);
}
this._onSuback.emit({ filter: filterString, granted: granted_.qos !== 128 });
});
}
});
subscription.add(() => {
delete this.observables[filterString];
this.client.unsubscribe(filterString);
});
return subscription;
},
// observableFactory: Create the observable that is consumed from.
// This part is not executed until the Observable returned by
// `observe` gets actually subscribed.
(subscription) => merge(rejected, this.messages))
.pipe(filter((msg) => MqttService.filterMatchesTopic(filterString, msg.topic)), publishFn(), refCount());
}
return this.observables[filterString];
}
/**
* This method returns an observable for a topic with optional options.
* After subscribing, the actual mqtt publication will be executed and
* the observable will emit an empty value and completes, if publishing was successful
* or throws an error, if the publication fails.
*/
publish(topic, message, options = {}) {
if (!this.client) {
throw new Error('mqtt client not connected');
}
return Observable.create((obs) => {
this.client.publish(topic, message, options, (error) => {
if (error) {
obs.error(error);
}
else {
obs.next();
obs.complete();
}
});
});
}
/**
* This method publishes a message for a topic with optional options.
* If an error occurs, it will throw.
*/
unsafePublish(topic, message, options = {}) {
if (!this.client) {
throw new Error('mqtt client not connected');
}
this.client.publish(topic, message, options, (error) => {
if (error) {
throw (error);
}
});
}
_generateClientId() {
return 'client-' + Math.random().toString(36).substr(2, 19);
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: MqttService, deps: [{ token: MqttServiceConfig }, { token: MqttClientService }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: MqttService, providedIn: 'root' }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: MqttService, decorators: [{
type: Injectable,
args: [{
providedIn: 'root',
}]
}], ctorParameters: () => [{ type: undefined, decorators: [{
type: Inject,
args: [MqttServiceConfig]
}] }, { type: undefined, decorators: [{
type: Inject,
args: [MqttClientService]
}] }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mqtt.service.js","sourceRoot":"","sources":["../../../../projects/ngx-mqtt/src/lib/mqtt.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter, Inject, Injectable } from '@angular/core';\r\nimport { IClientPublishOptions, IClientSubscribeOptions, ISubscriptionGrant} from 'mqtt';\r\nimport { Packet } from 'mqtt-packet';\r\n\r\nimport mqtt from 'mqtt';\r\nconst connect = mqtt.connect;\r\ntype MqttClient = mqtt.MqttClient;\r\n\r\nimport { BehaviorSubject, merge, Observable, Observer, Subject, Subscription, Unsubscribable, using } from 'rxjs';\r\nimport { filter, publish, publishReplay, refCount } from 'rxjs/operators';\r\n\r\nimport {\r\n  IMqttMessage,\r\n  IMqttServiceOptions,\r\n  IOnConnectEvent,\r\n  IOnErrorEvent,\r\n  IOnPacketreceiveEvent,\r\n  IOnPacketsendEvent,\r\n  IOnSubackEvent,\r\n  IPublishOptions,\r\n  MqttConnectionState\r\n} from './mqtt.model';\r\n\r\nimport { MqttClientService, MqttServiceConfig } from './mqtt.module';\r\n\r\n// A javascript function that takes two objects and merges them recursively\r\nfunction mergeDeep(target: any, ...sources: any[]): any {\r\n  if (!sources.length) {\r\n    return target;\r\n  }\r\n  const source = sources.shift();\r\n\r\n  if (isObject(target) && isObject(source)) {\r\n    for (const key in source) {\r\n      if (isObject(source[key])) {\r\n        if (!target[key]) {\r\n          Object.assign(target, { [key]: {} });\r\n        }\r\n        mergeDeep(target[key], source[key]);\r\n      } else {\r\n        Object.assign(target, { [key]: source[key] });\r\n      }\r\n    }\r\n  }\r\n\r\n  return mergeDeep(target, ...sources);\r\n}\r\n\r\nfunction isObject(item: any): item is Object {\r\n  return item && typeof item === 'object' && !Array.isArray(item);\r\n}\r\n\r\n/**\r\n * With an instance of MqttService, you can observe and subscribe to MQTT in multiple places, e.g. in different components,\r\n * to only subscribe to the broker once per MQTT filter.\r\n * It also handles proper unsubscription from the broker, if the last observable with a filter is closed.\r\n */\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class MqttService {\r\n  private client!: MqttClient;\r\n\r\n  /**\r\n   * The constructor needs [connection options]{@link IMqttServiceOptions} regarding the broker and some\r\n   * options to configure behavior of this service, like if the connection to the broker\r\n   * should be established on creation of this service or not.\r\n   */\r\n  constructor(\r\n    @Inject(MqttServiceConfig) private options: IMqttServiceOptions,\r\n    @Inject(MqttClientService) client?: MqttClient\r\n  ) {\r\n    if (options.connectOnCreate !== false) {\r\n      this.connect({}, client);\r\n    }\r\n\r\n    this.state.subscribe();\r\n  }\r\n\r\n  /**\r\n   * gets the _clientId\r\n   */\r\n  public get clientId() {\r\n    return this._clientId;\r\n  }\r\n\r\n  /** An EventEmitter to listen to connect messages */\r\n  public get onConnect(): EventEmitter<IOnConnectEvent> {\r\n    return this._onConnect;\r\n  }\r\n\r\n  /** An EventEmitter to listen to reconnect messages */\r\n  public get onReconnect(): EventEmitter<void> {\r\n    return this._onReconnect;\r\n  }\r\n\r\n  /** An EventEmitter to listen to close messages */\r\n  public get onClose(): EventEmitter<void> {\r\n    return this._onClose;\r\n  }\r\n\r\n  /** An EventEmitter to listen to offline events */\r\n  public get onOffline(): EventEmitter<void> {\r\n    return this._onOffline;\r\n  }\r\n\r\n  /** An EventEmitter to listen to error events */\r\n  public get onError(): EventEmitter<IOnErrorEvent> {\r\n    return this._onError;\r\n  }\r\n\r\n  /** An EventEmitter to listen to close messages */\r\n  public get onEnd(): EventEmitter<void> {\r\n    return this._onEnd;\r\n  }\r\n\r\n  /** An EventEmitter to listen to message events */\r\n  public get onMessage(): EventEmitter<Packet> {\r\n    return this._onMessage;\r\n  }\r\n\r\n  /** An EventEmitter to listen to packetsend messages */\r\n  public get onPacketsend(): EventEmitter<IOnPacketsendEvent> {\r\n    return this._onPacketsend;\r\n  }\r\n\r\n  /** An EventEmitter to listen to packetreceive messages */\r\n  public get onPacketreceive(): EventEmitter<IOnPacketreceiveEvent> {\r\n    return this._onPacketreceive;\r\n  }\r\n\r\n  /** An EventEmitter to listen to suback events */\r\n  public get onSuback(): EventEmitter<IOnSubackEvent> {\r\n    return this._onSuback;\r\n  }\r\n\r\n  /** An actual connection state **/\r\n  public get connectionState(): MqttConnectionState {\r\n    return this.state.value;\r\n  }\r\n\r\n  /** a map of all mqtt observables by filter */\r\n  public observables: { [filterString: string]: Observable<IMqttMessage> } = {};\r\n  /** the connection state */\r\n  public state: BehaviorSubject<MqttConnectionState> = new BehaviorSubject<MqttConnectionState>(MqttConnectionState.CLOSED);\r\n  /** an observable of the last mqtt message */\r\n  public messages: Subject<IMqttMessage> = new Subject<IMqttMessage>();\r\n\r\n  private _clientId = this._generateClientId();\r\n  private _connectTimeout = 10000;\r\n  private _reconnectPeriod = 10000;\r\n  private _url!: string;\r\n\r\n  private _onConnect: EventEmitter<IOnConnectEvent> = new EventEmitter<IOnConnectEvent>();\r\n  private _onReconnect: EventEmitter<void> = new EventEmitter<void>();\r\n  private _onClose: EventEmitter<void> = new EventEmitter<void>();\r\n  private _onOffline: EventEmitter<void> = new EventEmitter<void>();\r\n  private _onError: EventEmitter<IOnErrorEvent> = new EventEmitter<IOnErrorEvent>();\r\n  private _onEnd: EventEmitter<void> = new EventEmitter<void>();\r\n  private _onMessage: EventEmitter<Packet> = new EventEmitter<Packet>();\r\n  private _onSuback: EventEmitter<IOnSubackEvent> = new EventEmitter<IOnSubackEvent>();\r\n  private _onPacketsend: EventEmitter<IOnPacketsendEvent> = new EventEmitter<IOnPacketsendEvent>();\r\n  private _onPacketreceive: EventEmitter<IOnPacketreceiveEvent> = new EventEmitter<IOnPacketreceiveEvent>();\r\n\r\n  /**\r\n   * This static method shall be used to determine whether a MQTT\r\n   * topic matches a given filter. The matching rules are specified in the MQTT\r\n   * standard documentation and in the library test suite.\r\n   *\r\n   * @param  {string}  filter A filter may contain wildcards like '#' and '+'.\r\n   * @param  {string}  topic  A topic may not contain wildcards.\r\n   * @return {boolean}        true on match and false otherwise.\r\n   */\r\n  public static filterMatchesTopic(filterString: string, topic: string): boolean {\r\n    if (filterString[0] === '#' && topic[0] === '$') {\r\n      return false;\r\n    }\r\n    // Preparation: split and reverse on '/'. The JavaScript split function is sane.\r\n    const fs = (filterString || '').split('/').reverse();\r\n    const ts = (topic || '').split('/').reverse();\r\n    // This function is tail recursive and compares both arrays one element at a time.\r\n    const match = (): boolean => {\r\n      // Cutting of the last element of both the filter and the topic using pop().\r\n      const f = fs.pop();\r\n      const t = ts.pop();\r\n      switch (f) {\r\n        // In case the filter level is '#', this is a match no matter whether\r\n        // the topic is undefined on this level or not ('#' matches parent element as well!).\r\n        case '#':\r\n          return true;\r\n        // In case the filter level is '+', we shall dive into the recursion only if t is not undefined.\r\n        case '+':\r\n          return t ? match() : false;\r\n        // In all other cases the filter level must match the topic level,\r\n        // both must be defined and the filter tail must match the topic\r\n        // tail (which is determined by the recursive call of match()).\r\n        default:\r\n          return f === t && (f === undefined ? true : match());\r\n      }\r\n    };\r\n    return match();\r\n  }\r\n\r\n  /**\r\n   * connect manually connects to the mqtt broker.\r\n   */\r\n  public connect(opts?: IMqttServiceOptions, client?: MqttClient) {\r\n    const options = mergeDeep(this.options || {}, opts);\r\n    const protocol = options.protocol || 'ws';\r\n    const hostname = options.hostname || 'localhost';\r\n    if (options.url) {\r\n      this._url = options.url;\r\n    } else {\r\n      this._url = `${protocol}://${hostname}`;\r\n      this._url += options.port ? `:${options.port}` : '';\r\n      this._url += options.path ? `${options.path}` : '';\r\n    }\r\n    this.state.next(MqttConnectionState.CONNECTING);\r\n    const mergedOptions = mergeDeep({\r\n      clientId: this._clientId,\r\n      reconnectPeriod: this._reconnectPeriod,\r\n      connectTimeout: this._connectTimeout\r\n    }, options);\r\n\r\n    if (this.client) {\r\n      this.client.end(true);\r\n    }\r\n\r\n    if (!client) {\r\n      this.client = connect(this._url, mergedOptions);\r\n    } else {\r\n      this.client = client;\r\n    }\r\n    this._clientId = mergedOptions.clientId;\r\n\r\n    this.client.on('connect', this._handleOnConnect);\r\n    this.client.on('reconnect', this._handleOnReconnect);\r\n    this.client.on('close', this._handleOnClose);\r\n    this.client.on('offline', this._handleOnOffline);\r\n    this.client.on('error', this._handleOnError);\r\n    (this.client as any).stream.on('error', this._handleOnError);\r\n    this.client.on('end', this._handleOnEnd);\r\n    this.client.on('message', this._handleOnMessage);\r\n    this.client.on('packetsend', this._handleOnPacketsend);\r\n    this.client.on('packetreceive', this._handleOnPacketreceive);\r\n  }\r\n\r\n  /**\r\n   * disconnect disconnects from the mqtt client.\r\n   * This method `should` be executed when leaving the application.\r\n   */\r\n  public disconnect(force = true) {\r\n    if (!this.client) {\r\n      throw new Error('mqtt client not connected');\r\n    }\r\n    this.client.end(force);\r\n  }\r\n\r\n  /**\r\n   * With this method, you can observe messages for a mqtt topic.\r\n   * The observable will only emit messages matching the filter.\r\n   * The first one subscribing to the resulting observable executes a mqtt subscribe.\r\n   * The last one unsubscribing this filter executes a mqtt unsubscribe.\r\n   * Every new subscriber gets the latest message.\r\n   */\r\n  public observeRetained(filterString: string, opts: IClientSubscribeOptions = { qos: 1 }): Observable<IMqttMessage> {\r\n    return this._generalObserve(filterString, () => publishReplay(1), opts);\r\n  }\r\n\r\n  /**\r\n   * With this method, you can observe messages for a mqtt topic.\r\n   * The observable will only emit messages matching the filter.\r\n   * The first one subscribing to the resulting observable executes a mqtt subscribe.\r\n   * The last one unsubscribing this filter executes a mqtt unsubscribe.\r\n   */\r\n  public observe(filterString: string, opts: IClientSubscribeOptions = { qos: 1 }): Observable<IMqttMessage> {\r\n    return this._generalObserve(filterString, () => publish(), opts);\r\n  }\r\n\r\n  /**\r\n   * With this method, you can observe messages for a mqtt topic.\r\n   * The observable will only emit messages matching the filter.\r\n   * The first one subscribing to the resulting observable executes a mqtt subscribe.\r\n   * The last one unsubscribing this filter executes a mqtt unsubscribe.\r\n   * Depending on the publish function, the messages will either be replayed after new\r\n   * subscribers subscribe or the messages are just passed through\r\n   */\r\n  private _generalObserve(filterString: string, publishFn: Function, opts: IClientSubscribeOptions): Observable<IMqttMessage> {\r\n    if (!this.client) {\r\n      throw new Error('mqtt client not connected');\r\n    }\r\n    if (!this.observables[filterString]) {\r\n      const rejected: Subject<IMqttMessage> = new Subject();\r\n      this.observables[filterString] = using(\r\n        // resourceFactory: Do the actual ref-counting MQTT subscription.\r\n        // refcount is decreased on unsubscribe.\r\n        () => {\r\n          const subscription: Subscription = new Subscription();\r\n          this.client.subscribe(filterString, opts, (err: any, granted: ISubscriptionGrant[] | undefined) => {\r\n            if (granted) { // granted can be undefined when an error occurs when the client is disconnecting\r\n              granted.forEach((granted_: ISubscriptionGrant) => {\r\n                if (granted_.qos === 128) {\r\n                  delete this.observables[granted_.topic];\r\n                  this.client.unsubscribe(granted_.topic);\r\n                  rejected.error(`subscription for '${granted_.topic}' rejected!`);\r\n                }\r\n                this._onSuback.emit({ filter: filterString, granted: granted_.qos !== 128 });\r\n              });\r\n            }\r\n          });\r\n          subscription.add(() => {\r\n            delete this.observables[filterString];\r\n            this.client.unsubscribe(filterString);\r\n          });\r\n          return subscription;\r\n        },\r\n        // observableFactory: Create the observable that is consumed from.\r\n        // This part is not executed until the Observable returned by\r\n        // `observe` gets actually subscribed.\r\n        (subscription: Unsubscribable | void) => merge(rejected, this.messages))\r\n        .pipe(\r\n          filter((msg: IMqttMessage) => MqttService.filterMatchesTopic(filterString, msg.topic)),\r\n          publishFn(),\r\n          refCount()\r\n        ) as Observable<IMqttMessage>;\r\n    }\r\n    return this.observables[filterString];\r\n  }\r\n\r\n  /**\r\n   * This method returns an observable for a topic with optional options.\r\n   * After subscribing, the actual mqtt publication will be executed and\r\n   * the observable will emit an empty value and completes, if publishing was successful\r\n   * or throws an error, if the publication fails.\r\n   */\r\n  public publish(topic: string, message: string | Buffer, options: IClientPublishOptions = {}): Observable<void> {\r\n    if (!this.client) {\r\n      throw new Error('mqtt client not connected');\r\n    }\r\n    return Observable.create((obs: Observer<void>) => {\r\n      this.client.publish(topic, message, options, (error: Error | undefined) => {\r\n        if (error) {\r\n          obs.error(error);\r\n        } else {\r\n          obs.next();\r\n          obs.complete();\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * This method publishes a message for a topic with optional options.\r\n   * If an error occurs, it will throw.\r\n   */\r\n  public unsafePublish(topic: string, message: string | Buffer, options: IPublishOptions = {}): void {\r\n    if (!this.client) {\r\n      throw new Error('mqtt client not connected');\r\n    }\r\n    this.client.publish(topic, message, options, (error: Error | undefined) => {\r\n      if (error) {\r\n        throw (error);\r\n      }\r\n    });\r\n  }\r\n\r\n  private _handleOnConnect = (e: IOnConnectEvent) => {\r\n    if (this.options.connectOnCreate === true) {\r\n      Object.keys(this.observables).forEach((filterString: string) => {\r\n        this.client.subscribe(filterString);\r\n      });\r\n    }\r\n    this.state.next(MqttConnectionState.CONNECTED);\r\n    this._onConnect.emit(e);\r\n  }\r\n\r\n  private _handleOnReconnect = () => {\r\n    if (this.options.connectOnCreate === true) {\r\n      Object.keys(this.observables).forEach((filterString: string) => {\r\n        this.client.subscribe(filterString);\r\n      });\r\n    }\r\n    this.state.next(MqttConnectionState.CONNECTING);\r\n    this._onReconnect.emit();\r\n  }\r\n\r\n  private _handleOnClose = () => {\r\n    this.state.next(MqttConnectionState.CLOSED);\r\n    this._onClose.emit();\r\n  }\r\n\r\n  private _handleOnOffline = () => {\r\n    this._onOffline.emit();\r\n  }\r\n\r\n  private _handleOnError = (e: IOnErrorEvent) => {\r\n    this._onError.emit(e);\r\n    console.error(e);\r\n  }\r\n\r\n  private _handleOnEnd = () => {\r\n    this._onEnd.emit();\r\n  }\r\n\r\n  private _handleOnMessage = (topic: string, payload: Buffer, packet: Packet) => {\r\n    this._onMessage.emit(packet);\r\n    if (packet.cmd === 'publish') {\r\n      this.messages.next(packet as any);\r\n    }\r\n  }\r\n\r\n  private _handleOnPacketsend = (e: IOnPacketsendEvent) => {\r\n    this._onPacketsend.emit(e);\r\n  }\r\n\r\n  private _handleOnPacketreceive = (e: IOnPacketreceiveEvent) => {\r\n    this._onPacketreceive.emit(e);\r\n  }\r\n\r\n  private _generateClientId() {\r\n    return 'client-' + Math.random().toString(36).substr(2, 19);\r\n  }\r\n}\r\n"]}