ambiser
/
openvidu
mirror of https://github.com/OpenVidu/openvidu.git
8
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

openvidu-browser: filter refactoring (methods from Session to Stream/Filter)

pull/108/merge
pabloFuente 2018-08-28 11:24:26 +02:00
parent b44839f95b
commit d3b25765d1
7 changed files with 227 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

128
openvidu-browser/src/OpenVidu/Filter.ts
View File

@ -15,6 +15,13 @@
* *
*/ */
import { Stream } from './Stream';
import { FilterEvent } from '../OpenViduInternal/Events/FilterEvent';
import { StreamPropertyChangedEvent } from '../OpenViduInternal/Events/StreamPropertyChangedEvent';
import { OpenViduError, OpenViduErrorName } from '../OpenViduInternal/Enums/OpenViduError';
import { ObjMap } from '../OpenViduInternal/Interfaces/Private/ObjMap';
/** /**
* **WARNING**: experimental option. This interface may change in the near future * **WARNING**: experimental option. This interface may change in the near future
* *
@ -51,6 +58,16 @@ export class Filter {
method: string, params: Object method: string, params: Object
}; };
/**
* @hidden
*/
handlers: ObjMap<(event: FilterEvent) => void> = {};
/**
* @hidden
*/
stream: Stream;
/** /**
* @hidden * @hidden
@ -60,4 +77,115 @@ export class Filter {
this.options = options; this.options = options;
} }
/**
* Executes a filter method. Available methods are specific for each filter
*
* @param method Name of the method
* @param params Parameters of the method
*/
execMethod(method: string, params: Object): Promise<any> {
return new Promise((resolve, reject) => {
console.info('Executing filter method to stream ' + this.stream.streamId);
let stringParams;
if (typeof params !== 'string') {
try {
stringParams = JSON.stringify(params);
} catch (error) {
const errorMsg = "'params' property must be a JSON formatted object";
console.error(errorMsg);
reject(errorMsg);
}
} else {
stringParams = <string>params;
}
this.stream.session.openvidu.sendRequest(
'execFilterMethod',
{ streamId: this.stream.streamId, method, params: stringParams },
(error, response) => {
if (error) {
console.error('Error executing filter method for Stream ' + this.stream.streamId, error);
if (error.code === 401) {
reject(new OpenViduError(OpenViduErrorName.OPENVIDU_PERMISSION_DENIED, "You don't have permissions to execute a filter method"));
} else {
reject(error);
}
} else {
console.info('Filter method successfully executed on Stream ' + this.stream.streamId);
const oldValue = (<any>Object).assign({}, this.stream.filter);
this.stream.filter.lastExecMethod = { method, params: JSON.parse(stringParams) };
this.stream.session.emitEvent('streamPropertyChanged', [new StreamPropertyChangedEvent(this.stream.session, this.stream, 'filter', this.stream.filter, oldValue, 'execFilterMethod')]);
this.stream.streamManager.emitEvent('streamPropertyChanged', [new StreamPropertyChangedEvent(this.stream.streamManager, this.stream, 'filter', this.stream.filter, oldValue, 'execFilterMethod')]);
resolve();
}
}
);
});
}
/**
* Subscribe to certain filter event. Available events are specific for each filter
*
* @param eventType Event to which subscribe to.
* @param handler Function to execute upon event dispatched. It receives as parameter a [[FilterEvent]] object
*
* @returns A Promise (to which you can optionally subscribe to) that is resolved if the event listener was successfully attached to the filter and rejected with an Error object if not
*/
addEventListener(eventType: string, handler: (event: FilterEvent) => void): Promise<any> {
return new Promise((resolve, reject) => {
console.info('Adding filter event listener to event ' + eventType + ' to stream ' + this.stream.streamId);
this.stream.session.openvidu.sendRequest(
'addFilterEventListener',
{ streamId: this.stream.streamId, type: eventType },
(error, response) => {
if (error) {
console.error('Error adding filter event listener to event ' + eventType + 'for Stream ' + this.stream.streamId, error);
if (error.code === 401) {
reject(new OpenViduError(OpenViduErrorName.OPENVIDU_PERMISSION_DENIED, "You don't have permissions to add a filter event listener"));
} else {
reject(error);
}
} else {
this.handlers[eventType] = handler;
console.info('Filter event listener to event ' + eventType + ' successfully applied on Stream ' + this.stream.streamId);
resolve();
}
}
);
});
}
/**
* Removes certain filter event listener previously set.
*
* @param eventType Event to unsubscribe from.
*
* @returns A Promise (to which you can optionally subscribe to) that is resolved if the event listener was successfully removed from the filter and rejected with an Error object in other case
*/
removeEventListener(eventType: string): Promise<any> {
return new Promise((resolve, reject) => {
console.info('Removing filter event listener to event ' + eventType + ' to stream ' + this.stream.streamId);
this.stream.session.openvidu.sendRequest(
'removeFilterEventListener',
{ streamId: this.stream.streamId, type: eventType },
(error, response) => {
if (error) {
console.error('Error removing filter event listener to event ' + eventType + 'for Stream ' + this.stream.streamId, error);
if (error.code === 401) {
reject(new OpenViduError(OpenViduErrorName.OPENVIDU_PERMISSION_DENIED, "You don't have permissions to add a filter event listener"));
} else {
reject(error);
}
} else {
delete this.handlers[eventType];
console.info('Filter event listener to event ' + eventType + ' successfully removed on Stream ' + this.stream.streamId);
resolve();
}
}
);
});
}
} }

159
openvidu-browser/src/OpenVidu/Session.ts
View File

@ -494,148 +494,6 @@ export class Session implements EventDispatcher {
}); });
} }
applyFilter(stream: Stream, type: string, options: Object): Promise<any> {
return new Promise((resolve, reject) => {
console.info('Applying filter to stream ' + stream.streamId);
options = !!options ? options : {};
if (typeof options !== 'string') {
options = JSON.stringify(options);
}
this.openvidu.sendRequest(
'applyFilter',
{ streamId: stream.streamId, type, options },
(error, response) => {
if (error) {
console.error('Error applying filter for Stream ' + stream.streamId, error);
if (error.code === 401) {
reject(new OpenViduError(OpenViduErrorName.OPENVIDU_PERMISSION_DENIED, "You don't have permissions to apply a filter"));
} else {
reject(error);
}
} else {
console.info('Filter successfully applied on Stream ' + stream.streamId);
const oldValue: Filter = stream.filter;
stream.filter = new Filter(type, options);
this.emitEvent('streamPropertyChanged', [new StreamPropertyChangedEvent(this, stream, 'filter', stream.filter, oldValue, 'applyFilter')]);
stream.streamManager.emitEvent('streamPropertyChanged', [new StreamPropertyChangedEvent(stream.streamManager, stream, 'filter', stream.filter, oldValue, 'applyFilter')]);
resolve();
}
}
);
});
}
execFilterMethod(stream: Stream, method: string, params: Object): Promise<any> {
return new Promise((resolve, reject) => {
console.info('Executing filter method to stream ' + stream.streamId);
let stringParams;
if (typeof params !== 'string') {
try {
stringParams = JSON.stringify(params);
} catch (error) {
const errorMsg = "'params' property must be a JSON formatted object";
console.error(errorMsg);
reject(errorMsg);
}
} else {
stringParams = <string>params;
}
this.openvidu.sendRequest(
'execFilterMethod',
{ streamId: stream.streamId, method, params: stringParams },
(error, response) => {
if (error) {
console.error('Error executing filter method for Stream ' + stream.streamId, error);
if (error.code === 401) {
reject(new OpenViduError(OpenViduErrorName.OPENVIDU_PERMISSION_DENIED, "You don't have permissions to execute a filter method"));
} else {
reject(error);
}
} else {
console.info('Filter method successfully executed on Stream ' + stream.streamId);
const oldValue = JSON.parse(JSON.stringify(stream.filter));
stream.filter.lastExecMethod = { method, params: JSON.parse(stringParams) };
this.emitEvent('streamPropertyChanged', [new StreamPropertyChangedEvent(this, stream, 'filter', stream.filter, oldValue, 'execFilterMethod')]);
stream.streamManager.emitEvent('streamPropertyChanged', [new StreamPropertyChangedEvent(stream.streamManager, stream, 'filter', stream.filter, oldValue, 'execFilterMethod')]);
resolve();
}
}
);
});
}
removeFilter(stream: Stream): Promise<any> {
return new Promise((resolve, reject) => {
console.info('Removing filter of stream ' + stream.streamId);
this.openvidu.sendRequest(
'removeFilter',
{ streamId: stream.streamId },
(error, response) => {
if (error) {
console.error('Error removing filter for Stream ' + stream.streamId, error);
if (error.code === 401) {
reject(new OpenViduError(OpenViduErrorName.OPENVIDU_PERMISSION_DENIED, "You don't have permissions to remove a filter"));
} else {
reject(error);
}
} else {
console.info('Filter successfully removed from Stream ' + stream.streamId);
const oldValue = JSON.parse(JSON.stringify(stream.filter));
delete stream.filter;
this.emitEvent('streamPropertyChanged', [new StreamPropertyChangedEvent(this, stream, 'filter', stream.filter, oldValue, 'applyFilter')]);
stream.streamManager.emitEvent('streamPropertyChanged', [new StreamPropertyChangedEvent(stream.streamManager, stream, 'filter', stream.filter, oldValue, 'applyFilter')]);
resolve();
}
}
);
});
}
addFilterEventListener(stream: Stream, eventType: string): Promise<any> {
return new Promise((resolve, reject) => {
console.info('Adding filter event listener to event ' + eventType + ' to stream ' + stream.streamId);
this.openvidu.sendRequest(
'addFilterEventListener',
{ streamId: stream.streamId, type: eventType },
(error, response) => {
if (error) {
console.error('Error adding filter event listener to event ' + eventType + 'for Stream ' + stream.streamId, error);
if (error.code === 401) {
reject(new OpenViduError(OpenViduErrorName.OPENVIDU_PERMISSION_DENIED, "You don't have permissions to add a filter event listener"));
} else {
reject(error);
}
} else {
console.info('Filter event listener to event ' + eventType + ' successfully applied on Stream ' + stream.streamId);
resolve();
}
}
);
});
}
removeFilterEventListener(stream: Stream, eventType: string): Promise<any> {
return new Promise((resolve, reject) => {
console.info('Removing filter event listener to event ' + eventType + ' to stream ' + stream.streamId);
this.openvidu.sendRequest(
'removeFilterEventListener',
{ streamId: stream.streamId, type: eventType },
(error, response) => {
if (error) {
console.error('Error removing filter event listener to event ' + eventType + 'for Stream ' + stream.streamId, error);
if (error.code === 401) {
reject(new OpenViduError(OpenViduErrorName.OPENVIDU_PERMISSION_DENIED, "You don't have permissions to add a filter event listener"));
} else {
reject(error);
}
} else {
console.info('Filter event listener to event ' + eventType + ' successfully removed on Stream ' + stream.streamId);
resolve();
}
}
);
});
}
/** /**
* Sends one signal. `signal` object has the following optional properties: * Sends one signal. `signal` object has the following optional properties:
@ -685,7 +543,7 @@ export class Session implements EventDispatcher {
/** /**
* See [[EventDispatcher.on]] * See [[EventDispatcher.on]]
*/ */
on(type: string, handler: (event: SessionDisconnectedEvent | SignalEvent | StreamEvent | ConnectionEvent | PublisherSpeakingEvent | RecordingEvent | FilterEvent) => void): EventDispatcher { on(type: string, handler: (event: SessionDisconnectedEvent | SignalEvent | StreamEvent | ConnectionEvent | PublisherSpeakingEvent | RecordingEvent) => void): EventDispatcher {
this.ee.on(type, event => { this.ee.on(type, event => {
if (event) { if (event) {
@ -939,7 +797,16 @@ export class Session implements EventDispatcher {
case 'filter': case 'filter':
oldValue = stream.filter; oldValue = stream.filter;
msg.newValue = (Object.keys(msg.newValue).length > 0) ? msg.newValue : undefined; msg.newValue = (Object.keys(msg.newValue).length > 0) ? msg.newValue : undefined;
stream.filter = msg.newValue; if (msg.newValue !== undefined) {
stream.filter = new Filter(msg.newValue.type, msg.newValue.options);
stream.filter.stream = stream;
if (msg.newValue.lastExecMethod) {
stream.filter.lastExecMethod = msg.newValue.lastExecMethod;
}
} else {
delete stream.filter;
}
msg.newValue = stream.filter;
break; break;
} }
@ -1063,9 +930,9 @@ export class Session implements EventDispatcher {
const streamId: string = response.streamId; const streamId: string = response.streamId;
this.getConnection(connectionId, 'No connection found for connectionId ' + connectionId) this.getConnection(connectionId, 'No connection found for connectionId ' + connectionId)
.then(connection => { .then(connection => {
console.info('Filter event dispatched');
const stream: Stream = connection.stream; const stream: Stream = connection.stream;
stream.ee.emitEvent('filterEventDispatched', [new FilterEvent(stream, stream.filter, response.eventType, response.data)]); stream.filter.handlers[response.eventType](new FilterEvent(stream.filter, response.eventType, response.data));
this.ee.emitEvent('filterEventDispatched', [new FilterEvent(stream, stream.filter, response.eventType, response.data)]);
}); });
} }

79
openvidu-browser/src/OpenVidu/Stream.ts
View File

@ -26,6 +26,7 @@ import { OutboundStreamOptions } from '../OpenViduInternal/Interfaces/Private/Ou
import { WebRtcPeer, WebRtcPeerSendonly, WebRtcPeerRecvonly, WebRtcPeerSendrecv } from '../OpenViduInternal/WebRtcPeer/WebRtcPeer'; import { WebRtcPeer, WebRtcPeerSendonly, WebRtcPeerRecvonly, WebRtcPeerSendrecv } from '../OpenViduInternal/WebRtcPeer/WebRtcPeer';
import { WebRtcStats } from '../OpenViduInternal/WebRtcStats/WebRtcStats'; import { WebRtcStats } from '../OpenViduInternal/WebRtcStats/WebRtcStats';
import { PublisherSpeakingEvent } from '../OpenViduInternal/Events/PublisherSpeakingEvent'; import { PublisherSpeakingEvent } from '../OpenViduInternal/Events/PublisherSpeakingEvent';
import { StreamPropertyChangedEvent } from '../OpenViduInternal/Events/StreamPropertyChangedEvent';
import EventEmitter = require('wolfy87-eventemitter'); import EventEmitter = require('wolfy87-eventemitter');
import hark = require('hark'); import hark = require('hark');
@ -106,8 +107,8 @@ export class Stream implements EventDispatcher {
/** /**
* **WARNING**: experimental option. This interface may change in the near future * **WARNING**: experimental option. This interface may change in the near future
* *
* Filter applied to the Stream. You can apply filters by calling [[Session.applyFilter]], execute methods of the applied filter with * Filter applied to the Stream. You can apply filters by calling [[Stream.applyFilter]], execute methods of the applied filter with
* [[Session.execFilterMethod]] and remove it with [[Session.removeFilter]]. Be aware that the client calling this methods must have the * [[Filter.execMethod]] and remove it with [[Stream.removeFilter]]. Be aware that the client calling this methods must have the
* necessary permissions: the token owned by the client must have been initialized with the appropriated `allowedFilters` array. * necessary permissions: the token owned by the client must have been initialized with the appropriated `allowedFilters` array.
*/ */
filter: Filter; filter: Filter;
@ -257,6 +258,80 @@ export class Stream implements EventDispatcher {
} }
/**
*
* Applies an audio/video filter to the stream.
*
* @param type Type of filter applied. See [[Filter.type]]
* @param options Parameters used to initialize the filter. See [[Filter.options]]
*
* @returns A Promise (to which you can optionally subscribe to) that is resolved to the applied filter if success and rejected with an Error object if not
*/
applyFilter(type: string, options: Object): Promise<Filter> {
return new Promise((resolve, reject) => {
console.info('Applying filter to stream ' + this.streamId);
options = !!options ? options : {};
if (typeof options !== 'string') {
options = JSON.stringify(options);
}
this.session.openvidu.sendRequest(
'applyFilter',
{ streamId: this.streamId, type, options },
(error, response) => {
if (error) {
console.error('Error applying filter for Stream ' + this.streamId, error);
if (error.code === 401) {
reject(new OpenViduError(OpenViduErrorName.OPENVIDU_PERMISSION_DENIED, "You don't have permissions to apply a filter"));
} else {
reject(error);
}
} else {
console.info('Filter successfully applied on Stream ' + this.streamId);
const oldValue: Filter = this.filter;
this.filter = new Filter(type, options);
this.filter.stream = this;
this.session.emitEvent('streamPropertyChanged', [new StreamPropertyChangedEvent(this.session, this, 'filter', this.filter, oldValue, 'applyFilter')]);
this.streamManager.emitEvent('streamPropertyChanged', [new StreamPropertyChangedEvent(this.streamManager, this, 'filter', this.filter, oldValue, 'applyFilter')]);
resolve(this.filter);
}
}
);
});
}
/**
* Removes an audio/video filter previously applied.
*
* @returns A Promise (to which you can optionally subscribe to) that is resolved if the previously applied filter has been successfully removed and rejected with an Error object in other case
*/
removeFilter(): Promise<any> {
return new Promise((resolve, reject) => {
console.info('Removing filter of stream ' + this.streamId);
this.session.openvidu.sendRequest(
'removeFilter',
{ streamId: this.streamId },
(error, response) => {
if (error) {
console.error('Error removing filter for Stream ' + this.streamId, error);
if (error.code === 401) {
reject(new OpenViduError(OpenViduErrorName.OPENVIDU_PERMISSION_DENIED, "You don't have permissions to remove a filter"));
} else {
reject(error);
}
} else {
console.info('Filter successfully removed from Stream ' + this.streamId);
const oldValue = this.filter;
delete this.filter;
this.session.emitEvent('streamPropertyChanged', [new StreamPropertyChangedEvent(this.session, this, 'filter', this.filter, oldValue, 'applyFilter')]);
this.streamManager.emitEvent('streamPropertyChanged', [new StreamPropertyChangedEvent(this.streamManager, this, 'filter', this.filter, oldValue, 'applyFilter')]);
resolve();
}
}
);
});
}
/* Hidden methods */ /* Hidden methods */
/** /**

2
openvidu-browser/src/OpenViduInternal/Enums/OpenViduError.ts
View File

@ -83,7 +83,7 @@ export enum OpenViduErrorName {
/** /**
* The client tried to call a method without the required permissions. This can occur for methods [[Session.publish]], * The client tried to call a method without the required permissions. This can occur for methods [[Session.publish]],
* [[Session.forceUnpublish]] and [[Session.forceDisconnect]] * [[Session.forceUnpublish]], [[Session.forceDisconnect]], [[Stream.applyFilter]], [[Stream.removeFilter]]
*/ */
OPENVIDU_PERMISSION_DENIED = 'OPENVIDU_PERMISSION_DENIED', OPENVIDU_PERMISSION_DENIED = 'OPENVIDU_PERMISSION_DENIED',

5
openvidu-browser/src/OpenViduInternal/Events/Event.ts
View File

@ -15,6 +15,7 @@
* *
*/ */
import { Filter } from '../../OpenVidu/Filter';
import { StreamManager } from '../../OpenVidu/StreamManager'; import { StreamManager } from '../../OpenVidu/StreamManager';
import { Session } from '../../OpenVidu/Session'; import { Session } from '../../OpenVidu/Session';
import { Stream } from '../../OpenVidu/Stream'; import { Stream } from '../../OpenVidu/Stream';
@ -29,7 +30,7 @@ export abstract class Event {
/** /**
* The object that dispatched the event * The object that dispatched the event
*/ */
target: Session | Stream | StreamManager; target: Session | StreamManager | Filter;
/** /**
* The type of event. This is the same string you pass as first parameter when calling method `on()` of any object implementing [[EventDispatcher]] interface * The type of event. This is the same string you pass as first parameter when calling method `on()` of any object implementing [[EventDispatcher]] interface
@ -41,7 +42,7 @@ export abstract class Event {
/** /**
* @hidden * @hidden
*/ */
constructor(cancelable: boolean, target: Session | Stream | StreamManager, type: string) { constructor(cancelable: boolean, target: Session | StreamManager | Filter, type: string) {
this.cancelable = cancelable; this.cancelable = cancelable;
this.target = target; this.target = target;
this.type = type; this.type = type;

19
openvidu-browser/src/OpenViduInternal/Events/FilterEvent.ts
View File

@ -21,21 +21,10 @@ import { Filter } from '../../OpenVidu/Filter';
/** /**
* Defines the following events: * Defines every event dispatched by audio/video stream filters. You can subscribe to filter events by calling [[Filter.addEventListener]]
* - `filterEventDispatched`: dispatched by [[Stream]]. Only triggered if `Stream.on('filterEventDispatched', event => {})` was called
*/ */
export class FilterEvent extends Event { export class FilterEvent extends Event {
/**
* Filter affected
*/
filter: Filter;
/**
* Type of the event
*/
eventType: string;
/** /**
* Data of the event * Data of the event
*/ */
@ -44,10 +33,8 @@ export class FilterEvent extends Event {
/** /**
* @hidden * @hidden
*/ */
constructor(target: Stream, filter: Filter, eventType: string, data: Object) { constructor(target: Filter, eventType: string, data: Object) {
super(false, target, 'filterEventDispatched'); super(false, target, eventType);
this.filter = filter;
this.eventType = eventType;
this.data = data; this.data = data;
} }

2
openvidu-browser/src/OpenViduInternal/Events/StreamPropertyChangedEvent.ts
View File

@ -33,7 +33,7 @@ export class StreamPropertyChangedEvent extends Event {
stream: Stream; stream: Stream;
/** /**
* The property of the stream that changed. This value is either `"videoActive"`, `"audioActive"` or `"videoDimensions"` * The property of the stream that changed. This value is either `"videoActive"`, `"audioActive"`, `"videoDimensions"` or `"filter"`
*/ */
changedProperty: string; changedProperty: string;