jclic 2.2.1 → 2.3.0

package/src/media/ActiveMediaPlayer.js

@@ -1,297 +0,0 @@
-/**
- *  File    : media/ActiveMediaPlayer.js
- *  Created : 28/04/2015
- *  By      : Francesc Busquets <francesc@gmail.com>
- *
- *  JClic.js
- *  An HTML5 player of JClic activities
- *  https://projectestac.github.io/jclic.js
- *
- *  @source https://github.com/projectestac/jclic.js
- *
- *  @license EUPL-1.2
- *  @licstart
- *  (c) 2000-2020 Educational Telematic Network of Catalonia (XTEC)
- *
- *  Licensed under the EUPL, Version 1.1 or -as soon they will be approved by
- *  the European Commission- subsequent versions of the EUPL (the "Licence");
- *  You may not use this work except in compliance with the Licence.
- *
- *  You may obtain a copy of the Licence at:
- *  https://joinup.ec.europa.eu/software/page/eupl
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the Licence is distributed on an "AS IS" basis, WITHOUT
- *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- *  Licence for the specific language governing permissions and limitations
- *  under the Licence.
- *  @licend
- *  @module
- */
-
-/* global navigator */
-
-import $ from 'jquery';
-import AudioBuffer from './AudioBuffer.js';
-
-/**
- * This kind of object encapsulates a realized {@link module:media/MediaContent.MediaContent} and provides methods to start,
- * stop, pause and record different types of media (audio, video, MIDI, voice recording...)
- */
-export class ActiveMediaPlayer {
-  /**
-   * ActiveMediaPlayer constructor
-   * @param {module:media/MediaContent.MediaContent} mc - - The content used by this player
-   * @param {module:bags/MediaBag.MediaBag} mb - The project's MediaBag
-   * @param {module:JClicPlayer.JClicPlayer} ps - An object implementing the
-   * {@link http://projectestac.github.io/jclic/apidoc/edu/xtec/jclic/PlayStation.html PlayStation} interface,
-   * usually a {@link module:JClicPlayer.JClicPlayer JClicPlayer}.
-   */
-  constructor(mc, mb, ps) {
-    this.mc = mc;
-    this.ps = ps;
-    switch (mc.type) {
-      case 'RECORD_AUDIO':
-        if (ActiveMediaPlayer.AUDIO_BUFFERS) {
-          this.clearAudioBuffer(mc.recBuffer);
-          ActiveMediaPlayer.AUDIO_BUFFERS[mc.recBuffer] = new AudioBuffer(mc.length);
-        }
-      /* falls through */
-      case 'PLAY_RECORDED_AUDIO':
-        this.useAudioBuffer = true;
-        break;
-      case 'PLAY_AUDIO':
-      case 'PLAY_VIDEO':
-      case 'PLAY_MIDI':
-        this.mbe = mb.getElement(mc.file, true);
-        break;
-      default:
-        break;
-    }
-  }
-
-  /**
-   * Generates the objects that will play media
-   */
-  realize() {
-    if (this.mbe) {
-      this.mbe.build(mbe => {
-        if (mbe.data && mbe.data.pause && !mbe.data.paused && !mbe.data.ended && mbe.data.currentTime)
-          mbe.data.pause();
-        if ((mbe.type === 'video' || mbe.type === 'anim') && mbe.data) {
-          this.$visualComponent = $(mbe.data);
-          this.$visualComponent.css('z-index', 20);
-        }
-      }, this.ps, false, this.mc.level);
-    }
-  }
-
-  /**
-   * Plays the media, realizing it if needed.
-   * @param {module:boxes/ActiveBox.ActiveBox} [_setBx] - The active box where this media will be placed (when video)
-   */
-  playNow(_setBx) {
-    // TODO: Remove unused param "_setBx"
-    if (this.useAudioBuffer) {
-      if (ActiveMediaPlayer.AUDIO_BUFFERS) {
-        const $div = this.ps && this.ps.$div;
-        const buffer = ActiveMediaPlayer.AUDIO_BUFFERS[this.mc.recBuffer];
-        if (buffer) {
-          if (this.mc.type === 'RECORD_AUDIO') {
-            buffer.record($div);
-          } else {
-            buffer.play();
-          }
-        }
-      }
-    } else if (this.mbe) {
-      this.mbe.build(() => {
-        if (this.mbe.data) {
-          if (this.mbe.type === 'midi') {
-            this.mbe.data.playTo = this.mc.to || 0;
-          } else {
-            let armed = false;
-            const $player = $(this.mbe.data);
-            // Clear previous event handlers
-            $player.off();
-            // If there is a time fragment specified, prepare to stop when the `to` position is reached
-            if (this.mc.to > 0) {
-              $player.on('timeupdate', () => {
-                if (armed && this.mbe.data.currentTime >= this.mc.to / 1000) {
-                  $player.off('timeupdate');
-                  this.mbe.data.pause();
-                }
-              });
-            }
-            // Launch the media despite of its readyState
-            armed = true;
-          }
-          if (!this.mbe.data.paused && !this.mbe.data.ended && this.mbe.data.currentTime)
-            this.mbe.data.pause();
-          // Seek the media position
-          this.mbe.data.currentTime = this.mc.from > 0 ? this.mc.from / 1000 : 0;
-          this.mbe.data.play();
-        }
-      }, this.ps, true, this.mc.level);
-    }
-  }
-
-  /**
-   * Plays the media when available, without blocking the current thread.
-   * @param {module:boxes/ActiveBox.ActiveBox} [setBx] - The active box where this media will be placed (when video)
-   */
-  play(setBx) {
-    this.stopAllAudioBuffers();
-    this.playNow(setBx);
-  }
-
-  /**
-   * Stops the media playing
-   */
-  stop() {
-    if (this.useAudioBuffer)
-      this.stopAudioBuffer(this.mc.recBuffer);
-    else if (this.mbe && this.mbe.data && this.mbe.data.pause && !this.mbe.data.paused && !this.mbe.data.ended && this.mbe.data.currentTime)
-      this.mbe.data.pause();
-  }
-
-  /**
-   * Frees all resources used by this player
-   */
-  clear() {
-    this.stop();
-    if (this.useAudioBuffer)
-      this.clearAudioBuffer(this.mc.recBuffer);
-  }
-
-  /**
-   * Clears the specified audio buffer
-   * @param {number} buffer - Index of the buffer in {@link module:media/ActiveMediaPlayer.ActiveMediaPlayer#AUDIO_BUFFERS AUDIO_BUFFERS}
-   */
-  clearAudioBuffer(buffer) {
-    if (ActiveMediaPlayer.AUDIO_BUFFERS &&
-      buffer >= 0 && buffer < ActiveMediaPlayer.AUDIO_BUFFERS.length &&
-      ActiveMediaPlayer.AUDIO_BUFFERS[buffer]) {
-      ActiveMediaPlayer.AUDIO_BUFFERS[buffer].clear();
-      ActiveMediaPlayer.AUDIO_BUFFERS[buffer] = null;
-    }
-  }
-
-  /**
-   * Clears all audio buffers
-   */
-  clearAllAudioBuffers() {
-    if (ActiveMediaPlayer.AUDIO_BUFFERS)
-      ActiveMediaPlayer.AUDIO_BUFFERS.forEach((_buffer, n) => this.clearAudioBuffer(n));
-  }
-
-  /**
-   * Counts the number of active audio buffers
-   * @returns {number}
-   */
-  countActiveBuffers() {
-    return ActiveMediaPlayer.AUDIO_BUFFERS ? ActiveMediaPlayer.AUDIO_BUFFERS.reduce((c, ab) => c + ab ? 1 : 0, 0) : 0;
-  }
-
-  /**
-   * Stops the playing or recording actions of all audio buffers
-   */
-  stopAllAudioBuffers() {
-    if (ActiveMediaPlayer.AUDIO_BUFFERS)
-      ActiveMediaPlayer.AUDIO_BUFFERS.forEach(ab => ab ? ab.stop() : null);
-  }
-
-  /**
-   * Stops a specific audio buffer
-   * @param {number} buffer - Index of the buffer in {@link module:media/ActiveMediaPlayer.ActiveMediaPlayer#AUDIO_BUFFERS AUDIO_BUFFERS}
-   */
-  stopAudioBuffer(buffer) {
-    if (ActiveMediaPlayer.AUDIO_BUFFERS &&
-      buffer >= 0 && buffer < ActiveMediaPlayer.AUDIO_BUFFERS.length &&
-      ActiveMediaPlayer.AUDIO_BUFFERS[buffer])
-      ActiveMediaPlayer.AUDIO_BUFFERS[buffer].stop();
-  }
-
-  /**
-   * Checks the position of visual components after a displacement or resizing of its container
-   * @param {module:boxes/ActiveBox.ActiveBox} _bxi - The container where this player is hosted
-   */
-  checkVisualComponentBounds(_bxi) {
-    // does nothing
-  }
-
-  /**
-   * Sets the visual component of this player visible or invisible
-   * @param {boolean} _state - `true` for visible
-   */
-  setVisualComponentVisible(_state) {
-    // TODO: Implement setVisualComponentVisible
-  }
-
-  /**
-   * Sets the ActiveBox associated to this media player
-   * @param {module:boxes/ActiveBox.ActiveBox} setBx - The new container of this media. Can be `null`.
-   */
-  linkTo(setBx) {
-    this.bx = setBx;
-    if (this.bx && this.$visualComponent)
-      this.bx.setHostedComponent(this.$visualComponent);
-  }
-}
-
-Object.assign(ActiveMediaPlayer.prototype, {
-  /**
-   * The MediaContent associated to this player.
-   * @name module:media/ActiveMediaPlayer.ActiveMediaPlayer#mc
-   * @type {module:media/MediaContent.MediaContent} */
-  mc: null,
-  /**
-   * The player to which this player belongs.
-   * @name module:media/ActiveMediaPlayer.ActiveMediaPlayer#ps
-   * @type {module:JClicPlayer.JClicPlayer} */
-  ps: null,
-  /**
-   * MediaPlayers should be linked to {@link module:boxes/ActiveBox.ActiveBox ActiveBox} objects.
-   * @name module:media/ActiveMediaPlayer.ActiveMediaPlayer#bx
-   * @type {module:boxes/ActiveBox.ActiveBox} */
-  bx: null,
-  /**
-   * The visual component for videos, usually a `video` HTML element
-   * @name module:media/ActiveMediaPlayer.ActiveMediaPlayer#$visualComponent
-   * @type {external:jQuery} */
-  $visualComponent: null,
-  /**
-   * When `true`, this player makes use of a recording audio buffer
-   * @name module:media/ActiveMediaPlayer.ActiveMediaPlayer#useAudioBuffer
-   * @type {boolean} */
-  useAudioBuffer: false,
-  /**
-   * The {@link module:bads/MediaBagElement.MediaBagElement} containing the reference to the media to be played
-   * @name module:media/ActiveMediaPlayer.ActiveMediaPlayer#mbe
-   * @type {module:bags/MediaBagElement.MediaBagElement} */
-  mbe: null,
-});
-
-/**
- * Recording of audio is enabled only when `navigator.getUserMedia` and `MediaRecorder` are defined
- * In 02-Mar-2016 this is implemented only in Firefox 41 and Chrome 49 or later.
- * See: {@link https://addpipe.com/blog/mediarecorder-api}
- * @type Boolean
- */
-ActiveMediaPlayer.REC_ENABLED = typeof MediaRecorder !== 'undefined' && typeof navigator !== 'undefined';
-
-if (ActiveMediaPlayer.REC_ENABLED) {
-  navigator.getUserMedia = navigator.getUserMedia ||
-    navigator.webkitGetUserMedia ||
-    navigator.mozGetUserMedia ||
-    navigator.msGetUserMedia;
-}
-
-/**
- * Audio buffers used for recording and playing voice are stored in a static array because
- * they are common to all instances of {@link module:media/ActiveMediaPlayer.ActiveMediaPlayer ActiveMediaPlayer}
- * Only initialized when {@link module:media/ActiveMediaPlayer.ActiveMediaPlayer#REC_ENABLED REC_ENABLED} is `true`.
- * @type {external:AudioBuffer[]} */
-ActiveMediaPlayer.AUDIO_BUFFERS = ActiveMediaPlayer.REC_ENABLED ? [] : null;
-
-export default ActiveMediaPlayer;

package/src/media/AudioBuffer.js

@@ -1,219 +0,0 @@
-/**
- *  File    : media/EventSoundsElement.js
- *  Created : 01/04/2015
- *  By      : Francesc Busquets <francesc@gmail.com>
- *
- *  JClic.js
- *  An HTML5 player of JClic activities
- *  https://projectestac.github.io/jclic.js
- *
- *  @source https://github.com/projectestac/jclic.js
- *
- *  @license EUPL-1.2
- *  @licstart
- *  (c) 2000-2020 Educational Telematic Network of Catalonia (XTEC)
- *
- *  Licensed under the EUPL, Version 1.1 or -as soon they will be approved by
- *  the European Commission- subsequent versions of the EUPL (the "Licence");
- *  You may not use this work except in compliance with the Licence.
- *
- *  You may obtain a copy of the Licence at:
- *  https://joinup.ec.europa.eu/software/page/eupl
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the Licence is distributed on an "AS IS" basis, WITHOUT
- *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- *  Licence for the specific language governing permissions and limitations
- *  under the Licence.
- *  @licend
- *  @module
- */
-
-/* global navigator, window, document, Blob, URL, MediaRecorder */
-
-import { log } from '../Utils.js';
-
-/**
- * The AudioBuffer object provides sound recording and replaying to activities.
- */
-export class AudioBuffer {
-  /**
-   * AudioBuffer constructor
-   * @param {number} [seconds] - The maximum amount of time allowed to be recorded by this AudioBuffer
-   */
-  constructor(seconds) {
-    if (navigator && navigator.mediaDevices && navigator.mediaDevices.getUserMedia)
-      this.enabled = true;
-    if (seconds)
-      this.seconds = seconds;
-    this.chunks = [];
-  }
-
-  /**
-   * Starts playing the currently recorded audio, if any.
-   */
-  play() {
-    this.stop();
-    if (this.mediaPlayer) {
-      this.mediaPlayer.currentTime = 0;
-      this.mediaPlayer.play();
-    } else {
-      this.playWhenFinished = true;
-    }
-  }
-
-  /**
-   * Stops the current operation, either recording or playing audio
-   */
-  stop() {
-    if (this.mediaRecorder && this.mediaRecorder.state === 'recording')
-      this.mediaRecorder.stop();
-    else if (this.mediaPlayer && !this.mediaPlayer.paused)
-      this.mediaPlayer.pause();
-  }
-
-  /**
-   * Starts recording audio, or stops the recording if already started.
-   * @param {external:jQuery} [$div] - Optional `div` element where the recording is performed, as a jQuery ref.
-   */
-  record($div) {
-    if (this.mediaRecorder && this.mediaRecorder.state === 'recording')
-      this.mediaRecorder.stop();
-    else if (this.enabled) {
-      this.stop();
-      this.mediaPlayer = null;
-
-      navigator.mediaDevices.getUserMedia({ audio: true, video: false })
-        .then(mediaStream => {
-
-          this.mediaRecorder = new MediaRecorder(mediaStream);
-
-          this.mediaRecorder.ondataavailable = ev => this.chunks.push(ev.data);
-
-          this.mediaRecorder.onerror = err => {
-            log('error', `Error recording audio: ${err}`);
-            this.mediaRecorder = null;
-          };
-
-          this.mediaRecorder.onstart = () => {
-            log('debug', 'Recording audio started');
-            this.visualFeedbak(true, $div);
-          };
-
-          this.mediaRecorder.onstop = () => {
-            log('debug', 'Recording audio finished');
-            this.visualFeedbak(false, $div);
-
-            if (this.timeoutID) {
-              window.clearTimeout(this.timeoutID);
-              this.timeoutID = null;
-            }
-
-            const options = {};
-            if (this.chunks.length > 0 && this.chunks[0].type)
-              options.type = this.chunks[0].type;
-            const blob = new Blob(this.chunks, options);
-            this.chunks = [];
-            this.mediaPlayer = document.createElement('audio');
-            this.mediaPlayer.src = URL.createObjectURL(blob);
-            this.mediaPlayer.pause();
-            this.mediaRecorder = null;
-            if (this.playWhenFinished) {
-              this.playWhenFinished = false;
-              this.mediaPlayer.play();
-            }
-          };
-
-          this.mediaRecorder.onwarning = ev => log('warn', `Warning recording audio: ${ev}`);
-
-          this.playWhenFinished = false;
-
-          this.mediaRecorder.start();
-
-          this.timeoutID = window.setTimeout(() => {
-            if (this.mediaRecorder);
-            this.mediaRecorder.stop();
-          }, this.seconds * 1000);
-        })
-        .catch(err => {
-          log('error', err.toString());
-          this.visualFeedbak(false, $div);
-        });
-    }
-  }
-
-  /**
-   * Set visual feedback to the user while the system is recording audio
-   * Currently changes the cursor pointer associated to the HTML element
-   * containing the recorder.
-   * @param {boolean} enabled - Flag indicating if the visual feedback should be active or inactive
-   * @param {external:jQuery} [$div] - Optional `div` element where the recording is performed, as a jQuery ref.
-   */
-  visualFeedbak(enabled, $div) {
-    if ($div)
-      $div.css('cursor', enabled ? 'progress' : 'inherit');
-  }
-
-  /**
-   * Clears all data associated to this AudioBuffer
-   */
-  clear() {
-    this.stop();
-    this.mediaPlayer = null;
-  }
-}
-
-Object.assign(AudioBuffer.prototype, {
-  /**
-   * AudioBuffer is enabled only in browsers with `navigator.MediaDevices.getuserMedia`
-   * @name module:media/AudioBuffer.AudioBuffer#enabled
-   * @type {boolean}
-   */
-  enabled: false,
-  /**
-   * Maximum length of recordings allowed to this AudioBuffer (in seconds)
-   * @name module:media/AudioBuffer.AudioBuffer#seconds
-   * @type {number}
-   */
-  seconds: 20,
-  /**
-   * The object used to record audio data and convert it to a valid stream for the {@link module:media/ActiveMediaPlayer.ActiveMediaPlayer ActiveMediaPlayer}
-   * @name module:media/AudioBuffer.AudioBuffer#mediaRecorder
-   * @type {external:MediaRecorder}
-   */
-  mediaRecorder: null,
-  /**
-   * Array of data chunks collected during the recording
-   * @name module:media/AudioBuffer.AudioBuffer#chunks
-   * @type {external:Blob[]}
-   */
-  chunks: null,
-  /**
-   * The HTML audio element used to play the recorded sound
-   * @name module:media/AudioBuffer.AudioBuffer#mediaPlayer
-   * @type {external:HTMLAudioElement}
-   */
-  mediaPlayer: null,
-  /**
-   * The identifier of the timer launched to stop the recording when the maximum time is exceeded.
-   * This member is `null` when no timeout function is associated to this AudioBuffer
-   * @name module:media/AudioBuffer.AudioBuffer#timeoutID
-   * @type {number}
-   */
-  timeoutID: null,
-  /**
-   * Instructs this AudioBuffer recorder to start playing the collected audio at the end of the
-   * current `mediaRecorder` task.
-   * @name module:media/AudioBuffer.AudioBuffer#playWhenFinished
-   * @type {boolean}
-   */
-  playWhenFinished: false,
-});
-
-/**
- * Maximum amount of time allowed for recordings (in seconds)
- * @type {number}
- */
-AudioBuffer.MAX_RECORD_LENGTH = 180;
-
-export default AudioBuffer;

package/src/media/EventSounds.js

@@ -1,169 +0,0 @@
-/**
- *  File    : media/EventSounds.js
- *  Created : 01/04/2015
- *  By      : Francesc Busquets <francesc@gmail.com>
- *
- *  JClic.js
- *  An HTML5 player of JClic activities
- *  https://projectestac.github.io/jclic.js
- *
- *  @source https://github.com/projectestac/jclic.js
- *
- *  @license EUPL-1.2
- *  @licstart
- *  (c) 2000-2020 Educational Telematic Network of Catalonia (XTEC)
- *
- *  Licensed under the EUPL, Version 1.1 or -as soon they will be approved by
- *  the European Commission- subsequent versions of the EUPL (the "Licence");
- *  You may not use this work except in compliance with the Licence.
- *
- *  You may obtain a copy of the Licence at:
- *  https://joinup.ec.europa.eu/software/page/eupl
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the Licence is distributed on an "AS IS" basis, WITHOUT
- *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- *  Licence for the specific language governing permissions and limitations
- *  under the Licence.
- *  @licend
- *  @module
- */
-
-import $ from 'jquery';
-import EventSoundsElement from './EventSoundsElement.js';
-import { getTriState, getAttr, setAttr, DEFAULT } from '../Utils.js';
-
-// Use Webpack to import MP3 files
-import start from './sounds/start.mp3';
-import click from './sounds/click.mp3';
-import actionOk from './sounds/actionOk.mp3';
-import actionError from './sounds/actionError.mp3';
-import finishedOk from './sounds/finishedOk.mp3';
-import finishedError from './sounds/finishedError.mp3';
-
-/**
- * The EventSounds objects contains specific sounds to be played when JClic events are fired:
- * - start
- * - click
- * - actionError
- * - actionOk
- * - finishedError
- * - finishedOk
- *
- * The sounds are stored in an array of {@link module:media/EventSoundsElement EventSoundsElement} objects.
- */
-export class EventSounds {
-  /**
-   * EventSounds constructor
-   * @param {module:media/EventSounds.EventSounds} [parent] - Another EventSounds object that will act as a parent of this one,
-   * used to resolve which sound must be played for events when not defined here.
-   */
-  constructor(parent) {
-    if (parent) {
-      this.elements = Object.assign({}, this.elements, parent.elements);
-      this.enabled = parent.enabled;
-    }
-  }
-
-  /**
-   * Reads the object properties from an XML element
-   * @param {external:jQuery} $xml - The XML element to be parsed
-   */
-  setProperties($xml) {
-    this.enabled = getTriState($xml.attr('enabled'), this.enabled);
-    $xml.children().each((_n, child) => {
-      const id = child.getAttribute('id');
-      this.elements[id] = new EventSoundsElement(id);
-      this.elements[id].setProperties($(child));
-    });
-    return this;
-  }
-
-  /**
-   * Gets a object with the basic attributes needed to rebuild this instance excluding functions,
-   * parent references, constants and also attributes retaining the default value.
-   * The resulting object is commonly usued to serialize elements in JSON format.
-   * @returns {object} - The resulting object, with minimal attrributes
-   */
-  getAttributes() {
-    return getAttr(this, [
-      `enabled|${DEFAULT}`,
-      'elements',
-    ]);
-  }
-
-  /**
-   * Reads the properties of this EventSounds from a data object
-   * @param {object} data - The data object to be parsed
-   * @returns {module:media/EventSounds.EventSounds}
-   */
-  setAttributes(data) {
-    return setAttr(this, data, [
-      'enabled',
-      { key: 'elements', fn: EventSoundsElement, group: 'object' },
-    ]);
-  }
-
-  /**
-   * Instantiates the audio objects needed to play event sounds
-   * @param {module:JClicPlayer.JClicPlayer} ps
-   * @param {module:bags/MediaBag.MediaBag} mediaBag
-   */
-  realize(ps, mediaBag) {
-    // Values are {EventSoundElement} objects
-    $.each(this.elements, (key, value) => value.realize(ps, mediaBag));
-  }
-
-  /**
-   * Plays a specific event sound
-   * @param {string} eventName - The identifier of the event to be played
-   */
-  play(eventName) {
-    if (this.globalEnabled && this.enabled) {
-      const sound = this.elements[eventName];
-      if (sound && sound.enabled)
-        sound.play();
-    }
-  }
-}
-
-/**
- * Audio data for default event sounds
- * @name module:media/EventSounds.EventSounds.MEDIA
- * @type {object} */
-EventSounds.MEDIA = {
-  start,
-  click,
-  actionOk,
-  actionError,
-  finishedOk,
-  finishedError,
-};
-
-Object.assign(EventSounds.prototype, {
-  /**
-   * Collection of {@link module:media/EventSoundsElement EventSoundsElement} objects
-   * @name module:media/EventSounds.EventSounds#elements
-   * @type {object} */
-  elements: {
-    start: new EventSoundsElement('start', EventSounds.MEDIA.start),
-    click: new EventSoundsElement('click', EventSounds.MEDIA.click),
-    actionOk: new EventSoundsElement('actionOk', EventSounds.MEDIA.actionOk),
-    actionError: new EventSoundsElement('actionError', EventSounds.MEDIA.actionError),
-    finishedOk: new EventSoundsElement('finishedOk', EventSounds.MEDIA.finishedOk),
-    finishedError: new EventSoundsElement('finishedError', EventSounds.MEDIA.finishedError)
-  },
-  /**
-   * Whether this event sounds are enabled or not
-   * @name module:media/EventSounds.EventSounds#enabled
-   * @type {number} */
-  enabled: DEFAULT,
-  /**
-   * This attribute is intended to be used at prototype level, to indicate a globally disabled
-   * or enabled state.
-   * @name module:media/EventSounds.EventSounds#globalEnabled
-   * @type {boolean} */
-  globalEnabled: true,
-});
-
-export default EventSounds;