8492131351

Committed 30 Mar 2024 04:55PM UTC coverage: 78.63% (-0.1%) from 78.738%

Build # 8492131351

Build Type

Pull #193

github

Committed by

web-flow

Commit Message

Merge 55cabc672 into 40cd03278

Pull Request Pull Request #193: Support for Stream URL

Run Details

874 of 1154 branches covered (75.74%)

Branch coverage included in aggregate %.

14 of 19 new or added lines in 4 files covered. (73.68%)

2 existing lines in 1 file now uncovered.

1698 of 2117 relevant lines covered (80.21%)

77.86 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

64.35

/src/sonos-manager.ts

import debug, { Debugger } from 'debug';
import { EventEmitter } from 'events';
import { ZoneGroup } from './models/zone-group';
import { ZoneGroupTopologyService, ZoneGroupTopologyServiceEvent } from './services';
import SonosDevice from './sonos-device';
import SonosDeviceDiscovery from './sonos-device-discovery';
import { ServiceEvents, PlayNotificationOptions, PlayTtsOptions } from './models';
import IpHelper from './helpers/ip-helper';
import TtsHelper from './helpers/tts-helper';
import AsyncHelper from './helpers/async-helper';
import SonosError from './models/sonos-error';
/**
 * The SonosManager will manage the logical devices for you. It will also manage group updates so be sure to call .Close on exit to remove open listeners.
 *
 * @export
 * @class SonosManager
 */
export default class SonosManager {
  private readonly events: EventEmitter;

  private readonly debug: Debugger;

  private devices: SonosDevice[] = [];

  private zoneService: ZoneGroupTopologyService | undefined;

  constructor() {
    this.events = new EventEmitter();
    this.debug = debug('sonos:sonosmanager');
  }

  /**
   * Initialize the manager with one known device. Useful in special network environments.
   *
   * @param {string} host
   * @param {number} [port=1400]
   * @returns {Promise<boolean>}
   * @memberof SonosManager
   */
  public async InitializeFromDevice(host: string, port = 1400): Promise<boolean> {
    this.debug('InitializeFromDevice %s', host);
    const ip = IpHelper.IsIpv4(host) ? host : await IpHelper.ResolveHostname(host);
    this.zoneService = new ZoneGroupTopologyService(ip, port);
    return await this.Initialize();
  }

  /**
   * Initialize the manager by searching for one Sonos device in your network.
   *
   * @param {number} [timeoutInSeconds=10]
   * @returns {Promise<boolean>}
   * @memberof SonosManager
   */
  public async InitializeWithDiscovery(timeoutInSeconds = 10, discovery = new SonosDeviceDiscovery()): Promise<boolean> {
    this.debug('InitializeWithDiscovery timeout: %d', timeoutInSeconds);
    const player = await discovery.SearchOne(timeoutInSeconds);
    this.debug('Discovery found player with ip: %s', player.host);
    this.zoneService = new ZoneGroupTopologyService(player.host, player.port);
    return await this.Initialize();
  }

  private async Initialize(): Promise<boolean> {
    this.debug('Initialize()');
    const groups = await this
      .LoadAllGroups()
      .catch((err) => {
        this.debug('Error loading groups with pull %o', err);
        if (err instanceof SonosError && err.UpnpErrorCode === 501) {
          // This happens with big systems, try loading with events
          return this.LoadAllGroupsWithEvent();
        }
        throw err;
      });
    const success = this.InitializeWithGroups(groups);
    return this.SubscribeForGroupEvents(success);
  }

  private async LoadAllGroups(): Promise<ZoneGroup[]> {
    this.debug('LoadAllGroups()');
    if (this.zoneService === undefined) throw new Error('Manager is\'t initialized');
    return await this.zoneService.GetParsedZoneGroupState();
  }

  private async LoadAllGroupsWithEvent(): Promise<ZoneGroup[]> {
    this.debug('LoadAllGroupsWithEvent()');
    if (this.zoneService === undefined) throw new Error('Manager is\'t initialized');
    return await AsyncHelper
      .AsyncEvent<ZoneGroupTopologyServiceEvent>(this.zoneService.Events, ServiceEvents.ServiceEvent, 5)
      .then((data) => {
        if (!Array.isArray(data.ZoneGroupState)) {
          throw new Error('No groups in event');
        }
        return data.ZoneGroupState;
      });
  }

  private InitializeWithGroups(groups: ZoneGroup[]): boolean {
    groups.forEach((g) => {
      const coordinator = new SonosDevice(g.coordinator.host, g.coordinator.port, g.coordinator.uuid, g.coordinator.name, { name: g.name, managerEvents: this.events, groupId: g.groupId });
      if (this.devices.findIndex((v) => v.Uuid === coordinator.Uuid) === -1) this.devices.push(coordinator);
      g.members.forEach((m) => {
        // Check if device exists
        if (this.devices.findIndex((v) => v.Uuid === m.uuid) === -1) {
          this.devices.push(new SonosDevice(m.host, m.port, m.uuid, m.name, { coordinator: m.uuid === g.coordinator.uuid ? undefined : coordinator, name: g.name, managerEvents: this.events, groupId: g.groupId }));
        }
      });
    });
    return true;
  }

  private SubscribeForGroupEvents(success: boolean): boolean {
    if (success && this.zoneService) {
      this.zoneService.Events.on(ServiceEvents.ServiceEvent, this.zoneEventSubscription);
    }
    return success;
  }

  private zoneEventSubscription = this.handleZoneEventData.bind(this);

  private handleZoneEventData(data: ZoneGroupTopologyServiceEvent): void {
    if (data.ZoneGroupState !== undefined && typeof data.ZoneGroupState !== 'string') {
      data.ZoneGroupState.forEach((g) => {
        let coordinator = this.devices.find((d) => d.Uuid === g.coordinator.uuid);
        if (coordinator === undefined) {
          coordinator = new SonosDevice(g.coordinator.host, g.coordinator.port, g.coordinator.uuid, g.coordinator.name, { coordinator: undefined, name: g.name, managerEvents: this.events, groupId: g.groupId });
          this.devices.push(coordinator);
          this.events.emit('NewDevice', coordinator);
        }

        // New members
        g.members
          .filter((m) => !this.devices.some((d) => d.Uuid === m.uuid))
          .forEach((m) => {
            const newDevice = new SonosDevice(m.host, m.port, m.uuid, m.name, { coordinator: m.uuid === g.coordinator.uuid ? undefined : coordinator, name: g.name, managerEvents: this.events, groupId: g.groupId });
            this.devices.push(newDevice);
            this.events.emit('NewDevice', newDevice);
          });

        g.members.forEach((m) => {
          this.events.emit(m.uuid, { coordinator: g.coordinator.uuid === m.uuid ? undefined : coordinator, name: g.name, groupId: g.groupId });
        });
      });
    }
  }

  /**
   * Cancel the subscription (this will unsubscribe for zone events)
   *
   * @memberof SonosManager
   */
  public CancelSubscription(): void {
    if (this.zoneService !== undefined) this.zoneService.Events.removeListener(ServiceEvents.ServiceEvent, this.zoneEventSubscription);
  }

  /**
   * Get all found devices, call InitializeWithDiscovery or InitializeFromDevice first.
   *
   * @readonly
   * @type {SonosDevice[]}
   * @memberof SonosManager
   */
  public get Devices(): SonosDevice[] {
    if (this.devices.length === 0) throw new Error('No Devices available!');
    return this.devices;
  }

  /**
   * Subscribe to receive new devices.
   *
   * @param {(device: SonosDevice) => void} listener
   * @memberof SonosManager
   */
  public OnNewDevice(listener: (device: SonosDevice) => void): void {
    this.events.on('NewDevice', listener);
  }

  /**
   * Play a notification on all groups, without changing the current groups (for now).
   *
   * @param {PlayNotificationOptions} options The options
   * @param {string} options.trackUri The uri of the sound to play as notification, can be every supported sonos uri.
   * @param {string|Track} [options.metadata] The metadata of the track to play, will be guesses if undefined.
   * @param {number} [options.delayMs] Delay in ms between commands, for better notification playback stability
   * @param {boolean} [options.onlyWhenPlaying] Only play a notification if currently playing music. You don't have to check if the user is home ;)
   * @param {number} [options.timeout] Number of seconds the notification should play, as a fallback if the event doesn't come through.
   * @param {number} [options.volume] Change the volume for the notication and revert afterwards.
   * @returns {Promise<boolean>} Returns true is notification was played (and the state is set back to original)
   * @memberof SonosManager
   */
  public async PlayNotification(options: PlayNotificationOptions): Promise<boolean> {
    this.debug('PlayNotification(%o)', options);

    const commands = this.Devices
      .filter((d) => d.IsCoordinator)
      .map((d) => d.PlayNotification(options).catch(() => false));
    return Promise
      .all(commands)
      .then((values) => values.some((v) => v));
  }

  /**
   * Play text to speech message on all groups, without changing the current groups (for now).
   *
   * @param {PlayTtsOptions} options
   * @param {string} options.text Text to request a TTS file for.
   * @param {string} options.lang Language to request tts file for.
   * @param {string} [options.endpoint] TTS endpoint, see documentation, can also be set by environment variable 'SONOS_TTS_ENDPOINT'
   * @param {string} [options.gender] Supply gender, some languages support both genders.
   * @param {string} [options.name] Supply voice name, some services support several voices with different names.
   * @param {number} [options.delayMs] Delay in ms between commands, for better notification playback stability
   * @param {boolean} [options.onlyWhenPlaying] Only play a notification if currently playing music. You don't have to check if the user is home ;)
   * @param {number} [options.timeout] Number of seconds the notification should play, as a fallback if the event doesn't come through.
   * @param {number} [options.volume] Change the volume for the notication and revert afterwards.
   * @returns {Promise<boolean>} returns true if notification actually played
   * @memberof SonosDevice
   */
  public async PlayTTS(options: PlayTtsOptions): Promise<boolean> {
    this.debug('PlayTTS(%o)', options);
    const notificationOptions = await TtsHelper.TtsOptionsToNotification(options);
    if (typeof (notificationOptions) === 'undefined') {
      return false;
    }

    return await this.PlayNotification(notificationOptions);
  }

  /**
   * Check the event subscriptions for all known devices.
   *
   * @returns {Promise<void>}
   * @memberof SonosManager
   */
  public async CheckAllEventSubscriptions(): Promise<void> {
    await this.zoneService?.CheckEventListener();
    await Promise.all(this.devices.map((device) => device.RefreshEventSubscriptions().catch()));
  }
}

1	import debug, { Debugger } from 'debug';	1✔
2	import { EventEmitter } from 'events';	1✔
3	import { ZoneGroup } from './models/zone-group';
4	import { ZoneGroupTopologyService, ZoneGroupTopologyServiceEvent } from './services';	1✔
5	import SonosDevice from './sonos-device';	1✔
6	import SonosDeviceDiscovery from './sonos-device-discovery';	1✔
7	import { ServiceEvents, PlayNotificationOptions, PlayTtsOptions } from './models';	1✔
8	import IpHelper from './helpers/ip-helper';	1✔
9	import TtsHelper from './helpers/tts-helper';	1✔
10	import AsyncHelper from './helpers/async-helper';	1✔
11	import SonosError from './models/sonos-error';	1✔
12	/**
13	* The SonosManager will manage the logical devices for you. It will also manage group updates so be sure to call .Close on exit to remove open listeners.
14	*
15	* @export
16	* @class SonosManager
17	*/
18	export default class SonosManager {	1✔
19	private readonly events: EventEmitter;
20
21	private readonly debug: Debugger;
22
23	private devices: SonosDevice[] = [];	4✔
24
25	private zoneService: ZoneGroupTopologyService \| undefined;
26
27	constructor() {
28	this.events = new EventEmitter();	4✔
29	this.debug = debug('sonos:sonosmanager');	4✔
30	}
31
32	/**
33	* Initialize the manager with one known device. Useful in special network environments.
34	*
35	* @param {string} host
36	* @param {number} [port=1400]
37	* @returns {Promise<boolean>}
38	* @memberof SonosManager
39	*/
40	public async InitializeFromDevice(host: string, port = 1400): Promise<boolean> {	×
41	this.debug('InitializeFromDevice %s', host);	3✔
42	const ip = IpHelper.IsIpv4(host) ? host : await IpHelper.ResolveHostname(host);	3!
43	this.zoneService = new ZoneGroupTopologyService(ip, port);	3✔
44	return await this.Initialize();	3✔
45	}
46
47	/**
48	* Initialize the manager by searching for one Sonos device in your network.
49	*
50	* @param {number} [timeoutInSeconds=10]
51	* @returns {Promise<boolean>}
52	* @memberof SonosManager
53	*/
54	public async InitializeWithDiscovery(timeoutInSeconds = 10, discovery = new SonosDeviceDiscovery()): Promise<boolean> {	×
55	this.debug('InitializeWithDiscovery timeout: %d', timeoutInSeconds);	1✔
56	const player = await discovery.SearchOne(timeoutInSeconds);	1✔
57	this.debug('Discovery found player with ip: %s', player.host);	1✔
58	this.zoneService = new ZoneGroupTopologyService(player.host, player.port);	1✔
59	return await this.Initialize();	1✔
60	}
61
62	private async Initialize(): Promise<boolean> {
63	this.debug('Initialize()');	4✔
64	const groups = await this	4✔
65	.LoadAllGroups()
66	.catch((err) => {
67	this.debug('Error loading groups with pull %o', err);	×
68	if (err instanceof SonosError && err.UpnpErrorCode === 501) {	×
69	// This happens with big systems, try loading with events
70	return this.LoadAllGroupsWithEvent();	×
71	}
72	throw err;	×
73	});
74	const success = this.InitializeWithGroups(groups);	4✔
75	return this.SubscribeForGroupEvents(success);	4✔
76	}
77
78	private async LoadAllGroups(): Promise<ZoneGroup[]> {
79	this.debug('LoadAllGroups()');	4✔
80	if (this.zoneService === undefined) throw new Error('Manager is\'t initialized');	4!
81	return await this.zoneService.GetParsedZoneGroupState();	4✔
82	}
83
84	private async LoadAllGroupsWithEvent(): Promise<ZoneGroup[]> {
85	this.debug('LoadAllGroupsWithEvent()');	×
86	if (this.zoneService === undefined) throw new Error('Manager is\'t initialized');	×
87	return await AsyncHelper	×
88	.AsyncEvent<ZoneGroupTopologyServiceEvent>(this.zoneService.Events, ServiceEvents.ServiceEvent, 5)
89	.then((data) => {
90	if (!Array.isArray(data.ZoneGroupState)) {	×
91	throw new Error('No groups in event');	×
92	}
93	return data.ZoneGroupState;	×
94	});
95	}
96
97	private InitializeWithGroups(groups: ZoneGroup[]): boolean {
98	groups.forEach((g) => {	4✔
99	const coordinator = new SonosDevice(g.coordinator.host, g.coordinator.port, g.coordinator.uuid, g.coordinator.name, { name: g.name, managerEvents: this.events, groupId: g.groupId });	4✔
100	if (this.devices.findIndex((v) => v.Uuid === coordinator.Uuid) === -1) this.devices.push(coordinator);	4✔
101	g.members.forEach((m) => {	4✔
102	// Check if device exists
103	if (this.devices.findIndex((v) => v.Uuid === m.uuid) === -1) {	16✔
104	this.devices.push(new SonosDevice(m.host, m.port, m.uuid, m.name, { coordinator: m.uuid === g.coordinator.uuid ? undefined : coordinator, name: g.name, managerEvents: this.events, groupId: g.groupId }));	8!
105	}
106	});
107	});
108	return true;	4✔
109	}
110
111	private SubscribeForGroupEvents(success: boolean): boolean {
112	if (success && this.zoneService) {	4✔
113	this.zoneService.Events.on(ServiceEvents.ServiceEvent, this.zoneEventSubscription);	4✔
114	}
115	return success;	4✔
116	}
117
118	private zoneEventSubscription = this.handleZoneEventData.bind(this);	4✔
119
120	private handleZoneEventData(data: ZoneGroupTopologyServiceEvent): void {
121	if (data.ZoneGroupState !== undefined && typeof data.ZoneGroupState !== 'string') {	1✔
122	data.ZoneGroupState.forEach((g) => {	1✔
123	let coordinator = this.devices.find((d) => d.Uuid === g.coordinator.uuid);	3✔
124	if (coordinator === undefined) {	1✔
125	coordinator = new SonosDevice(g.coordinator.host, g.coordinator.port, g.coordinator.uuid, g.coordinator.name, { coordinator: undefined, name: g.name, managerEvents: this.events, groupId: g.groupId });	1✔
126	this.devices.push(coordinator);	1✔
127	this.events.emit('NewDevice', coordinator);	1✔
128	}
129
130	// New members
131	g.members	1✔
132	.filter((m) => !this.devices.some((d) => d.Uuid === m.uuid))	4✔
133	.forEach((m) => {
NEW 134	const newDevice = new SonosDevice(m.host, m.port, m.uuid, m.name, { coordinator: m.uuid === g.coordinator.uuid ? undefined : coordinator, name: g.name, managerEvents: this.events, groupId: g.groupId });	×
135	this.devices.push(newDevice);	×
136	this.events.emit('NewDevice', newDevice);	×
137	});
138
139	g.members.forEach((m) => {	1✔
140	this.events.emit(m.uuid, { coordinator: g.coordinator.uuid === m.uuid ? undefined : coordinator, name: g.name, groupId: g.groupId });	1!
141	});
142	});
143	}
144	}
145
146	/**
147	* Cancel the subscription (this will unsubscribe for zone events)
148	*
149	* @memberof SonosManager
150	*/
151	public CancelSubscription(): void {
152	if (this.zoneService !== undefined) this.zoneService.Events.removeListener(ServiceEvents.ServiceEvent, this.zoneEventSubscription);	4✔
153	}
154
155	/**
156	* Get all found devices, call InitializeWithDiscovery or InitializeFromDevice first.
157	*
158	* @readonly
159	* @type {SonosDevice[]}
160	* @memberof SonosManager
161	*/
162	public get Devices(): SonosDevice[] {
163	if (this.devices.length === 0) throw new Error('No Devices available!');	4!
164	return this.devices;	4✔
165	}
166
167	/**
168	* Subscribe to receive new devices.
169	*
170	* @param {(device: SonosDevice) => void} listener
171	* @memberof SonosManager
172	*/
173	public OnNewDevice(listener: (device: SonosDevice) => void): void {
174	this.events.on('NewDevice', listener);	1✔
175	}
176
177	/**
178	* Play a notification on all groups, without changing the current groups (for now).
179	*
180	* @param {PlayNotificationOptions} options The options
181	* @param {string} options.trackUri The uri of the sound to play as notification, can be every supported sonos uri.
182	* @param {string\|Track} [options.metadata] The metadata of the track to play, will be guesses if undefined.
183	* @param {number} [options.delayMs] Delay in ms between commands, for better notification playback stability
184	* @param {boolean} [options.onlyWhenPlaying] Only play a notification if currently playing music. You don't have to check if the user is home ;)
185	* @param {number} [options.timeout] Number of seconds the notification should play, as a fallback if the event doesn't come through.
186	* @param {number} [options.volume] Change the volume for the notication and revert afterwards.
187	* @returns {Promise<boolean>} Returns true is notification was played (and the state is set back to original)
188	* @memberof SonosManager
189	*/
190	public async PlayNotification(options: PlayNotificationOptions): Promise<boolean> {
191	this.debug('PlayNotification(%o)', options);	×
192
193	const commands = this.Devices	×
194	.filter((d) => d.IsCoordinator)	×
195	.map((d) => d.PlayNotification(options).catch(() => false));	×
196	return Promise	×
197	.all(commands)
198	.then((values) => values.some((v) => v));	×
199	}
200
201	/**
202	* Play text to speech message on all groups, without changing the current groups (for now).
203	*
204	* @param {PlayTtsOptions} options
205	* @param {string} options.text Text to request a TTS file for.
206	* @param {string} options.lang Language to request tts file for.
207	* @param {string} [options.endpoint] TTS endpoint, see documentation, can also be set by environment variable 'SONOS_TTS_ENDPOINT'
208	* @param {string} [options.gender] Supply gender, some languages support both genders.
209	* @param {string} [options.name] Supply voice name, some services support several voices with different names.
210	* @param {number} [options.delayMs] Delay in ms between commands, for better notification playback stability
211	* @param {boolean} [options.onlyWhenPlaying] Only play a notification if currently playing music. You don't have to check if the user is home ;)
212	* @param {number} [options.timeout] Number of seconds the notification should play, as a fallback if the event doesn't come through.
213	* @param {number} [options.volume] Change the volume for the notication and revert afterwards.
214	* @returns {Promise<boolean>} returns true if notification actually played
215	* @memberof SonosDevice
216	*/
217	public async PlayTTS(options: PlayTtsOptions): Promise<boolean> {
218	this.debug('PlayTTS(%o)', options);	×
219	const notificationOptions = await TtsHelper.TtsOptionsToNotification(options);	×
220	if (typeof (notificationOptions) === 'undefined') {	×
221	return false;	×
222	}
223
224	return await this.PlayNotification(notificationOptions);	×
225	}
226
227	/**
228	* Check the event subscriptions for all known devices.
229	*
230	* @returns {Promise<void>}
231	* @memberof SonosManager
232	*/
233	public async CheckAllEventSubscriptions(): Promise<void> {
234	await this.zoneService?.CheckEventListener();	1!
235	await Promise.all(this.devices.map((device) => device.RefreshEventSubscriptions().catch()));	3✔
236	}
237	}

svrooij / node-sonos-ts / 8492131351

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous