speechrecorderng 2.22.4 → 2.22.5

package/esm2020/lib/speechrecorder/session/basicrecorder.mjs

@@ -0,0 +1,283 @@
+import { TransportActions } from "./controlpanel";
+import { Browser, UserAgentBuilder } from "../../utils/ua-parser";
+import { MessageDialog } from "../../ui/message_dialog";
+import { LevelMeasure, StreamLevelMeasure } from "../../audio/dsp/level_measure";
+import { Action } from "../../action/action";
+import { MIN_DB_LEVEL } from "../../ui/recordingitem_display";
+export const FORCE_REQUEST_AUDIO_PERMISSIONS = false;
+export const RECFILE_API_CTX = 'recfile';
+export const MAX_RECORDING_TIME_MS = 1000 * 60 * 60 * 60; // 1 hour
+export const LEVEL_BAR_INTERVALL_SECONDS = 0.1; // 100ms
+export class BasicRecorder {
+    constructor(dialog, sessionService) {
+        this.dialog = dialog;
+        this.sessionService = sessionService;
+        this.statusMsg = '';
+        this.statusWaiting = false;
+        this.readonly = false;
+        this.processingRecording = false;
+        this.ac = null;
+        this._selectedDeviceId = undefined;
+        this._channelCount = 2;
+        this._session = null;
+        this.uploadProgress = 100;
+        this.uploadStatus = 'ok';
+        this.audioSignalCollapsed = true;
+        this.peakLevelInDb = MIN_DB_LEVEL;
+        this.displayLevelInfos = null;
+        this.displayAudioClip = null;
+        this.audioFetchSubscription = null;
+        this.destroyed = false;
+        this.navigationDisabled = true;
+        this.userAgent = UserAgentBuilder.userAgent();
+        console.debug("Detected platform: " + this.userAgent.detectedPlatform);
+        console.debug("Detected browser: " + this.userAgent.detectedBrowser);
+        this.transportActions = new TransportActions();
+        this.playStartAction = new Action('Play');
+        this.levelMeasure = new LevelMeasure();
+        this.streamLevelMeasure = new StreamLevelMeasure();
+        this.selCaptureDeviceId = null;
+    }
+    set audioDevices(audioDevices) {
+        this._audioDevices = audioDevices;
+    }
+    set autoGainControlConfigs(autoGainControlConfigs) {
+        this._autoGainControlConfigs = autoGainControlConfigs;
+    }
+    set channelCount(channelCount) {
+        this._channelCount = channelCount;
+    }
+    set session(session) {
+        this._session = session;
+    }
+    get session() {
+        return this._session;
+    }
+    enableStartUserGesture() {
+        this.statusAlertType = 'info';
+        this.statusMsg = 'Ready.';
+    }
+    start() {
+        this.statusAlertType = 'info';
+        this.statusMsg = 'Starting session...';
+        this.statusWaiting = false;
+        if (this._session) {
+            if (this._session.sealed) {
+                this.readonly = true;
+                this.statusMsg = 'Session sealed!';
+                //let dialogRef = this.dialog.open(SessionSealedDialog, {});
+                this.dialog.open(MessageDialog, {
+                    data: {
+                        type: 'error',
+                        title: 'Error',
+                        msg: "This session is sealed. Recordings cannot be added anymore.",
+                        advise: 'Please ask your experimenter what to do (e.g start a new session).',
+                    }
+                });
+            }
+            else {
+                let body = {};
+                if (this._session.status === "CREATED") {
+                    this._session.status = "LOADED";
+                    body.status = this._session.status;
+                    if (!this._session.loadedDate) {
+                        this._session.loadedDate = new Date();
+                        body.loadedDate = this._session.loadedDate;
+                    }
+                }
+                else {
+                    this._session.restartedDate = new Date();
+                    body.restartedDate = this._session.restartedDate;
+                }
+                this.sessionService.patchSessionObserver(this._session, body).subscribe();
+            }
+        }
+        // Check browser compatibility
+        if (this.userAgent.detectedBrowser === Browser.Safari && this._channelCount > 1) {
+            let eMsg = "Error: Safari browser does not support stereo recordings.";
+            console.error(eMsg);
+            this.dialog.open(MessageDialog, {
+                data: {
+                    type: 'error',
+                    title: 'Browser not supported',
+                    msg: eMsg,
+                    advice: "Please use a supported browser, e.g. Mozilla Firefox."
+                }
+            });
+        }
+        //console.log("Session ID: "+this._session.session+ " status: "+this._session.status)
+        this._selectedDeviceId = undefined;
+        if (!this.readonly && this.ac && (FORCE_REQUEST_AUDIO_PERMISSIONS || (this._audioDevices && this._audioDevices.length > 0))) {
+            this.statusMsg = 'Requesting audio permissions...';
+            this.statusAlertType = 'info';
+            this.ac.deviceInfos((mdis) => {
+                let audioCaptureDeviceAvail = false;
+                let audioPlayDeviceAvail = false;
+                if (mdis) {
+                    if (this.ac) {
+                        this.ac.printDevices(mdis);
+                    }
+                    if (mdis.length > 0) {
+                        for (let mdii = 0; mdii < mdis.length; mdii++) {
+                            let mdi = mdis[mdii];
+                            let kind = mdi.kind;
+                            if (kind === "audioinput") {
+                                audioCaptureDeviceAvail = true;
+                            }
+                            else if (kind === "audiooutput") {
+                                audioPlayDeviceAvail = true;
+                            }
+                        }
+                    }
+                    if (this._session && this._session.type !== 'TEST_DEF_A' && this._audioDevices && this._audioDevices.length > 0) {
+                        let fdi = null;
+                        for (let adI = 0; adI < this._audioDevices.length; adI++) {
+                            let ad = this._audioDevices[adI];
+                            if (ad.playback) {
+                                // project audio device config for playback device
+                                // not used for now
+                                continue;
+                            }
+                            for (let mdii = 0; mdii < mdis.length; mdii++) {
+                                let mdi = mdis[mdii];
+                                let kind = mdi.kind;
+                                if (kind === "audioinput") {
+                                    audioCaptureDeviceAvail = true;
+                                }
+                                else if (kind === "audiooutput") {
+                                    audioPlayDeviceAvail = true;
+                                }
+                                if (ad.regex) {
+                                    //console.log("Match?: \'"+mdi.label+"\' \'"+ad.name+"\'");
+                                    if (mdi.label.match(ad.name)) {
+                                        fdi = mdi;
+                                        //console.log("Match!");
+                                    }
+                                }
+                                else {
+                                    if (mdi.label.trim() === ad.name.trim()) {
+                                        fdi = mdi;
+                                    }
+                                }
+                                if (fdi) {
+                                    break;
+                                }
+                            }
+                            if (fdi) {
+                                break;
+                            }
+                        }
+                        if (fdi) {
+                            // matching device found
+                            // Not able to open device here since Chrome 71
+                            // Chrome 71 requires a user gesture before the AudioContext can be resumed
+                            // sessionmanager.ts:712 Open session with default audio device for 1 channels
+                            // capture.ts:128 The AudioContext was not allowed to start. It must be resumed (or created) after a user gesture on the page. https://goo.gl/7K7WLu
+                            // push../projects/speechrecorderng/src/lib/audio/capture/capture.ts.AudioCapture.open @ capture.ts:128
+                            //this.ac.open(this._channelCount, fdi.deviceId);
+                            console.info("Set selected audio device: \'" + fdi.label + "\' Id: \'" + fdi.deviceId + "\'");
+                            this._selectedDeviceId = fdi.deviceId;
+                            this.enableStartUserGesture();
+                        }
+                        else {
+                            // device not found
+                            this.statusMsg = 'ERROR: Required audio device not available!';
+                            this.statusAlertType = 'error';
+                            this.readonly = true;
+                            this.dialog.open(MessageDialog, {
+                                data: {
+                                    type: 'error',
+                                    title: 'Required audio device',
+                                    msg: "Required audio device not found",
+                                    advice: "Please connect a suitable audio device for this project and retry (press the browser reload button)."
+                                }
+                            });
+                        }
+                    }
+                    else {
+                        if (!audioCaptureDeviceAvail && !audioPlayDeviceAvail) {
+                            // no device found
+                            this.statusMsg = 'ERROR: No audio device available!';
+                            this.statusAlertType = 'warn';
+                            //this.readonly = true;
+                            this.dialog.open(MessageDialog, {
+                                data: {
+                                    type: 'warn',
+                                    title: 'No audio device',
+                                    msg: "No audio device found",
+                                    advice: "Please connect an audio device and retry (press the browser reload button) or try to continue anyway."
+                                }
+                            });
+                        }
+                        else {
+                            if (!this.readonly && !audioCaptureDeviceAvail) {
+                                // no device found
+                                this.statusMsg = 'WARNING: No audio capture device available!';
+                                this.statusAlertType = 'warning';
+                                //this.readonly = true;
+                                this.dialog.open(MessageDialog, {
+                                    data: {
+                                        type: 'warning',
+                                        title: 'No audio capture device',
+                                        msg: "No audio capture device found",
+                                        advice: "Please connect an audio capture device and retry (press the browser reload button) or try to continue anyway."
+                                    }
+                                });
+                            }
+                            // Safari does not list playback devices
+                            if (!audioPlayDeviceAvail) {
+                                // Firefox does not enumerate audiooutput devices
+                                // Do not show this warning, because it would always appear on Firefox
+                                // When https://bugzilla.mozilla.org/show_bug.cgi?id=1498512 is fixed the warning can be enabled for Firefox as well
+                                // It is already implemneted but kept behind a preference setting https://bugzilla.mozilla.org/show_bug.cgi?id=1152401
+                                // Output devices are listed if about:config media.setsinkid.enabled=true
+                                // but default setting is false
+                                // Same problem with Safari
+                                if (!(this.userAgent.detectedBrowser === Browser.Safari || this.userAgent.detectedBrowser === Browser.Firefox)) {
+                                    // no device found
+                                    this.statusMsg = 'WARNING: No audio playback device available!';
+                                    this.statusAlertType = 'warn';
+                                    //this.readonly = true;
+                                    this.dialog.open(MessageDialog, {
+                                        data: {
+                                            type: 'warn',
+                                            title: 'No audio playback device',
+                                            msg: "No audio playback device found",
+                                            advice: "Please connect an audio playback device and retry (press the browser reload button) or try to continue anyway."
+                                        }
+                                    });
+                                }
+                            }
+                        }
+                        // Not able to open device here since Chrome 71
+                        // Chrome 71 requires a user gesture before the AudioContext can be resumed
+                        // sessionmanager.ts:712 Open session with default audio device for 1 channels
+                        // capture.ts:128 The AudioContext was not allowed to start. It must be resumed (or created) after a user gesture on the page. https://goo.gl/7K7WLu
+                        // push../projects/speechrecorderng/src/lib/audio/capture/capture.ts.AudioCapture.open @ capture.ts:128
+                        //console.log("Open session with default audio device for "+this._channelCount+" channels");
+                        //this.ac.open(this._channelCount);
+                        // enable start gesture anyway
+                        this.enableStartUserGesture();
+                    }
+                }
+            });
+        }
+    }
+    closed() {
+        this.statusAlertType = 'info';
+        this.statusMsg = 'Session closed.';
+    }
+    error(msg = 'An unknown error occured during recording.', advice = 'Please retry.') {
+        this.statusMsg = 'ERROR: Recording.';
+        this.statusAlertType = 'error';
+        this.dialog.open(MessageDialog, {
+            data: {
+                type: 'error',
+                title: 'Recording error',
+                msg: msg,
+                advice: advice
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"basicrecorder.js","sourceRoot":"","sources":["../../../../../../projects/speechrecorderng/src/lib/speechrecorder/session/basicrecorder.ts"],"names":[],"mappings":"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","sourcesContent":["import {TransportActions} from \"./controlpanel\";\r\nimport {Browser, UserAgent, UserAgentBuilder} from \"../../utils/ua-parser\";\r\nimport {MatDialog} from \"@angular/material/dialog\";\r\nimport {MessageDialog} from \"../../ui/message_dialog\";\r\nimport {Session} from \"./session\";\r\nimport {SessionService} from \"./session.service\";\r\nimport {AudioCapture} from \"../../audio/capture/capture\";\r\nimport {AudioDevice, AutoGainControlConfig} from \"../project/project\";\r\nimport {LevelInfos, LevelMeasure, StreamLevelMeasure} from \"../../audio/dsp/level_measure\";\r\nimport {AudioPlayer} from \"../../audio/playback/player\";\r\nimport {Subscription} from \"rxjs\";\r\nimport {AudioClip} from \"../../audio/persistor\";\r\nimport {Action} from \"../../action/action\";\r\nimport {MIN_DB_LEVEL} from \"../../ui/recordingitem_display\";\r\n\r\nexport const FORCE_REQUEST_AUDIO_PERMISSIONS=false;\r\nexport const RECFILE_API_CTX = 'recfile';\r\nexport const MAX_RECORDING_TIME_MS = 1000 * 60 * 60 * 60; // 1 hour\r\n\r\nexport const LEVEL_BAR_INTERVALL_SECONDS = 0.1;  // 100ms\r\n\r\nexport class BasicRecorder {\r\n  protected userAgent:UserAgent;\r\n  statusMsg: string='';\r\n  statusAlertType!: string;\r\n  statusWaiting: boolean=false;\r\n  readonly=false;\r\n  processingRecording=false;\r\n  ac: AudioCapture|null=null;\r\n  // Property audioDevices from project config: list of names of allowed audio devices.\r\n  protected _audioDevices: Array<AudioDevice> | null| undefined;\r\n  protected _selectedDeviceId:string|undefined=undefined;\r\n  protected selCaptureDeviceId: ConstrainDOMString | null;\r\n  protected _channelCount = 2;\r\n  protected _autoGainControlConfigs: Array<AutoGainControlConfig> | null| undefined;\r\n\r\n  _session: Session|null=null;\r\n\r\n  transportActions: TransportActions;\r\n  playStartAction: Action<void>;\r\n\r\n  uploadProgress: number = 100;\r\n  uploadStatus: string = 'ok'\r\n  audioSignalCollapsed = true;\r\n\r\n  protected streamLevelMeasure: StreamLevelMeasure;\r\n  protected levelMeasure: LevelMeasure;\r\n  peakLevelInDb:number=MIN_DB_LEVEL;\r\n  displayLevelInfos: LevelInfos | null=null;\r\n  protected _controlAudioPlayer!: AudioPlayer;\r\n  displayAudioClip: AudioClip | null=null;\r\n  protected audioFetchSubscription:Subscription|null=null;\r\n\r\n  protected destroyed=false;\r\n\r\n  protected navigationDisabled=true;\r\n\r\n  constructor(  public dialog: MatDialog,protected sessionService:SessionService) {\r\n    this.userAgent=UserAgentBuilder.userAgent();\r\n    console.debug(\"Detected platform: \"+this.userAgent.detectedPlatform);\r\n    console.debug(\"Detected browser: \"+this.userAgent.detectedBrowser);\r\n    this.transportActions = new TransportActions();\r\n    this.playStartAction = new Action('Play');\r\n    this.levelMeasure = new LevelMeasure();\r\n    this.streamLevelMeasure = new StreamLevelMeasure();\r\n    this.selCaptureDeviceId = null;\r\n  }\r\n\r\n  set audioDevices(audioDevices: Array<AudioDevice> | null | undefined) {\r\n    this._audioDevices = audioDevices;\r\n  }\r\n\r\n  set autoGainControlConfigs(autoGainControlConfigs: Array<AutoGainControlConfig>|null|undefined){\r\n    this._autoGainControlConfigs=autoGainControlConfigs;\r\n  }\r\n\r\n  set channelCount(channelCount: number) {\r\n    this._channelCount = channelCount;\r\n  }\r\n\r\n  set session(session: Session|null) {\r\n    this._session = session;\r\n  }\r\n\r\n  get session():Session|null{\r\n    return this._session;\r\n  }\r\n\r\n  enableStartUserGesture() {\r\n    this.statusAlertType = 'info';\r\n    this.statusMsg = 'Ready.';\r\n  }\r\n\r\n  start() {\r\n    this.statusAlertType = 'info';\r\n    this.statusMsg = 'Starting session...';\r\n    this.statusWaiting=false;\r\n    if(this._session) {\r\n      if (this._session.sealed) {\r\n        this.readonly = true\r\n        this.statusMsg = 'Session sealed!';\r\n        //let dialogRef = this.dialog.open(SessionSealedDialog, {});\r\n        this.dialog.open(MessageDialog, {\r\n          data: {\r\n            type: 'error',\r\n            title: 'Error',\r\n            msg: \"This session is sealed. Recordings cannot be added anymore.\",\r\n            advise: 'Please ask your experimenter what to do (e.g start a new session).',\r\n          }\r\n        });\r\n      } else {\r\n        let body: any = {};\r\n        if (this._session.status === \"CREATED\") {\r\n          this._session.status = \"LOADED\";\r\n          body.status = this._session.status;\r\n          if (!this._session.loadedDate) {\r\n            this._session.loadedDate = new Date();\r\n            body.loadedDate = this._session.loadedDate;\r\n          }\r\n        } else {\r\n          this._session.restartedDate = new Date();\r\n          body.restartedDate = this._session.restartedDate;\r\n        }\r\n        this.sessionService.patchSessionObserver(this._session, body).subscribe()\r\n      }\r\n    }\r\n\r\n    // Check browser compatibility\r\n    if(this.userAgent.detectedBrowser===Browser.Safari && this._channelCount>1){\r\n      let eMsg=\"Error: Safari browser does not support stereo recordings.\";\r\n      console.error(eMsg);\r\n      this.dialog.open(MessageDialog, {\r\n        data: {\r\n          type: 'error',\r\n          title: 'Browser not supported',\r\n          msg: eMsg,\r\n          advice: \"Please use a supported browser, e.g. Mozilla Firefox.\"\r\n        }\r\n      })\r\n    }\r\n\r\n    //console.log(\"Session ID: \"+this._session.session+ \" status: \"+this._session.status)\r\n    this._selectedDeviceId=undefined;\r\n\r\n    if (!this.readonly && this.ac && (FORCE_REQUEST_AUDIO_PERMISSIONS || (this._audioDevices && this._audioDevices.length > 0))) {\r\n      this.statusMsg = 'Requesting audio permissions...';\r\n      this.statusAlertType = 'info';\r\n\r\n      this.ac.deviceInfos((mdis) => {\r\n        let audioCaptureDeviceAvail: boolean = false;\r\n        let audioPlayDeviceAvail: boolean = false;\r\n        if (mdis) {\r\n          if(this.ac) {\r\n            this.ac.printDevices(mdis);\r\n          }\r\n          if (mdis.length > 0) {\r\n            for (let mdii = 0; mdii < mdis.length; mdii++) {\r\n              let mdi = mdis[mdii];\r\n              let kind=mdi.kind;\r\n              if(kind === \"audioinput\"){\r\n                audioCaptureDeviceAvail=true;\r\n              }else if(kind=== \"audiooutput\"){\r\n                audioPlayDeviceAvail=true;\r\n              }\r\n            }\r\n          }\r\n\r\n          if (this._session && this._session.type !== 'TEST_DEF_A' && this._audioDevices && this._audioDevices.length > 0) {\r\n            let fdi: MediaDeviceInfo | null = null;\r\n            for (let adI = 0; adI < this._audioDevices.length; adI++) {\r\n              let ad = this._audioDevices[adI];\r\n              if (ad.playback) {\r\n                // project audio device config for playback device\r\n                // not used for now\r\n                continue;\r\n              }\r\n              for (let mdii = 0; mdii < mdis.length; mdii++) {\r\n                let mdi = mdis[mdii];\r\n                let kind=mdi.kind;\r\n                if(kind === \"audioinput\"){\r\n                  audioCaptureDeviceAvail=true;\r\n                }else if(kind=== \"audiooutput\"){\r\n                  audioPlayDeviceAvail=true;\r\n                }\r\n                if (ad.regex) {\r\n                  //console.log(\"Match?: \\'\"+mdi.label+\"\\' \\'\"+ad.name+\"\\'\");\r\n                  if (mdi.label.match(ad.name)) {\r\n                    fdi = mdi;\r\n                    //console.log(\"Match!\");\r\n                  }\r\n                } else {\r\n                  if (mdi.label.trim() === ad.name.trim()) {\r\n                    fdi = mdi;\r\n                  }\r\n                }\r\n                if (fdi) {\r\n                  break;\r\n                }\r\n              }\r\n              if (fdi) {\r\n                break;\r\n              }\r\n            }\r\n\r\n            if (fdi) {\r\n              // matching device found\r\n\r\n              // Not able to open device here since Chrome 71\r\n              // Chrome 71 requires a user gesture before the AudioContext can be resumed\r\n              // sessionmanager.ts:712 Open session with default audio device for 1 channels\r\n              // capture.ts:128 The AudioContext was not allowed to start. It must be resumed (or created) after a user gesture on the page. https://goo.gl/7K7WLu\r\n              // push../projects/speechrecorderng/src/lib/audio/capture/capture.ts.AudioCapture.open @ capture.ts:128\r\n\r\n              //this.ac.open(this._channelCount, fdi.deviceId);\r\n              console.info(\"Set selected audio device: \\'\" + fdi.label + \"\\' Id: \\'\" + fdi.deviceId + \"\\'\");\r\n              this._selectedDeviceId = fdi.deviceId;\r\n\r\n              this.enableStartUserGesture()\r\n            } else {\r\n              // device not found\r\n              this.statusMsg = 'ERROR: Required audio device not available!';\r\n              this.statusAlertType = 'error';\r\n              this.readonly = true;\r\n\r\n              this.dialog.open(MessageDialog, {\r\n                data: {\r\n                  type: 'error',\r\n                  title: 'Required audio device',\r\n                  msg: \"Required audio device not found\",\r\n                  advice: \"Please connect a suitable audio device for this project and retry (press the browser reload button).\"\r\n                }\r\n              })\r\n            }\r\n          }else{\r\n            if(!audioCaptureDeviceAvail && !audioPlayDeviceAvail){\r\n              // no device found\r\n              this.statusMsg = 'ERROR: No audio device available!';\r\n              this.statusAlertType = 'warn';\r\n              //this.readonly = true;\r\n\r\n              this.dialog.open(MessageDialog, {\r\n                data: {\r\n                  type: 'warn',\r\n                  title: 'No audio device',\r\n                  msg: \"No audio device found\",\r\n                  advice: \"Please connect an audio device and retry (press the browser reload button) or try to continue anyway.\"\r\n                }\r\n              })\r\n            }else {\r\n              if (!this.readonly && !audioCaptureDeviceAvail) {\r\n                // no device found\r\n                this.statusMsg = 'WARNING: No audio capture device available!';\r\n                this.statusAlertType = 'warning';\r\n                //this.readonly = true;\r\n\r\n                this.dialog.open(MessageDialog, {\r\n                  data: {\r\n                    type: 'warning',\r\n                    title: 'No audio capture device',\r\n                    msg: \"No audio capture device found\",\r\n                    advice: \"Please connect an audio capture device and retry (press the browser reload button) or try to continue anyway.\"\r\n                  }\r\n                })\r\n              }\r\n              // Safari does not list playback devices\r\n              if (!audioPlayDeviceAvail) {\r\n                // Firefox does not enumerate audiooutput devices\r\n                // Do not show this warning, because it would always appear on Firefox\r\n                // When https://bugzilla.mozilla.org/show_bug.cgi?id=1498512 is fixed the warning can be enabled for Firefox as well\r\n\r\n                // It is already implemneted but kept behind a preference setting https://bugzilla.mozilla.org/show_bug.cgi?id=1152401\r\n\r\n\r\n                // Output devices are listed if about:config media.setsinkid.enabled=true\r\n                // but default setting is false\r\n\r\n\r\n                // Same problem with Safari\r\n\r\n                if (!(this.userAgent.detectedBrowser===Browser.Safari || this.userAgent.detectedBrowser===Browser.Firefox)) {\r\n                  // no device found\r\n                  this.statusMsg = 'WARNING: No audio playback device available!';\r\n                  this.statusAlertType = 'warn';\r\n                  //this.readonly = true;\r\n\r\n                  this.dialog.open(MessageDialog, {\r\n                    data: {\r\n                      type: 'warn',\r\n                      title: 'No audio playback device',\r\n                      msg: \"No audio playback device found\",\r\n                      advice: \"Please connect an audio playback device and retry (press the browser reload button) or try to continue anyway.\"\r\n                    }\r\n                  })\r\n                }\r\n              }\r\n            }\r\n\r\n            // Not able to open device here since Chrome 71\r\n            // Chrome 71 requires a user gesture before the AudioContext can be resumed\r\n            // sessionmanager.ts:712 Open session with default audio device for 1 channels\r\n            // capture.ts:128 The AudioContext was not allowed to start. It must be resumed (or created) after a user gesture on the page. https://goo.gl/7K7WLu\r\n            // push../projects/speechrecorderng/src/lib/audio/capture/capture.ts.AudioCapture.open @ capture.ts:128\r\n            //console.log(\"Open session with default audio device for \"+this._channelCount+\" channels\");\r\n            //this.ac.open(this._channelCount);\r\n\r\n            // enable start gesture anyway\r\n            this.enableStartUserGesture()\r\n          }\r\n        }\r\n\r\n      });\r\n    }\r\n  }\r\n\r\n  closed() {\r\n    this.statusAlertType = 'info';\r\n    this.statusMsg = 'Session closed.';\r\n  }\r\n\r\n  error(msg='An unknown error occured during recording.',advice:string='Please retry.') {\r\n    this.statusMsg = 'ERROR: Recording.';\r\n    this.statusAlertType = 'error';\r\n    this.dialog.open(MessageDialog, {\r\n      data: {\r\n        type: 'error',\r\n        title: 'Recording error',\r\n        msg: msg,\r\n        advice: advice\r\n      }\r\n    });\r\n  }\r\n\r\n}\r\n"]}